python - instalar - Keras Conv2D y canales de entrada.

tensorflow python

Question

La documentación de la capa Keras especifica los tamaños de entrada y salida para las capas convolucionales: https://keras.io/layers/convolutional/

Forma de entrada: (samples, channels, rows, cols)

Forma de salida: (samples, filters, new_rows, new_cols)

Y el tamaño del kernel es un parámetro espacial, es decir, determina solo el ancho y la altura.

Por lo tanto, una entrada con c canales producirá una salida con canales de filters independientemente del valor de c . Por lo tanto, debe aplicar la convolución 2D con un filtro de height x width espacial y luego agregar los resultados de alguna manera para cada filtro aprendido.

¿Qué es este operador de agregación? ¿Es una suma a través de canales? puedo controlarlo? No pude encontrar ninguna información en la documentación de Keras.

• Tenga en cuenta que en TensorFlow los filtros también se especifican en el canal de profundidad: https://www.tensorflow.org/api_guides/python/nn#Convolution , por lo que la operación de profundidad es clara.

Gracias.

Answer 1

Podría ser confuso que se llame capa Conv2D (fue para mí, por lo que vine buscando esta respuesta), porque como Nilesh Birari comentó:

Supongo que te estás perdiendo el núcleo 3D [ancho, alto, profundidad]. Entonces el resultado es sumación a través de los canales.

Quizás el 2D se deriva del hecho de que el núcleo solo se desliza a lo largo de dos dimensiones, la tercera dimensión está fija y determinada por el número de canales de entrada (la profundidad de entrada).

Para obtener una explicación más detallada, lea https://petewarden.com/2015/04/20/why-gemm-is-at-the-heart-of-deep-learning/

Tomé una imagen ilustrativa de allí:

Answer 2

También me estaba preguntando esto, y encontré otra respuesta here , donde se dice (énfasis mío):

Quizás el ejemplo más tangible de una entrada multicanal es cuando tienes una imagen en color que tiene 3 canales RGB. Vayamos a una capa de convolución con 3 canales de entrada y 1 canal de salida. (...) Lo que hace es que calcula la convolución de cada filtro con su canal de entrada correspondiente (...). El paso de todos los canales es el mismo, por lo que generan matrices con el mismo tamaño. Ahora, resume todas las matrices y genera una matriz única que es el único canal en la salida de la capa de convolución.

Ilustración:

Observe que los pesos de los núcleos de convolución para cada canal son diferentes , que luego se ajustan de forma iterativa en los pasos de propagación hacia atrás mediante, por ejemplo, algoritmos basados ​​en gradiente decente, como el descenso de gradiente estocástico (SDG).

Aquí hay una respuesta más técnica de TensorFlow API .

Answer 3

También necesitaba convencerme a mí mismo, así que di un ejemplo sencillo con una imagen de 3 × 3 RGB.

# red    # green        # blue
1 1 1    100 100 100    10000 10000 10000
1 1 1    100 100 100    10000 10000 10000    
1 1 1    100 100 100    10000 10000 10000

El filtro se inicializa a unos:

1 1
1 1

También he establecido la convolución para tener estas propiedades:

• sin relleno
• zancadas = 1
• función de activación relu
• sesgo inicializado a 0

Esperamos que la salida (agregada) sea:

40404 40404
40404 40404

Además, a partir de la imagen de arriba, el no. de parametros es

3 filtros separados (uno para cada canal) × 4 pesos + 1 (sesgo, no se muestra) = 13 parámetros

Aquí está el código.

Importar módulos:

import numpy as np
from keras.layers import Input, Conv2D
from keras.models import Model

Crea los canales rojo, verde y azul:

red   = np.array([1]*9).reshape((3,3))
green = np.array([100]*9).reshape((3,3))
blue  = np.array([10000]*9).reshape((3,3))

Apila los canales para formar una imagen RGB:

img = np.stack([red, green, blue], axis=-1)
img = np.expand_dims(img, axis=0)

Crea un modelo que solo haga una convolución Conv2D:

inputs = Input((3,3,3))
conv = Conv2D(filters=1, 
              strides=1, 
              padding=''valid'', 
              activation=''relu'',
              kernel_size=2, 
              kernel_initializer=''ones'', 
              bias_initializer=''zeros'', )(inputs)
model = Model(inputs,conv)

Introduzca la imagen en el modelo:

model.predict(img)
# array([[[[40404.],
#          [40404.]],

#         [[40404.],
#          [40404.]]]], dtype=float32)

Ejecuta un resumen para obtener el número de parámetros:

model.summary()