Retour au blog

Deep Learning : Réseaux de Neurones, CNN et NLP pour les Étudiants en Data

Comment un réseau de neurones calcule et apprend, pourquoi les CNN conviennent aux images et comment l'attention traite le texte, avec trois exercices corrigés.

Cet article a été rédigé à des fins pédagogiques. Les informations présentées peuvent évoluer. Nous t’invitons à vérifier auprès de sources officielles.

Un réseau de neurones profond, l'outil du deep learning (apprentissage profond), empile des couches dont le calcul de base est $\mathbf{a} = f(W\mathbf{x} + \mathbf{b})$ : une combinaison linéaire des entrées, suivie d'une fonction non linéaire $f$. Par exemple, un neurone de poids $(2\,;\,-1)$, de biais $0{,}5$ et de fonction $\mathrm{ReLU}(z) = \max(0\,;\,z)$ transforme l'entrée $(1\,;\,1)$ en $\max(0\,;\,2 - 1 + 0{,}5) = 1{,}5$. Le réseau apprend en ajustant ses poids pour réduire son erreur. Un CNN (réseau convolutif) applique ce calcul aux images avec de petits filtres qui glissent sur les pixels ; en traitement automatique des langues (NLP), l'attention mélange les mots selon leur contexte.

Le neurone et la couche

Un neurone multiplie chaque entrée $x_i$ par un poids $w_i$, qui dit combien elle compte, ajoute un biais $b$, puis applique une fonction d'activation $f$ :

$$y = f\left(\sum_{i=1}^{n} w_i x_i + b\right)$$

ReLU, $\max(0\,;\,z)$, garde le positif et met le négatif à zéro. La sigmoïde $\sigma(z) = \dfrac{1}{1 + e^{-z}}$ envoie tout réel entre 0 et 1 : elle sert à sortir une probabilité.

Formule : une couche dense (chaque neurone y lit toutes les entrées) de $m$ neurones sur $n$ entrées calcule $\mathbf{a} = f(W\mathbf{x} + \mathbf{b})$, où $W$ a une ligne par neurone et $f$ s'applique à chaque coordonnée. Elle compte $mn + m$ paramètres : les poids et les biais.

« Profond » veut dire que les couches s'empilent. Sans activation, l'empilement ne sert à rien : $W_2(W_1\mathbf{x} + \mathbf{b}_1) + \mathbf{b}_2 = (W_2W_1)\mathbf{x} + (W_2\mathbf{b}_1 + \mathbf{b}_2)$ n'est qu'une couche affine. C'est la non-linéarité qui permet à chaque couche de bâtir une représentation plus riche que la précédente.

Apprendre : perte, gradient, rétropropagation

La fonction de perte $L$ mesure l'erreur. Pour prédire un nombre, on prend souvent l'erreur quadratique $(\hat{y} - y)^2$, avec $\hat{y}$ la prédiction et $y$ la bonne réponse. Pour classer, l'entropie croisée $-\ln p$, où $p$ est la probabilité donnée à la bonne classe, est nulle si le réseau est sûr et juste, immense s'il est sûr et faux.

Le gradient, vecteur des dérivées partielles de $L$ par rapport aux paramètres, indique la direction où la perte monte le plus vite : on fait un petit pas dans l'autre sens.

Formule : à chaque étape de la descente de gradient, chaque paramètre $w$ devient

$$w \leftarrow w - \eta\,\frac{\partial L}{\partial w}$$

où le taux d'apprentissage $\eta > 0$ règle la longueur du pas.

La rétropropagation calcule toutes ces dérivées par la règle de dérivation des fonctions composées, de la sortie vers l'entrée. Pour un neurone $\hat{y} = f(z)$ avec $z = wx + b$ : $\dfrac{\partial L}{\partial w} = \dfrac{\partial L}{\partial \hat{y}} \times f'(z) \times x$. Chaque couche réutilise ce qui a été calculé pour la suivante, si bien qu'un seul passage en arrière fournit tous les gradients.

Piège classique : la rétropropagation calcule les gradients, elle ne modifie aucun poids. C'est la descente de gradient qui s'en sert pour les mettre à jour.

Les CNN pour les images

Une photo couleur de $224 \times 224$ pixels, c'est $150\,528$ nombres : un par pixel et par canal (rouge, vert, bleu). Une couche dense de mille neurones posée dessus aurait plus de 150 millions de poids. Elle devrait aussi apprendre un même motif séparément à chaque endroit de l'image.

Un réseau convolutif (CNN) règle les deux problèmes. Un filtre, petite grille de poids de taille $3 \times 3$ par exemple, glisse sur l'image : à chaque position, on multiplie case par case, on additionne et on ajoute un biais. Les résultats forment une carte de caractéristiques. Comme les mêmes poids servent partout (c'est le partage des poids), la couche a peu de paramètres et reconnaît un motif où qu'il soit.

Exemple : le filtre $\begin{pmatrix} 1 & 0 & -1 \\ 1 & 0 & -1 \\ 1 & 0 & -1 \end{pmatrix}$ posé sur la zone $\begin{pmatrix} 9 & 5 & 0 \\ 8 & 5 & 1 \\ 9 & 4 & 0 \end{pmatrix}$ d'une image en niveaux de gris, avec un biais nul, donne $(9 + 8 + 9) - (0 + 1 + 0) = 25$. Sur une zone uniforme, il donnerait 0 : c'est un détecteur de bord vertical.

Formule : une entrée de côté $n$, un filtre de côté $k$, une marge de zéros $p$ (le padding) et un pas $s$ (le stride) donnent une sortie de côté

$$\left\lfloor \frac{n + 2p - k}{s} \right\rfloor + 1$$

où $\lfloor\ \rfloor$ désigne la partie entière. Une couche de $C_{\text{out}}$ filtres $k \times k$ sur $C_{\text{in}}$ canaux compte $(k \times k \times C_{\text{in}} + 1) \times C_{\text{out}}$ paramètres.

Un max-pooling $2 \times 2$ de pas 2 garde ensuite le maximum de chaque carré de quatre valeurs : hauteur et largeur sont divisées par 2, sans aucun paramètre.

Piège classique : en mathématiques, une convolution retourne le noyau avant de le faire glisser. Un CNN ne le retourne pas : la documentation de PyTorch précise que sa couche Conv2d calcule une corrélation croisée. Les poids étant appris, le réseau apprend directement le filtre retourné.

Le NLP et l'attention

Le texte est d'abord découpé en tokens (des mots ou des morceaux de mots), et chaque token reçoit un vecteur appris, son plongement (embedding). Un vecteur fixe par mot ne suffit pas : « avocat » aurait le même dans « j'ai mangé un avocat » et dans « mon avocat a plaidé ».

Les réseaux récurrents (RNN) lisaient la phrase token après token, un calcul séquentiel qui empêche de paralléliser le traitement d'une même phrase, notent Vaswani et ses coauteurs (2017). Leur Transformer remplace la récurrence par l'attention.

Avec trois matrices apprises, chaque token fabrique une requête (ce qu'il cherche), une clé (ce qui permet de le trouver) et une valeur (ce qu'il transmet). Le score entre deux tokens est le produit scalaire de la requête de l'un et de la clé de l'autre. La softmax change ces scores $z_j$ en poids positifs de somme 1, $\dfrac{e^{z_j}}{\sum_i e^{z_i}}$, et la sortie est la somme des valeurs pondérées par ces poids. « Avocat » peut ainsi puiser surtout dans « plaidé ».

Formule : avec les requêtes, les clés et les valeurs rangées en lignes dans $Q$, $K$ et $V$, et $d_k$ la dimension des clés,

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{T}}{\sqrt{d_k}}\right)V$$

La division par $\sqrt{d_k}$ a sa raison. Si les coordonnées d'une requête et d'une clé sont indépendantes, de moyenne 0 et de variance 1, leur produit scalaire a pour variance $d_k$ : sans correction, les scores grandissent avec la dimension, la softmax met presque tout le poids sur un seul token et ses gradients deviennent minuscules. Enfin, l'attention seule ignore l'ordre des mots : le Transformer ajoute donc à chaque plongement un encodage de sa position.

Pourquoi maintenant : la puissance de calcul

Tous ces calculs se ramènent pour l'essentiel à des produits de matrices, comme $W\mathbf{x}$ ou $QK^{T}$ : une masse de multiplications indépendantes, qu'une carte graphique (GPU) exécute en parallèle.

Krizhevsky, Sutskever et Hinton (2012) écrivent que les CNN restaient trop coûteux à grande échelle sur des images en haute résolution, et que les GPU, avec une convolution bien programmée, suffisaient enfin. Leur réseau de 60 millions de paramètres s'entraîne en cinq à six jours sur deux GPU, avec environ 1,2 million d'images étiquetées. Une variante gagne le concours ILSVRC-2012 avec 15,3 % d'erreur top-5 (bonne réponse absente des cinq propositions les plus probables), contre 26,2 % pour le deuxième.

Exercices corrigés

Exercice 1 : Un neurone sans activation prédit $\hat{y} = wx + b$, avec la perte $L = (\hat{y} - y)^2$. On l'entraîne sur l'exemple $x = 2$ et $y = 3$, en partant de $w = 0{,}5$ et $b = 0$. Fais une étape de descente de gradient avec $\eta = 0{,}1$, puis calcule la nouvelle perte. Refais l'étape depuis le même départ avec $\eta = 0{,}25$.

Correction :

Au départ, $\hat{y} = 0{,}5 \times 2 + 0 = 1$ et $L = (1 - 3)^2 = 4$. En dérivant la fonction composée, $\dfrac{\partial L}{\partial w} = 2(\hat{y} - y)\,x = 2 \times (-2) \times 2 = -8$ et $\dfrac{\partial L}{\partial b} = 2(\hat{y} - y) = -4$.

Avec $\eta = 0{,}1$ : $w = 0{,}5 - 0{,}1 \times (-8) = 1{,}3$ et $b = 0 - 0{,}1 \times (-4) = 0{,}4$. La prédiction devient $1{,}3 \times 2 + 0{,}4 = 3$ : la perte tombe à 0.

Avec $\eta = 0{,}25$ : $w = 0{,}5 - 0{,}25 \times (-8) = 2{,}5$ et $b = 0 - 0{,}25 \times (-4) = 1$. La prédiction vaut $2{,}5 \times 2 + 1 = 6$ et la perte $(6 - 3)^2 = 9$. Elle passe de 4 à 9 : avec un taux d'apprentissage trop grand, le pas saute par-dessus le minimum.

Exercice 2 : Une photo couleur de $32 \times 32$ pixels, à 3 canaux, entre dans une couche de 16 filtres $3 \times 3$, de pas 1, avec une marge de zéros de 1. Donne la taille de la sortie et le nombre de paramètres. Compare avec une couche dense qui produirait une sortie de même taille. Que devient la sortie après un max-pooling $2 \times 2$ de pas 2 ?

Correction :

Côté de sortie : $\left\lfloor \dfrac{32 + 2 \times 1 - 3}{1} \right\rfloor + 1 = 32$. Chaque filtre produit une carte, donc la sortie mesure $32 \times 32 \times 16$.

Chaque filtre couvre les 3 canaux : $3 \times 3 \times 3 = 27$ poids et un biais, soit $(27 + 1) \times 16 = 448$ paramètres. Le piège est d'oublier les canaux et de trouver $(9 + 1) \times 16 = 160$.

Une couche dense relierait les $32 \times 32 \times 3 = 3\,072$ entrées aux $32 \times 32 \times 16 = 16\,384$ sorties : $3\,072 \times 16\,384 + 16\,384 = 50\,348\,032$ paramètres, plus de cent mille fois plus. Après le max-pooling, la sortie mesure $16 \times 16 \times 16$, sans paramètre de plus.

Exercice 3 : Un token a pour requête $\mathbf{q} = (1\,;\,1)$. Deux tokens ont pour clés $\mathbf{k}_1 = (1\,;\,1)$ et $\mathbf{k}_2 = (1\,;\,-1)$, et pour valeurs $\mathbf{v}_1 = (1\,;\,0)$ et $\mathbf{v}_2 = (0\,;\,1)$, avec $d_k = 2$. Calcule les poids d'attention, puis la sortie, au centième près.

Correction :

Scores : $\mathbf{q} \cdot \mathbf{k}_1 = 1 + 1 = 2$ et $\mathbf{q} \cdot \mathbf{k}_2 = 1 - 1 = 0$. Divisés par $\sqrt{2}$, ils valent environ $1{,}414$ et $0$.

Softmax : $e^{1{,}414} \approx 4{,}11$ et $e^{0} = 1$, donc les poids valent $\dfrac{4{,}11}{5{,}11} \approx 0{,}80$ et $\dfrac{1}{5{,}11} \approx 0{,}20$.

Sortie : $0{,}80\,\mathbf{v}_1 + 0{,}20\,\mathbf{v}_2 = (0{,}80\,;\,0{,}20)$. Le token puise surtout dans le premier, dont la clé ressemble à sa requête.

À retenir

À retenir :

  • Une couche calcule $\mathbf{a} = f(W\mathbf{x} + \mathbf{b})$ ; sans activation non linéaire, empiler des couches ne sert à rien.
  • La rétropropagation calcule les gradients, la descente de gradient s'en sert : $w \leftarrow w - \eta\,\dfrac{\partial L}{\partial w}$.
  • Une couche de convolution compte $(k \times k \times C_{\text{in}} + 1) \times C_{\text{out}}$ paramètres : n'oublie pas les canaux.
  • L'attention, $\mathrm{softmax}\left(\dfrac{QK^{T}}{\sqrt{d_k}}\right)V$, fait dépendre chaque token de son contexte.
  • Les GPU, en parallélisant les produits de matrices, ont rendu ces réseaux entraînables à grande échelle.

Sources

  • A. Krizhevsky, I. Sutskever et G. E. Hinton, « ImageNet Classification with Deep Convolutional Neural Networks », actes de NIPS 2012 : article en PDF.
  • A. Vaswani et al., « Attention Is All You Need », 2017 : article sur arXiv.
  • Documentation de PyTorch, couche Conv2d (corrélation croisée, taille de la sortie) : docs.pytorch.org.

Tu peux partager cette page librement, en citant ORBITECH AI Academy avec son lien.