Keras Conv2D et canaux d'entrée

Question

La documentation de la couche Keras spécifie les tailles d'entrée et de sortie des couches de convolution: https://keras.io/layers/convolutional/

Forme de saisie: (samples, channels, rows, cols)

Forme de sortie: (samples, filters, new_rows, new_cols)

Et la taille du noyau est un paramètre spatial, c’est-à-dire ne détermine que la largeur et la hauteur.

Ainsi, une entrée avec c canaux produira une sortie avec filters canaux quelle que soit la valeur de c. Il doit donc appliquer une convolution 2D avec un filtre spatial height x width, puis agréger les résultats d’une manière ou d’une autre pour chaque filtre appris.

Quel est cet opérateur d'agrégation? est-ce une sommation sur plusieurs canaux? puis-je le contrôler? Je n'ai trouvé aucune information sur la documentation de Keras.

Notez que dans TensorFlow, les filtres sont également spécifiés dans le canal de profondeur: https://www.tensorflow.org/api_guides/python/nn#Convolution , L'opération de profondeur est donc claire.

Merci.

noio · Accepted Answer

Cela peut être déroutant qu'il s'appelle couche Conv2D (c'était pour moi, c'est pourquoi je suis venu chercher cette réponse), car, comme le disait Nilesh Birari:

Je suppose que vous manquez son noyau 3D [largeur, hauteur, profondeur]. Le résultat est donc la somme des canaux.

Peut-être que 2D provient du fait que le noyau ne se trouve que diapositives le long de deux dimensions, la troisième dimension est fixe et déterminée par le nombre de canaux d'entrée (la profondeur d'entrée).

Pour une explication plus élaborée, lisez https://petewarden.com/2015/04/20/why-gemm-is-at-the-heart-of-deep-learning/

J'ai cueilli une image illustrative à partir de là:

Alaroff · Answer

Je me posais aussi la question et ai trouvé une autre réponse ici , où il est indiqué (souligné par moi):

L'exemple le plus concret d'une entrée multicanal est peut-être lorsque vous avez une image couleur comportant 3 canaux RVB. Passons à une couche de convolution avec 3 canaux d’entrée et 1 canal de sortie. (...) Il calcule la convolution de chaque filtre avec le canal d'entrée correspondant (...). La foulée de tous les canaux est la même, ils produisent donc des matrices de même taille. Maintenant, il résume toutes les matrices et génère une seule matrice qui est le seul canal à la sortie de la couche de convolution.

Illustration:

Notez que les poids des noyaux de convolution pour chaque canal sont différents, qui sont ensuite ajustés de manière itérative dans les étapes de rétro-propagation, par ex. algorithmes basés sur le gradient décent tels que la descente de gradient stochastique (SDG).

Voici une réponse plus technique de API TensorFlow .

Raimi bin Karim · Answer

J'avais aussi besoin de me convaincre alors j'ai donné un exemple simple avec une image 3 × 3 RVB.

# 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

Le filtre est initialisé à ceux suivants:

1 1 1 1

J'ai également défini la convolution pour avoir ces propriétés:

pas de rembourrage
foulées = 1
fonction d'activation de relu
biais initialisé à 0

Nous nous attendions à ce que la sortie (agrégée) soit:

40404 40404 40404 40404

En outre, d'après la photo ci-dessus, le no. des paramètres est

3 filtres séparés (un pour chaque canal) × 4 poids + 1 (biais, non montré) = 13 paramètres

Voici le code.

Modules d'importation:

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

Créez les canaux rouge, vert et bleu:

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

Empiler les canaux pour former une image RVB:

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

Créez un modèle qui ne fait qu'une convolution 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)

Entrez l'image dans le modèle:

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

Exécutez un résumé pour obtenir le nombre de paramètres:

model.summary()