Clase Keras.Conv2D

Keras Conv2D es una capa de convolución 2D, esta capa crea un núcleo de convolución que se enrolla con entrada de capas que ayuda a producir un tensor de salidas.

Kernel: en el procesamiento de imágenes, el kernel es una array de convolución o máscaras que se pueden usar para desenfocar, agudizar, realzar, detectar bordes y más al hacer una convolución entre un kernel y una imagen.

El constructor de la clase Keras Conv2D tiene los siguientes argumentos:

keras.layers.Conv2D(filters, kernel_size, strides=(1, 1),
  padding='valid', data_format=None, dilation_rate=(1, 1),
  activation=None, use_bias=True, kernel_initializer='glorot_uniform',
  bias_initializer='zeros', kernel_regularizer=None,
  bias_regularizer=None, activity_regularizer=None,
  kernel_constraint=None, bias_constraint=None)

Ahora examinemos cada uno de estos parámetros individualmente:
filtros

• El parámetro Conv2D obligatorio es el número de filtros de los que aprenderán las capas convolucionales.
• Es un valor entero y también determina el número de filtros de salida en la convolución.

model.add(Conv2D(32, (3, 3), padding="same", activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))

kernel_size

• Este parámetro determina las dimensiones del núcleo. Las dimensiones comunes incluyen 1 × 1, 3 × 3, 5 × 5 y 7 × 7, que se pueden pasar como tuplas (1, 1), (3, 3), (5, 5) o (7, 7).
• Es un número entero o tupla/lista de 2 números enteros, especificando la altura y el ancho de la ventana de convolución 2D.
• Este parámetro debe ser un entero impar.

model.add(Conv2D(32, (7, 7), activation="relu"))

zancadas

• Este parámetro es un número entero o tupla/lista de 2 números enteros, especificando el «paso» de la convolución junto con la altura y el ancho del volumen de entrada.
• Su valor predeterminado siempre se establece en (1, 1), lo que significa que el filtro Conv2D dado se aplica a la ubicación actual del volumen de entrada y el filtro dado da un paso de 1 píxel a la derecha y nuevamente el filtro se aplica a la volumen de entrada y se realiza hasta llegar al extremo derecho del borde del volumen en el que estamos moviendo nuestro filtro.

model.add(Conv2D(128, (3, 3), strides=(1, 1), activation="relu"))
model.add(Conv2D(128, (3, 3), strides=(2, 2), activation="relu"))

relleno

• El parámetro de relleno de la clase Keras Conv2D puede tomar uno de dos valores: ‘válido’ o ‘igual’.
• Establecer el valor en el parámetro «válido» significa que el volumen de entrada no se rellena con ceros y se permite que las dimensiones espaciales se reduzcan a través de la aplicación natural de la convolución.

model.add(Conv2D(32, (3, 3), padding="valid"))

En su lugar, puede conservar las dimensiones espaciales del volumen de modo que el tamaño del volumen de salida coincida con el tamaño del volumen de entrada, configurando el valor en «mismo».

model.add(Conv2D(32, (3, 3), padding="same"))

formato de datos

• Este parámetro de la clase Conv2D se puede establecer en el valor «channels_last» o «channels_first».
• El backend de TensorFlow para Keras usa el último pedido de canales, mientras que el backend de Theano usa el primer pedido de canales.
• Por lo general, no vamos a tocar este valor como Keras, ya que la mayoría de las veces usaremos el backend de TensorFlow para Keras.
• El valor predeterminado es el valor image_data_format que se encuentra en su archivo de configuración de Keras en ~/.keras/Keras.json.

tasa_de_dilatación

• El parámetro dilation_rate de la clase Conv2D es una tupla de 2 enteros, que controla la tasa de dilatación para la convolución dilatada.
• La convolución dilatada es la convolución básica aplicada al volumen de entrada con espacios definidos.
• Puede usar este parámetro cuando trabaje con imágenes de mayor resolución y los detalles de granularidad sean importantes para usted o cuando esté construyendo una red con menos parámetros.

activación

• El parámetro de activación de la clase Conv2D es simplemente un parámetro conveniente que le permite proporcionar una string que especifica el nombre de la función de activación que desea aplicar después de realizar la convolución.

model.add(Conv2D(32, (3, 3), activation="relu"))

O

model.add(Conv2D(32, (3, 3)))
model.add(Activation("relu"))

• Si no especifica nada, no se aplica ninguna activación y no tendrá un impacto en el rendimiento de su red neuronal convolucional.

use_bias

• Este parámetro de la clase Conv2D se utiliza para determinar si se agregará un vector de polarización a la capa convolucional.
• De forma predeterminada, su valor se establece como True.

kernel_initializer

• Este parámetro controla el método de inicialización que se usa para inicializar todos los valores en la clase Conv2D antes de entrenar realmente el modelo.
• Es el inicializador de la array de pesos del núcleo.

bias_initializer

• Mientras que bias_initializer controla cómo se inicializa realmente el vector de polarización antes de que comience el entrenamiento.
• Es el inicializador del vector de polarización.

kernel_regularizer, bias_regularizer y activity_regularizer

• kernel_regularizer es la función de regularizador que se aplica a la array de pesos del kernel.
• bias_regularizer es la función de Regularizador que se aplica al vector de polarización.
• activity_regularizer es la función Regularizer que se aplica a la salida de la capa (es decir, activación).
• Las regularizaciones son técnicas que se utilizan para reducir el error al ajustar una función de manera adecuada en el conjunto de entrenamiento dado y evitar el sobreajuste.
• Controla el tipo y la cantidad de método de regularización aplicado a la capa Conv2D.
• El uso de la regularización es imprescindible cuando se trabaja con grandes conjuntos de datos y redes neuronales profundas.
• El uso de la regularización nos ayuda a reducir los efectos del sobreajuste y también a aumentar la capacidad de generalización de nuestro modelo.
• Hay dos tipos de regularización: regularización L1 y L2, ambas se utilizan para reducir el sobreajuste de nuestro modelo.

from keras.regularizers import l2
...
model.add(Conv2D(128, (3, 3), activation="relu"),
    kernel_regularizer=l2(0.0002))

• El valor de regularización que aplique es el hiperparámetro que necesitará ajustar para su propio conjunto de datos y su valor generalmente oscila entre 0,0001 y 0,001.
• Siempre se recomienda dejar el bias_regularizer solo, ya que tiene un impacto muy menor en la reducción del sobreajuste.
• También se recomienda dejar activity_regularizer en su valor predeterminado.

kernel_constraint y bias_constraint

• kernel_constraint es la función de restricción que se aplica a la array del núcleo.
• bias_constraint es la función de restricción que se aplica al vector de polarización.
• Una restricción es una condición de un problema de optimización que la solución debe satisfacer.
  Hay varios tipos de restricciones, principalmente restricciones de igualdad, restricciones de desigualdad y restricciones de enteros.
• Estos parámetros le permiten imponer restricciones en las capas Conv2D.
• Estos parámetros generalmente se dejan solos a menos que tenga una razón específica para aplicar una restricción en las capas Con2D.

Aquí hay un ejemplo de código simple para mostrarle el funcionamiento de diferentes parámetros de la clase Conv2D:

# build the model
model = Sequential()
model.add(Conv2D(32, kernel_size =(5, 5), strides =(1, 1),
                 activation ='relu'))
model.add(MaxPooling2D(pool_size =(2, 2), strides =(2, 2)))
model.add(Conv2D(64, (5, 5), activation ='relu'))
model.add(MaxPooling2D(pool_size =(2, 2)))
model.add(Flatten())
model.add(Dense(1000, activation ='relu'))
model.add(Dense(num_classes, activation ='softmax'))
  
# training the model
model.compile(loss = keras.losses.categorical_crossentropy,
              optimizer = keras.optimizers.SGD(lr = 0.01),
              metrics =['accuracy'])
  
# fitting the model
model.fit(x_train, y_train,
          batch_size = batch_size,
          epochs = epochs,
          verbose = 1,
          validation_data =(x_test, y_test),
          callbacks =[history])
  
# evaluating and printing results
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Comprender el código:

• Al agregar las capas Conv2D usando el método Sequential.model.add() , existen numerosos parámetros que podemos usar y que hemos leído anteriormente en nuestro blog.
• El primer parámetro nos informa sobre la cantidad de filtros utilizados en nuestra operación de convolución.
• Luego, el segundo parámetro especifica el tamaño del filtro convolucional en píxeles. El tamaño del filtro puede estar determinado por la arquitectura CNN que esté utilizando; por ejemplo, VGGNet usa exclusivamente (3, 3) filtros. De lo contrario, use un filtro de 5 × 5 o 7 × 7 para aprender características más grandes y luego redúzcalo rápidamente a 3 × 3.
• El tercer parámetro especifica cómo debe avanzar el filtro convolucional a lo largo del eje x y el eje y de la imagen de origen. En la mayoría de los casos, está bien dejar el parámetro zancadas con el valor predeterminado (1, 1). Sin embargo, puede aumentarlo a (2, 2) para reducir el tamaño del volumen de salida.
• El cuarto parámetro es el parámetro de activación que especifica el nombre de la función de activación que desea aplicar después de realizar la convolución.

Código similar usando API funcional

#build the model
inputs = Input(shape = ())
conv1 = Conv2D(32, kernel_size = (5,5), strides = (1,1), activation = 'relu'))(inputs)
max1 = MaxPooling2D(pool_size=(2,2), strides=(2,2)))(conv1)
conv2 = Conv2D(64, (5,5), activation = 'relu'))(max1)
max2 = MaxPooling2D(pool_size=(2,2)))(conv2)
flat = Flatten()(max2)
den1 = Dense(100, activation = 'relu'))(flat)
out1 = Dense(num_classes, activation ='softmax'))(den1)
  
model = Model(inputs = inputs, output =out1 )
  
  
# training the model 
model.compile(loss = keras.losses.categorical_crossentropy,
              optimizer = keras.optimizers.SGD(lr = 0.01),
              metrics =['accuracy'])
  
# fitting the model 
model.fit(x_train, y_train,
          batch_size = batch_size,
          epochs = epochs,
          verbose = 1,
          validation_data =(x_test, y_test),
          callbacks =[history])
  
# evaluating and printing results 
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Resumen:

• La mayor parte del tiempo utilizará filtros, kernel_size, zancadas, relleno.
• Cómo usar correctamente la clase Keras Conv2D para crear nuestra propia red neuronal de convolución y determinar si necesitamos utilizar un parámetro específico para la clase Keras Conv2D.