Limites des Réseaux de Neurones

Réseaux de Neurones

Modèle implémentant une transformation continue et différentiable de \(\mathbb{R}^n\) dans \(\mathbb{R}^m\) :

Des transformations linéaires
Des fonctions d’activations
Des couches successives

m = nn.Sequential(

nn.Linear(3,4),

nn.ReLU(),

nn.Linear(4,3),

nn.Sigmoid(),

nn.Linear(3,5),

nn.ReLU(),

nn.Linear(5,1),

nn.Sigmoid()

)

Limites

Comment traiter des signaux : image, son, etc. avec un réseau de \(\R^n\) dans \(\R^m\) ?

Exemple : classifier une image (chat, chien, humain), une musique (rock, rap, opera), un texte etc.

Dimension d’entrée très grande voire non bornée :
- Image : une image \(1000 \times 1000\) donne \(n = 3 \times 10^6\) valeurs.
- Son : durée d’une musique pas forcément déterminé à l’avance.
- Texte : longueur du texte arbitraire.

Comment traiter ce genre de données avec des réseaux de neurones ?

Solutions possibles

Borner la taille possible de l’entrée
- Exemple: se limiter à des images \(n \times n\) (cas de MNIST pour les nombres manuscripts)
- +: facile à implémenter
- -: comment traiter des images “plus petites” du jeu de données ?
- -: taille corrélée à la décision.
Utiliser une partie de l’entrée seulement
- Exemple: 20 secondes d’un morceau de musique (cas de Shazam)
- +: peu coûteux et suffisant dans certaines applications (e.g., détecter langue d’un texte)
- -: approximation trop grossière (image)
- -: pas clair de comment choisir le bon extrait
Redimensionner l’entrée
- Image \(n \times n\) redimensionnée vers \(256 \times 256\) (cas de AlexNet)
- +: limite le nombre de poids
- -: dimension toujours élevée
- -: perte d’informations, pas toujours possible (par exemple pour le son?).

Réseaux de Neurones Convolutifs

Convolution 1D

Opération sur les listes
Origine dans le traitement du signal : agréger les informations d’un voisinage dans un point.
On fait “glisser” sur une liste \(L\) \(K\) une petite liste appelée le kernel.

\[ (L*K)[i] = \sum_{a=0}^{k-1} L[i+a] \times K[a] \]

Si \(L\) est de longueur \(l\) et \(K\) de longueur \(k\), alors la liste produite est de longueur \(l-k+1\).

Exemple pour un kernel de taille \(3\) :

K
L	1	4	2	-1	3	8	0	7
K	1	-1	1
K		1	-1	1
K			1	-1	1
K				1	-1	1
K					1	-1	1
K						1	-1	1

L*K	-1	1	6	4	-5	15

Convolution 2D

Pareil pour les matrices
Mathématiquement, si \(M\) est une matrice \(n_1 \times n_2\) et \(K\) une matrice \(k_1 \times k_2\),

\[ (M * K)[i,j] = \sum_{a=0}^{k_1-1} \sum_{b=0}^{k_2-1} M[i+a, j+b] \times K[a,b]\]

où \(0 \leq i < n_1-(k_1-1)\) et \(0 \leq j < n_2 - (k_2-1)\).

\(M*K\) est une matrice \((n_1-k_1+1) \times (n_2 - k_2+1)\).

Image et convolution 2D

Étudié depuis longtemps en traitement de l’image.

Convolutions intéressantes connues :

-2	-1	0
-1	1	1
0	1	2

1	1	1
1	1	1
1	1	1

0	1	0
1	-4	1
0	1	0

Ici, la convolution est appliquée sur chaque couleur \((R, G, B)\) indépendamment (on parle de canaux/channels).

Exemple

M
1	0	1	2
2	3	1	2
0	1	2	0
3	2	2	1

K
1	-1
-1	1

M * K
2	-3	0
0	3	-3
-2	-1	1

Padding

Si \(M\) est une matrice \(n \times n\) et \(K\) une matrice \(k \times k\), alors \(M * K\) est de dimension \(n-k+1 \times n-k+1\).
Parfois utile de garder la même dimension.
Padding: on transforme \(M\) en \(M'\) de taille \(n+k-1 \times n+k-1\) en ajoutant des lignes des des colonnes.
Ainsi : \(M' * K\) est une matrice \(n \times n\).

Padding le plus courant : ajouter des lignes/colonnes nulles (mais aussi : copier les dernières colonnes, copier les première etc.)

Exemple avec padding

Cas d’une convolution avec un kernel \(3 \times 3\)
Ajouter deux colonnes et deux lignes de \(0\).
\(M*K\) a la même dimension que \(M\).

1	0	1	2
2	3	1	2
0	1	2	0
3	2	2	1

0	0	0	0
1	0	1	2
2	3	1	2
0	1	2	0
3	2	2	1
0	0	0	0


0	0	0	0
1	0	1	2
2	3	1	2
0	1	2	0
3	2	2	1
0	0	0	0

K
0	1	0
1	-4	1
0	1	0

M' * K
-2	5	-1	-5
-4	-8	4	-5
6	3	-4	5
-10	-2	-3	-2

Couche de Convolution

Couche appliquant une ou plusieurs convolutions
Paramètres : les kernels de chaque convolution.
Intuition: on apprend les kernels intéressants (et non pas un kernel “connu”)
Donne une couche qui n’est pas complètement interconnectée.
- Moins de paramètres
- Respecte les informations “spatiales” (dans l’image) ou “temporel” (dans une séquence).

En Pytorch

Trois couches principalement : nn.Conv1d (séquences), nn.Conv2d (image), nn.Conv3d (dans l’espace)

nn.Conv2d(in_channel=3, out_channel=5, kernel_size=2)

Kernels de taille kernel_size (ici \(2 \times 2\))
Applique une convolution différente sur chaque canal d’entrée in_channel (couleur RGB, stéréo etc.) et les additionne.
On additionne aussi un biais.
Cela est fait out_channel fois.
On peut spécifier padding = 1 par exemple qui rajoutera deux lignes et deux colonnes de \(0\) (début et fin).

Analyse de paramètres

nn.Conv2d(in_channel=3, out_channel=5, kernel_size=2)

Input \((3, N, M)\) (\(3\) channels, \(N,M\) taille des matrices)
On sort un tenseur de forme \((5, N-2, M-2)\).
Analyse des paramètres :
- \(3\) kernels pour chacun des \(5\) canaux de sorties : 15 matrices \(2 \times 2\) donc 60 paramètres.
- \(5\) biais.
- \(65\) paramètres en tout.

Comparons avec une couche linéaire complètement connectée :

Entrée \(3NM\)
Sortie \(5(N-2)(M-2)\)
Donc on aurait \(15N(N-2)M(M-2)\) paramètres (>30k paramètres pour \(N=M=8\)).

Pooling

Autre aggrégation locale de donnée dans une séquence, matrice etc.
Applique une fonction \(f : Mat(k_1,k_2) \rightarrow \R\)
Décompose la matrice en blocs de taille \(k_1 \times k_2\) disjoints et applique \(f\) indépendamment.

Exemple avec \(k_1=k_2=2\) et \(f = \max\) :

1	0	1	2
2	3	1	2
0	1	2	0
3	2	2	1

\(f(B_1)\)	\(f(B_2)\)
\(f(B_3)\)	\(f(B_4)\)

3	2
3	2

En Pytorch

Beaucoup de couches permettant des opérations de “pooling” :

kernel_size permet de spécifier la taille de bloc
Max: nn.MaxPool1d, nn.MaxPool2d, nn.MaxPool3d
Moyenne: nn.AvgPool1d, nn.AvgPool2d, nn.AvgPool3d etc.

Pas de paramètres entraînables.

Résumé

Pour le traitement d’image (et plus généralement de signaux) :

L’entrée n’est plus nécessairement un vecteur de features
Couches de convolution et de pooling :
- respecte la connectivité locale
- moins de paramètres
Architecture particulièrement adaptée à la reconnaissance d’images.

Limites

On continue à traiter des signaux bornés, donc pas applicable au texte, musique etc.

Besoin d’autres architectures :

Recursive Neural Networks (RNN) : une partie de la sortie est réutilisée dans l’entrée.
Transformers : mécanismes d’attention.

Pytorch : quelques bonnes pratiques

Construction de modèles

Pour construire un modèle, on a essentiellement vu nn.Sequential :

nn.Sequential(
    nn.Linear(10, 3),
    nn.ReLU(),
    nn.Linear(3,1),
    nn.Sigmoid()
)

+ Syntaxe claire
+ Rapide à mettre en place
- Pas de souplesse :
- pas de preprocessing de l’entrée
- pas de réutilisation des couches
- pas contrôle fin : on pourrait vouloir faire \(Ax\) et \(Bx\) pour deux matrices \(A\) et \(B\) différentes et les recombiner.

Par `nn.Module`

On peut être plus fin en créant une nouvelle classe héritée de nn.Module.
Il faut implémenter le constructeur __init__(self) et forward(self,x).

class MyModel(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim
        self.c1a = nn.Linear(dim, dim)
        self.c1b = nn.Linear(dim, dim)
        self.c2 = nn.ReLU()
        self.c3 = nn.Linear(2*dim, 1)
        self.output = nn.Sigmoid()
    def forward(self, x):
        ax = self.c1a(x)
        bx = self.c1b(x)
        x = self.c3(self.c2(torch.cat((ax,bx), dim=1)))
        return self.output(x)

Implémentation automatique de .to(), .parameters() etc.
Permet d’introduire du partage, de la réutilisation etc.
Peut se combiner avec nn.Sequential
nn.Sequential est elle-même une classe héritée de nn.Module

self.c = nn.Sequential(nn.ReLU(), 
    nn.Linear(2*dim, 1), 
    nn.Sigmoid())

`m.train()` et `m.eval()`

Certaines optimisations / certains comportements sont désactivés pendant l’entraînement.
On peut changer le mode en fonction de ce que l’on fait sur le modèle

Cas le plus courant : c = nn.Dropout(p=0.3)

en mode train, cette couche renvoie pour chaque coefficient \(x\) du tenseur d’entrée :
- \(0\) avec probabilité \(0.3\) et
- \(x\) avec probabilité \(0.7\).
permet d’annuler des gradients pendant l’entraînement
évite l’apparition de certaines corrélations entre les neurones
en mode eval, cette couche “disparaît” (renvoie toujours \(x\)).

Enregistrement de modèles

Sauvegarder un modèle entraîné dans un fichier pour :

Continuer l’entraînement plus tard,
Réutiliser en production,
Distribution, etc.

Sérialisation

nn.Module contient une méthode state_dict() qui sérialise les valeurs des attributs :

m = MyModel(2)
print(m.state_dict())

>>> OrderedDict([
>>> ('c1a.weight', tensor([[ 0.2510, -0.6375],
>>>                       [ 0.2481, -0.6280]])), 
>>> ('c1a.bias', tensor([0.1261, 0.2936])), 
>>> ('c1b.weight', tensor([[-0.5350, -0.5719],
>>>                        [-0.2772, -0.0570]])), 
>>> ('c1b.bias', tensor([ 0.4638, -0.3181])), 
>>> ('c3.weight', tensor([[ 0.2049, -0.2333, -0.3563,  0.1219]])), 
>>> ('c3.bias', tensor([-0.3907]))
>>> ])

Importer/exporter la sérialisation

On peut donc exporter cette sérialisation du modèle
torch.save(m.state_dict(), "model.pt")
Exporte un OrderedDict dans un format binaire (librairie Python pickle)
nn.Module contient une méthode .load_state_dict()

m = MyModel(2)
train(m) # on entraîne
torch.save(m.state_dict(), "model.pt")
...
m_new = MyModel(2)
d = torch.load("model.pt")
m_new.load_state_dict(d)

Variation sur les Réseaux de Neurones

Limites des Réseaux de Neurones

Réseaux de Neurones

Limites

Solutions possibles

Réseaux de Neurones Convolutifs

Convolution 1D

Convolution 2D

Image et convolution 2D

Exemple

Padding

Exemple avec padding

Couche de Convolution

En Pytorch

Analyse de paramètres

Pooling

En Pytorch

Résumé

Limites

Pytorch : quelques bonnes pratiques

Construction de modèles

Par nn.Module

m.train() et m.eval()

Enregistrement de modèles

Sérialisation

Importer/exporter la sérialisation

Par `nn.Module`

`m.train()` et `m.eval()`