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.