Réseau de neurones fully connected et convolutionnel

Reprenons notre perceptron des sections précédentes :

A la couche cachée 1, nous avons trois sorties $o = [o_1^1,o_2^1,o_3^1]$ où $o_i^j$ est la sortie du perceptron $i$ à la couche $j$. Il y a une matrice de poids $\omega^j$ pour chaque couche cachée $j$ qui assure le mapping de la couche $j-1$ à la couche $j$. Ici, la matrice comprend trois vecteurs de poids, un pour chaque perceptron, qu'on peut écrire comme la matrice $ \omega^1 = \begin{bmatrix} w_{10} & w_{11} \\ w_{20} & w_{21} \\ w_{30} & w_{31} \\ \end{bmatrix}$ où chaque ligne représente les poids d'un perceptron. La matrice $\omega^j$ est donc taille $|j| \times |j-1| $ où $|j|$ est la taille de la couche $j$. En effet, ici $ \omega^1$ est de taille $3 \times 2 $

On peut écrire la transition complète de la couche $1$ à la couche $2$ comme suit:

$o_1^1 = f(w_{10}^1 x_1 + w_{11}^1 x_2)$

$o_2^1 = f(w_{20}^1 x_1 + w_{21}^1 x_2)$

$o_3^1 = f(w_{30}^1 x_1 + w_{31}^1 x_2)$

$= o^1 = f(x \cdot \omega^{1^T})$

Les réseaux fully-connected (FC) ne marchent pas comme on le souhaiterait pour tous types d'entrées. Pour les images, par exemple, des entrées 3 dimensions (hauteur x largeur x RGB), les FC ont des difficultés à converger vers un minimum acceptable. Reprenons le dataset LFW de la précédente section. Les images sont de taille $62\times47\times1$ (greyscale), on devrait donc les aplatir pour en créer des entrées $x \in \mathbb{R}^{2914}$ :

In [3]:

# Build the network
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(62*47, 512)
        self.fc2 = nn.Linear(512, 128)
        self.fc3 = nn.Linear(128, n_output)

    def forward(self, x):
        x = x.reshape(x.size(0),-1)
        x = F.tanh(self.fc1(x))
        x = F.tanh(self.fc2(x))
        x = F.tanh(self.fc3(x))
        return x

Nombre de classes: (8,)
['Ariel Sharon' 'Colin Powell' 'Donald Rumsfeld' 'George W Bush'
 'Gerhard Schroeder' 'Hugo Chavez' 'Junichiro Koizumi' 'Tony Blair']
Dataset shape (1348, 62, 47)

Iter 100 - loss: 1.70
Iter 200 - loss: 1.78
Iter 300 - loss: 1.86
Iter 400 - loss: 1.80
Iter 500 - loss: 1.85
Iter 600 - loss: 1.80
Iter 700 - loss: 1.78
Iter 800 - loss: 1.74
Iter 900 - loss: 1.74
Iter 1000 - loss: 1.85
Iter 1100 - loss: 1.77
Iter 1200 - loss: 1.89
Iter 1300 - loss: 1.69
Iter 1400 - loss: 1.94
Iter 1500 - loss: 1.75
Iter 1600 - loss: 1.77
Iter 1700 - loss: 1.66
Iter 1800 - loss: 1.75
Iter 1900 - loss: 1.75

# Build the network
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.conv3 = nn.Conv2d(16, 32, 5)
        self.fc1 = nn.Linear(32 * 4 * 2, 120)
        self.fc2 = nn.Linear(120, n_output)


    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 32 * 4 * 2)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return x

Définition : En analyse fonctionnelle, la convolution est une opération mathématique sur deux fonctions $f$ et $g$ qui produisent une troisième fonction qui exprime comment les formes de ces deux fonctions interagissent entre elles. Une convolution est définie par l'intégrale suivante : $$(f * g)(t) \triangleq\ \int_{-\infty}^\infty f(\tau) g(t - \tau) \, d\tau$$ qui se traduit par un "glissement" de valeur $\tau$ de la fonction $g$ sur la fonction $f$ :

• des entrées deux dimensions, en bleu clair (ou $f$)
• le neurone (perceptron) ou le filtre ($g$), en bleu foncé, qui glisse (convolve en anglais) sur les entrées bleues claires
• le résultat qui se construit au fur et à mesure de la convolution, en gris $(f * g)$

• Sa profondeur (depth) : qui correspond au nombre de filtres (de cellules) qui vont glisser sur le même input. Dans le cas précédent, si on ajoutait un deuxième filtre, la sortie grise serait de taille $3 \times 3 \times2$.
• Son pas (stride): qui correspond au "saut" que fait le filtre à chaque glissement. Dans l'exemple précédent, le saut est de 1.
• Zero-padding : qui correpond à l'ajout d'un bord de 0 (autour de l'input) pour privilégier une taille de sortie que l'on préfèrerait. Le filtre passe sur ces 0 et donc augmente son volume de sorties.

Exercice : Appliquez la formule pour le problème suivant et vérifiez votre solution. Le bord blanc est un zero-padding :

Imaginez le même exercice mais avec un stride $S$ de 3 : cette convolution est-elle possible ?

Attention : Si la connectivité est locale en espace, la connectivité est pleine dans la profondeur. Si une entrée est de taille $W \times W \times 3$ (une image RGB, par exemple), le filtre sera de taille $F \times F \times 3$, comme nous le voyons sur l'image suivante :


Cependant, la taille de la sortie sera toujours le même : le filtre produit toujours une sortie par glissement, peu importe la profondeur. Il y a juste plus de multiplications et de sommes pour obtenir le résultat.

• Réduction de dimension : Réduire la dimension de l'entrée et donc les coûts computationels
• Invariance positionnelle : Extraire les features les plus importantes dans la région peu importe sa position dans le voisinage