Layers-API-Keras

Keras-TensorFlow
juan

Nota: (Las capas de Keras son los bloques de construcción principal de los Modelos-Keras. Cada capa recibe información de entrada, realiza algunos cálculos y genera unos datos. Esta datos ira a la siguiente capa como su entrada).

 

Layers-API-Keras

. Las capas “layers” son los componentes básicos de las Redes-Neuronales en Keras. Una capa consta de una función de cálculo de tensor de entrada y tensor de salida y algún estado contenido en las variables de TensorFlow los “Pesos”. Se actualizan cuando la capa “layers” recibe datos durante el entrenamiento y se almacenan en layer.weights. Keras ofrece una amplia gama de capas integradas, tenemos que tener en cuenta que crear capas “layers” personalizadas es muy común y fácil.

Definiendo TensorFlow & Keras:

  • TensorFlow es una capa de infraestructura para la programación diferenciable que se ocupa de tensores, variables y gradientes,
  • Keras es una interfaz de usuario para el Deep-Learning que se ocupa de capas, modelos, optimizadores, funciones de pérdida, métricas y más.

-. Keras sirve como API de alto nivel para TensorFlow, por lotanto Keras-API es lo que hace que TensorFlow sea relativamente simple y productivo. La clase Layer “capa” es la abstracción fundamental en Keras. encapsula un estado los Pesos y algunos cálculos. Tenemos muchas capas integradas disponibles, “.dense” , “.conv2D” , “.LSTMConv3DTransposeConvLSTM2D”etc.

. Empecemos por su configuración, realicemos un reseteo y carguemos las librerías y llamar una Instancia de Layers “capas” como si fuera una Función:

Reseteo:

  • In: import tensorflow as tf
  • In: tf.keras.backend.clear_session()

Librerías:

  • In: import numpy as np
  • In: import tensorflow as tf
  • In: from tensorflow import keras
  • In: from keras import layers

Llamar-Instancia:

  • In: layer = layers.Dense(32, activation=‘relu’)
  • In: inputs = tf.random.uniform(shape=(10, 20))
  • In: outputs = layer(inputs)

-. Las capas “layers” mantienen un estado, se actualizan cuando la capa recibe datos durante el entrenamiento y se almacenan en layer.weights, las Funciones no lo hacen.

Podemos verlo con layer.weights:

 

Relación de layers disponibles:

  • La clase de capa base
  • Activaciones de capas
  • Inicializadores de peso de capa
  • Regularizadores de peso de capa
  • Restricciones de peso de capa
  • Capas de núcleo
  • Capas de convolución
  • Agrupación de capas
  • Capas recurrentes
  • Capas de preprocesamiento
  • Capas de normalización
  • Capas de regularización
  • Capas de atención
  • Capas de remodelación
  • Combinar capas
  • Capas conectadas localmente
  • Capas de activación

Nota: A continuación veremos una descripción de listado anterior de las Layers”Capas”, con lo cual tendremos una compresión del conjunto de las Layer”Capas”.

 

Que es Layers–Base:

  • In: tf.keras.layers.Layer(
  • trainable=True, name=None, dtype=None, dynamic=False,
  • )

. Una Layers “Capa” es un objeto invocable que toma como entrada uno o más Tensores y que genera uno o más Tensores. Implica computación , definida en el método call(), y un estado variables de Pesos. El estado se puede crear en varios lugares.

Relación de Layers-Base disponibles:

  • Clase de capa
  • propiedad de los pesos
  • propiedad trainable_weights
  • propiedad non_trainable_weights
  • método add_weight
  • propiedad entrenable
  • método get_weights
  • método set_weights
  • método get_config
  • método add_loss
  • método add_metric
  • pérdidas de propiedad
  • propiedad de métricas
  • propiedad dinámica

 

Que es Layers–Funciones–Activación:

. La Funcion-Activaciones se pueden usar a través de una Activación-Layers “Capa” o a través del Activación-Argumento admitido por todas las capas delanteras.

Cargamos las librerías que faltan:

  • In: from keras import activations
  • In: from keras.models import Sequential
  • In: from keras.layers import Dense
  • In: model = Sequential()

Generación de Layers con Activación incorporada:

  • In: model.add(layers.Dense(64, activation=activations.relu))

Generación de Layers forma mas tradicional:

  • In: model.add(layers.Dense(64))
  • In: model.add(layers.Activation(activations.relu))

Activaciones integradas con identificador de cadena:

  • In: model.add(layers.Dense(64, activation=‘relu’))

Relación de Layers–Funciones–Activación disponibles:

  • relu función
  • sigmoid función
  • softmax función
  • softplus función
  • softsign función
  • tanh función
  • selu función
  • elu función
  • exponential función

 

Que es Inicializadores–Pesos–Layers:

-. Los Inicializadores se definen como la forma de establecer los Pesos-Aleatorios-Iniciales de las Layers-Keras. Los argumentos de utilizados para pasar Inicializadores a capas dependen de la capa. Es simplemente kernel_initializer y bias_initializer.

Cargamos las librería que falta:

  • In: from keras import initializers

Generamos la Layers:

  • In: layer = layers.Dense(
  • In: units=64,
  • In: kernel_initializer=initializers.RandomNormal(stddev=0.01),
  • In: bias_initializer=initializers.Zeros()
  • In )

Inicializadores ejecutarlos a través de su identificador de cadena:

  • In: layer = layers.Dense(
  • In: units=64,
  • In: kernel_initializer=‘random_normal’,
  • In: bias_initializer=‘zeros’
  • In: )

Relación de Inicializadores–Pesos–Layers disponibles:

  • RandomNormal
  • RandomUniform
  • TruncatedNormal
  • Zeros
  • Ones
  • GlorotNormal
  • GlorotUniform
  • HeNormal
  • HeUniform
  • Identity
  • Orthogonal
  • Constant
  • VarianceScaling

 

Que son Regularizadores-Peso-Layers:

-. Los Regularizadores nos permiten aplicar penalizaciones en los parámetros de las Layers o la actividad de las mismas, cuando podemos hacerlo “durante la optimización”. Estas penalizaciones se suman a la Función-Pérdida que optimiza la red. Estas penalizaciones o sanciones de Regularización se aplican por capa “Layers” .

Estas Layers nos presentan tres argumentos:

  • kernel_regularizer: Regularizador para aplicar una penalización en el núcleo de la capa
  • bias_regularizer: Regularizador para aplicar una penalización al sesgo de la capa
  • activity_regularizer: Regularizador para aplicar una penalización en la salida de la capa

Cargamos las librería que falta:

  • In: from keras import regularizers

Generamos la Layers:

  • In: layer = layers.Dense(
  • In: units=64,
  • In: kernel_regularizer=regularizers.L1L2(l1=1e-5, l2=1e-4),
  • In: bias_regularizer=regularizers.L2(1e-4),
  • In: activity_regularizer=regularizers.L2(1e-5)
  • In: )

-. Podemos acceder “ver” las penalizaciones de Regularización de una Layers, llamando al argumento layer.losses por supuesto después de “generar” , “llamar” a la Layers.

Relación de Regularizadores–Pesos–Layers disponibles:

  • L1
  • L2
  • L1L2
  • OrthogonalRegularizer

 

Que son Restricciones-Peso-Layers:

. El módulo tf.keras.constraints permiten establecer Restricciones en los parámetros del Modelo durante el proceso de entrenamiento. Son funciones de proyección por variable, que se aplican a la variable de destino después de cada actualización de gradiente cuando se usa fit().

Estas Layers nos presentan los siguientes argumentos:

  • kernel_constraint para la matriz de ponderaciones principal
  • bias_constraint por el sesgo.

Cargamos las librería que falta:

  • In: from keras.constraints import max_norm

Generamos la Layers:

  • In: model.add(Dense(64, kernel_constraint=max_norm(2.)))

Nota: En esta imagen a parte del tema que tratamos, incluyo todas las librerías que sean cargado hasta este momento, es importante incluirlas de lo contrario nos dará error, pongamos el ejemplo estamos tratando necesitamos, Dense , max_norm , model , etc.

Relación de Restricciones-Pesos–Layers disponibles:

  • MaxNorm
  • MinMaxNorm
  • NonNeg
  • UnitNorm
  • RadialConstraint

 

Que es Layers-Núcleo “Core”

. Las Core-Layers, conocidas como “Capas de alto nivel en Keras”, Core-Layers-Keras implementan operaciones fundamentales, que se utilizan en casi todos los tipos de arquitectura de Red-Neuronal. Las Layers más popular es Dense, es una Layers de las más simple de una Red-Neuronal totalmente conectada.

Entre las Layers–Núcleo mas utilizadas nos encontramos:

  • In: tf.keras.Input()
  • In: tf.keras.layers.Dense()
  • In: tf.keras.layers.Activation()

Relación de Core–Layers disponibles:

  • Input object
  • Dense layer
  • Activation layer
  • Embedding layer
  • Masking layer
  • Lambda layer

 

Que es Convolutión-Layers:

. Tomaremos una Layers del tipo convolutión-2D que es convolutión espacial sobre una imagen. Esta Layers crea un núcleo de convolución, y se convoluciona con la entrada de la Layers para producir un tensor de salidas. Las entradas son imágenes RGB de 28×28.

  • In: input_shape = (4, 28, 28, 3)
  • In: x = tf.random.normal(input_shape)
  • In: y = tf.keras.layers.Conv2D(2, 3, activation=‘relu’, input_shape=input_shape[1:])(x)
  • In: print(y.shape)

Nota: Pongamos un ejemplo extradido de una Red-Neuronal real, tendríamos dos lineas de interés del tema que nos ocupa, la primera seria importar la librería y la segunda seria la primera-layers-convolutional que encontramos.

  • In: from keras.layers.convolutional import Conv2D
  • In: conv1 = Conv2D(32, kernel_size=4, activation=‘relu’)(visible)

Relación de Convolutión–Layers disponibles:

  • Conv1D layer
  • Conv2D layer
  • Conv3D layer
  • SeparableConv1D layer
  • SeparableConv2D layer
  • DepthwiseConv2D layer
  • Conv1DTranspose layer
  • Conv2DTranspose layer
  • Conv3DTranspose layer

 

Que es Pooling–Layers “Agrupación”

. La adición de una Pooling-Layers “agrupación” después de la Layers-Convolucional es comúnmente utilizado para ordenar capas dentro de una Red-Neuronal-Convolucional, que puede repetirse una o más veces en un Modelo, el Pooling crear un nuevo conjunto del mismo número de mapas de características Agrupados “Pooling”.

. La Clase MaxPooling2D es una operación de agrupación máxima para datos espaciales 2D. Reduce la muestra de la entrada a lo largo de sus dimensiones espaciales “alto y ancho 2D” tomando el valor máximo sobre una ventana de entrada para cada canal de la entrada. La ventana se desplaza a lo largo de cada dimensión.

Cargamos las librería que falta:

  • In: from keras.layers.pooling import MaxPooling2D

Generamos Layers MaxPooling2D:

  • In: tf.keras.layers.MaxPooling2D(
  • In: pool_size=(2, 2), strides=None, padding=«valid», data_format=None,
  • In: )

Relación de Pooling–Layers disponibles:

  • MaxPooling1D layer
  • MaxPooling2D layer
  • MaxPooling3D layer
  • AveragePooling1D layer
  • AveragePooling2D layer
  • AveragePooling3D layer
  • GlobalMaxPooling1D layer
  • GlobalMaxPooling2D layer
  • GlobalMaxPooling3D layer
  • GlobalAveragePooling1D layer
  • GlobalAveragePooling2D layer
  • GlobalAveragePooling3D layer

 

Que es Recurrent-Layers:

. Es una capa “Layers” totalmente conectada cuya salida se envía de vuelta a la entrada. Se puede definir como un entero positivo que representa la dimensionalidad del espacio de salida.

LSTM-Layer clase tf.keras.layers.LSTM(), este tipo de Capa-LSTM tiene memoria a largo plazo

Hay tres capas Recurrent integradas API-Keras:

  • keras.layers.SimpleRNN, una Recurrent-Layers completamente conectado donde la salida del paso de tiempo anterior se alimentará al próximo paso de tiempo.
  • keras.layers.GRU, La layers-GRU se compone de la puerta de reinicio y la puerta de actualización.
  • keras.layers.LSTM, La layers-LSTM se compone de la puerta de entrada,salida y olvido de la LSTM.

Creación del Modelo:

  • In: model = keras.Sequential()
  • In: model.add(layers.Embedding(input_dim=1000, output_dim=64))
  • In: model.add(layers.LSTM(128))
  • In: model.add(layers.Dense(10))
  • In: model.summary()

Descripción del Modelo:

Tenemos una primera Capa de incrustación esperando un vocabulario de entrada “input” de tamaño 1000, y dimensión de incrustación de salida “outpu” de tamaño 64. La segunda Capa es la que nos ocupa en este momento la layers.LSTM con 128 unidades internas. Por ultimo una Capa-Dense con 10 unidades.

Relación de Recurrent-Layers disponibles:

  • SimpleRNN layer
  • GRU layer
  • LSTM layer
  • TimeDistributed layer
  • Bidirectional layer
  • ConvLSTM1D layer
  • ConvLSTM2D layer
  • ConvLSTM3D layer
  • Base RNN layer

 

Que es Preprocesamiento-Layers:

-. La API-Keras-Preprocesamiento-Layers permite a los desarrolladores crear canalizaciones de procesamiento de entrada nativas de Keras. Estas canalizaciones de procesamiento de entrada se pueden usar como código de preprocesamiento independiente en flujos de trabajo que no son de Keras, combinados directamente con Modelos de Keras y exportados como parte de un Modelo guardado de Keras.

Preprocesamiento disponible

Preprocesamiento de texto:
  • tf.keras.layers.TextVectorization: convierte cadenas sin formato en una representación codificada que puede ser leída por una Embedding-Layers o Dense-Layers.
Preprocesamiento de características numéricas:
  • tf.keras.layers.Normalization: realiza la normalización de funciones de las funciones de entrada.
  • tf.keras.layers.Discretization: convierte características numéricas continuas en características categóricas enteras.
Preprocesamiento de características categóricas:
  • tf.keras.layers.CategoryEncoding: convierte características categóricas de enteros en representaciones one-hot, multi-hot o de recuento denso.
  • tf.keras.layers.Hashing: realiza hash de características categóricas, también conocido como «truco hash».
  • tf.keras.layers.StringLookup: convierte los valores categóricos de cadena en una representación codificada que puede leer una Embedding-Layers o Dense-Layers.
  • tf.keras.layers.IntegerLookup: convierte valores categóricos enteros en una representación codificada que puede ser leída por una Embedding-Layers o Dense-Layers.
Preprocesamiento de imágenes:
  • tf.keras.layers.Resizing: cambia el tamaño de un lote de imágenes a un tamaño objetivo.
  • tf.keras.layers.Rescaling: cambia la escala y compensa los valores de un lote de imágenes (por ejemplo, pasa de entradas en el [0, 255]rango a entradas en el [0, 1] rango.
  • tf.keras.layers.CenterCrop: devuelve un recorte central de un lote de imágenes.

Nota: Este tipo de layers son, para estandarizar las entradas de un Modelo de imagen.

Aumento de datos de imagen:
  • tf.keras.layers.RandomCrop
  • tf.keras.layers.RandomFlip
  • tf.keras.layers.RandomTranslation
  • tf.keras.layers.RandomRotation
  • tf.keras.layers.RandomZoom
  • tf.keras.layers.RandomHeight
  • tf.keras.layers.RandomWidth
  • tf.keras.layers.RandomContrast

Nota: Este tipo de layers aplican transformaciones de aumento aleatorio a un lote de imágenes, estas capas están solo activas durante el entrenamiento.

 

Que es Activation-Layers:

. En las Redes-Neuronales-Artificiales , la función de activación de un nodo define la salida de ese nodo dada una entrada o un conjunto de entradas, en las Activation-Layers es lo mismo, solo las funciones de activación no lineales permiten que dichas Capa-Activation calculen problemas que queremos resorber, el conjunto de estas Capas-Activación forman forman parte de la arquitectura del Modelo-Keras.

Relación deActivation-Layers disponibles:

ReLU layer

  • tf.keras.layers.ReLU(max_value=None, negative_slope=0.0, threshold=0.0)

Softmax layer

  • tf.keras.layers.Softmax(axis=-1)

LeakyReLU layer

  • tf.keras.layers.LeakyReLU(alpha=0.3)

PReLU layer

  • tf.keras.layers.PReLU(
  • alpha_initializer=»zeros»,
  • alpha_regularizer=None,
  • alpha_constraint=None,
  • shared_axes=None,
  • )

ELU layer

  • tf.keras.layers.ELU(alpha=1.0)

ThresholdedReLU layer

  • tf.keras.layers.ThresholdedReLU(theta=1.0)

 

Recopilando:

La definición de las Capas-Keras, la que mas se aproxima a la realidad, dice que son los bloques de construcción de los Modelos-Keras, hemos dado una vuelta por algunas de las mas usadas pero (tenemos más).

  • Referencias: (Entorno-Moreluz)
  • Referencias: (Keras)