[PYTHON] [Apprentissage en profondeur] Découvrez comment utiliser chaque fonction du réseau neuronal convolutif [DW jour 3]

Qu'est-ce que le réseau neuronal convolutif (CNN)?

Un réseau neuronal spécialisé pour les images. Alors qu'un perceptron multicouche normal se compose d'une couche d'entrée, d'une couche intermédiaire et d'une couche de sortie, le CNN a également une couche de convolution, une couche de regroupement et une couche localement normalisée (couche LRN).

En regardant AlexNet (haut de ILSVRC2012) dans l'exemple Chainer, cela ressemble à ceci:

• ImageNet Classification with Deep Convolutional Réseaux de neurones
• Chainer Example AlexNet

# … (Omis)
class AlexBN(chainer.Chain):

   """Single-GPU AlexNet with LRN layers replaced by BatchNormalization."""

   insize = 227

   def __init__(self):
       super(AlexBN, self).__init__(
           conv1=L.Convolution2D(3,  96, 11, stride=4),
           bn1=L.BatchNormalization(96),
           conv2=L.Convolution2D(96, 256,  5, pad=2),
           bn2=L.BatchNormalization(256),
           conv3=L.Convolution2D(256, 384,  3, pad=1),
           conv4=L.Convolution2D(384, 384,  3, pad=1),
           conv5=L.Convolution2D(384, 256,  3, pad=1),
           fc6=L.Linear(9216, 4096),
           fc7=L.Linear(4096, 4096),
           fc8=L.Linear(4096, 1000),
       )
       self.train = True

# … (Omis)

Il se compose de 5 couches convolutives et de 3 couches entièrement connectées. Le document indique également que les fonctions d'activation ReLu, multi-GPU, LRN et la mise en commun sont importantes. L'exemple de chaînage ci-dessus utilise la normalisation par lots au lieu de LRN. Ce qui suit est détaillé sur la normalisation des lots.

• Mécanisme de normalisation par lots et sa compréhension intuitive

Couche pliante

L.Convolution2D(3,  96, 11, stride=4)

La formule de pliage est omise car elle est écrite dans divers ouvrages de référence. Ici, nous visons à pouvoir utiliser cette fonction. Premièrement, la convolution consiste à filtrer et à convertir une image. Comme l'image, le filtre a des variables telles que le nombre de pixels et le canal. Lorsque le nombre de pixels de l'image est $ N \ fois N $ et le nombre de canaux est $ K $, la taille du filtre est également $ H \ fois H , tout comme la taille de l'image s'écrit $ N \ fois N \ fois K $. Écrivez comme des temps K $. Le nombre de canaux d'image et de filtre sera le même. Il peut y avoir plusieurs types de filtres appliqués à l'image. Lorsque vous appliquez le filtre de type $ M $, le nombre de canaux dans l'image de sortie est converti en $ M $. De plus, lors de l'application d'un filtre, le filtre est partiellement appliqué lors du déplacement, et la largeur du mouvement est appelée largeur de foulée. L'augmentation de la largeur de foulée permet de rater plus facilement les caractéristiques de l'image, donc une largeur de foulée plus petite est souhaitable. En outre, fournir des pixels virtuels à l'extérieur du bord de l'image est appelé remplissage. En donnant un rembourrage, il est possible de supprimer la réduction de l'image lorsqu'elle est pliée. Si vous voulez qu'elle ait la même taille que l'entrée, tronquez la taille de remplissage à $ H / 2 $. Pour résumer jusqu'ici, l'argument de pythonL.Convolution2D () est

--Premier argument = nombre de canaux d'entrée. C'est $ K $. --Deuxième argument = nombre de canaux de sortie. $ M $.

• Troisième argument = taille du filtre. Environ $ H $ --Nom de l'argument stride = largeur de la foulée. (Le plus petit est le mieux. Est-ce un équilibre avec la taille de l'image d'entrée?) --Cadre de nom d'argument = largeur de remplissage. (Souvent arrondi à un petit nombre de $ H / 2 $)

Sera. Il n'y a pas de spécification concernant le nombre de pixels dans l'image d'entrée / sortie.

Normalisation par lots

L.BatchNormalization(96)

L'argument est le nombre de canaux de l'image à normaliser. Ce sera le même que le nombre de canaux de sortie de la convolution précédente ($ M $).

Couche de regroupement

 h = self.bn1(self.conv1(x), test=not self.train)
 h = F.max_pooling_2d(F.relu(h), 3, stride=2)

Le regroupement est effectué après la saisie du résultat de la couche de convolution dans ReLu. Le regroupement prête attention à une certaine zone comme un filtre et génère une valeur représentative de cette zone selon une certaine règle. En conséquence, une invariance de position peut être obtenue. Il existe de nombreuses variantes de mise en commun.

--Mise en commun moyenne: prenez la moyenne des valeurs de la zone --Mise en commun maximale: prenez le maximum de la zone

AlexNet utilise une mise en commun maximale.

Résumant les arguments de F.max_pool_2d (),

--Premier argument: Image d'entrée --Deuxième argument: taille de la zone de regroupement. Si la zone est trop grande, la précision diminuera.

• Troisième argument: largeur de foulée. Habituellement 2 ou plus.

Là encore, le nombre de pixels d'entrée / sortie n'est pas spécifié.

J'ai essayé d'utiliser AlexNet

Dans le prochain article (par écrit), j'écrirai le résultat de l'utilisation d'AlexNet.