Keras - Capas
Como se aprendió anteriormente, las capas de Keras son el componente principal de los modelos de Keras. Cada capa recibe información de entrada, realiza algunos cálculos y finalmente genera la información transformada. La salida de una capa fluirá a la siguiente capa como entrada. Aprendamos detalles completos sobre las capas en este capítulo.
Introducción
Una capa de Keras requiere shape of the input (input_shape) para comprender la estructura de los datos de entrada, initializerpara establecer el peso de cada entrada y finalmente los activadores para transformar la salida para hacerla no lineal. En el medio, las restricciones restringen y especifican el rango en el que el peso de los datos de entrada que se generarán y el regularizador intentará optimizar la capa (y el modelo) aplicando dinámicamente las penalizaciones en los pesos durante el proceso de optimización.
Para resumir, la capa de Keras requiere detalles mínimos por debajo para crear una capa completa.
- Forma de los datos de entrada
- Número de neuronas / unidades en la capa
- Initializers
- Regularizers
- Constraints
- Activations
Entendamos el concepto básico en el próximo capítulo. Antes de comprender el concepto básico, creemos una capa de Keras simple utilizando la API de modelo secuencial para tener una idea de cómo funcionan el modelo y la capa de Keras.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
from keras import regularizers
from keras import constraints
model = Sequential()
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform',
kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(8))dónde,
Line 1-5 importa los módulos necesarios.
Line 7 crea un nuevo modelo usando API secuencial.
Line 9 crea un nuevo Dense capa y agréguela al modelo. Densees una capa de nivel de entrada proporcionada por Keras, que acepta el número de neuronas o unidades (32) como parámetro requerido. Si la capa es la primera capa, entonces debemos proporcionarInput Shape, (16,)también. De lo contrario, la salida de la capa anterior se utilizará como entrada de la siguiente capa. Todos los demás parámetros son opcionales.
El primer parámetro representa el número de unidades (neuronas).
input_shape representar la forma de los datos de entrada.
kernel_initializer representan el inicializador que se utilizará. he_uniform la función se establece como valor.
kernel_regularizer representar regularizerpara ser utilizado. Ninguno se establece como valor.
kernel_constraint representan la restricción que se utilizará. MaxNorm la función se establece como valor.
activationrepresentan la activación que se utilizará. La función relu se establece como valor.
Line 10 crea segundo Dense capa con 16 unidades y conjunto relu como función de activación.
Line 11 crea una capa densa final con 8 unidades.
Concepto básico de capas
Entendamos el concepto básico de capa y cómo Keras apoya cada concepto.
Forma de entrada
En el aprendizaje automático, todo tipo de datos de entrada como texto, imágenes o videos se convertirán primero en una matriz de números y luego se incorporarán al algoritmo. Los números de entrada pueden ser una matriz unidimensional, una matriz bidimensional (matriz) o una matriz multidimensional. Podemos especificar la información dimensional usandoshape, una tupla de números enteros. Por ejemplo,(4,2) representar una matriz con cuatro filas y dos columnas.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>Similar, (3,4,2) matriz tridimensional que tiene tres colecciones de matriz 4x2 (dos filas y cuatro columnas).
>>> import numpy as np
>>> shape = (3, 4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>Para crear la primera capa del modelo (o capa de entrada del modelo), se debe especificar la forma de los datos de entrada.
Inicializadores
En Machine Learning, se asignará peso a todos los datos de entrada. InitializersEl módulo proporciona diferentes funciones para establecer estos pesos iniciales. Algunos de losKeras Initializer función son las siguientes:
Ceros
Genera 0 para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Zeros()
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Dónde, kernel_initializer representan el inicializador del kernel del modelo.
Unos
Genera 1 para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Ones()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Constante
Genera un valor constante (digamos, 5) especificado por el usuario para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Constant(value = 0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)dónde, value representar el valor constante
AleatorioNormal
Genera valor utilizando la distribución normal de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomNormal(mean=0.0,
stddev = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dónde,
mean representar la media de los valores aleatorios para generar
stddev representar la desviación estándar de los valores aleatorios para generar
seed representar los valores para generar un número aleatorio
AleatorioUniforme
Genera valor mediante la distribución uniforme de los datos de entrada.
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dónde,
minval representar el límite inferior de los valores aleatorios para generar
maxval representar el límite superior de los valores aleatorios para generar
TruncatedNormal
Genera valor utilizando una distribución normal truncada de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))VarianceScaling
Genera un valor basado en la forma de entrada y la forma de salida de la capa junto con la escala especificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.VarianceScaling(
scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
skernel_initializer = my_init))dónde,
scale representar el factor de escala
mode representar a cualquiera de fan_in, fan_out y fan_avg valores
distribution representar cualquiera de normal o uniform
VarianceScaling
Encuentra el stddev valor para la distribución normal usando la fórmula siguiente y luego encuentre los pesos usando la distribución normal,
stddev = sqrt(scale / n)dónde n representar,
número de unidades de entrada para mode = fan_in
número de unidades de salida para mode = fan_out
número medio de unidades de entrada y salida para mode = fan_avg
De manera similar, encuentra el límite para la distribución uniforme usando la siguiente fórmula y luego encuentra los pesos usando la distribución uniforme,
limit = sqrt(3 * scale / n)lecun_normal
Genera valor usando la distribución normal de lecun de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Encuentra el stddev usando la fórmula siguiente y luego aplique la distribución normal
stddev = sqrt(1 / fan_in)dónde, fan_in representan el número de unidades de entrada.
lecun_uniform
Genera valor mediante la distribución uniforme de lecun de los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.lecun_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme
limit = sqrt(3 / fan_in)dónde,
fan_in representa el número de unidades de entrada
fan_out representa el número de unidades de salida
glorot_normal
Genera valor usando la distribución normal de glorot de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_normal(seed=None) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)Encuentra el stddev usando la fórmula siguiente y luego aplique la distribución normal
stddev = sqrt(2 / (fan_in + fan_out))dónde,
fan_in representa el número de unidades de entrada
fan_out representa el número de unidades de salida
glorot_uniform
Genera valor utilizando una distribución uniforme de glorot de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme
limit = sqrt(6 / (fan_in + fan_out))dónde,
fan_in representan el número de unidades de entrada.
fan_out representa el número de unidades de salida
él_normal
Genera valor usando la distribución normal de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Encuentra el stddev usando la siguiente fórmula y luego aplica la distribución normal.
stddev = sqrt(2 / fan_in)dónde, fan_in representan el número de unidades de entrada.
él_uniforme
Genera valor utilizando la distribución uniforme de los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.he_normal(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme.
limit = sqrt(6 / fan_in)dónde, fan_in representan el número de unidades de entrada.
Ortogonal
Genera una matriz ortogonal aleatoria.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Orthogonal(gain = 1.0, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dónde, gain representan el factor de multiplicación de la matriz.
Identidad
Genera matriz de identidad.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)Restricciones
En el aprendizaje automático, se establecerá una restricción en el parámetro (peso) durante la fase de optimización. <> El módulo de restricciones proporciona diferentes funciones para establecer la restricción en la capa. Algunas de las funciones de restricción son las siguientes.
NonNeg
Restringe los pesos para que no sean negativos.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init)
)dónde, kernel_constraint representan la restricción que se utilizará en la capa.
UnitNorm
Restringe los pesos para que sean la norma unitaria.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.UnitNorm(axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))MaxNorm
Restringe el peso a la norma menor o igual al valor dado.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))dónde,
max_value representar el límite superior
El eje representa la dimensión en la que se aplicará la restricción. Por ejemplo, en Shape (2,3,4) el eje 0 indica la primera dimensión, 1 indica la segunda dimensión y 2 indica la tercera dimensión
MinMaxNorm
Restringe los pesos para que sean la norma entre los valores mínimos y máximos especificados.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))dónde, rate representan la tasa a la que se aplica la restricción de peso.
Regularizadores
En el aprendizaje automático, los regularizadores se utilizan en la fase de optimización. Aplica algunas penalizaciones en el parámetro de capa durante la optimización. El módulo de regularización de Keras proporciona las siguientes funciones para establecer penalizaciones en la capa. La regularización se aplica solo por capa.
Regularizador L1
Proporciona regularización basada en L1.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l1(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))dónde, kernel_regularizer representan la tasa a la que se aplica la restricción de peso.
Regularizador L2
Proporciona regularización basada en L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))Regularizador L1 y L2
Proporciona regularización basada en L1 y L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))Activaciones
En el aprendizaje automático, la función de activación es una función especial que se utiliza para encontrar si una neurona específica está activada o no. Básicamente, la función de activación realiza una transformación no lineal de los datos de entrada y, por lo tanto, permite que las neuronas aprendan mejor. La salida de una neurona depende de la función de activación.
Como recordará el concepto de percepción única, la salida de un perceptrón (neurona) es simplemente el resultado de la función de activación, que acepta la suma de todas las entradas multiplicadas por su peso correspondiente más el sesgo general, si hay alguno disponible.
result = Activation(SUMOF(input * weight) + bias)Entonces, la función de activación juega un papel importante en el aprendizaje exitoso del modelo. Keras proporciona muchas funciones de activación en el módulo de activaciones. Aprendamos todas las activaciones disponibles en el módulo.
lineal
Aplica la función lineal. No hace nada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))Dónde, activationse refiere a la función de activación de la capa. Se puede especificar simplemente por el nombre de la función y la capa utilizará los activadores correspondientes.
elu
Aplica unidad lineal exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))selu
Aplica la unidad lineal exponencial escalada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))relu
Aplica unidad lineal rectificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))softmax
Aplica la función Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))softplus
Aplica la función Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))softsign
Aplica la función Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))tanh
Aplica la función de tangente hiperbólica.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))sigmoideo
Aplica la función sigmoidea.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))hard_sigmoid
Aplica la función sigmoidea dura.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))exponencial
Aplica función exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))| No Señor | Capas y descripción |
|---|---|
| 1 | Capa densa Dense layer es la capa de red neuronal regular profundamente conectada. |
| 2 | Capas de abandono Dropout es uno de los conceptos importantes en el aprendizaje automático. |
| 3 | Aplanar capas Flatten se utiliza para aplanar la entrada. |
| 4 | Cambiar la forma de las capas Reshape se utiliza para cambiar la forma de la entrada. |
| 5 | Permutar capas Permute también se usa para cambiar la forma de la entrada usando patrón. |
| 6 | Repetir Capas vectoriales RepeatVector se utiliza para repetir la entrada para el número establecido, n veces. |
| 7 | Capas Lambda Lambda se utiliza para transformar los datos de entrada mediante una expresión o función. |
| 8 | Capas de convolución Keras contiene muchas capas para crear ANN basado en convolución, popularmente llamado como red neuronal de convolución (CNN) . |
| 9 | Capa de agrupación Se utiliza para realizar operaciones de agrupación máxima en datos temporales. |
| 10 | Capa conectada localmente Las capas conectadas localmente son similares a la capa Conv1D, pero la diferencia es que los pesos de las capas Conv1D se comparten, pero aquí los pesos no se comparten. |
| 11 | Fusionar capa Se utiliza para fusionar una lista de entradas. |
| 12 | Capa de incrustación Realiza operaciones de incrustación en la capa de entrada. |