Apprentissage profond

Objectifs du chapitre

À la fin de ce chapitre, vous serez capable de:

• expliquer pourquoi un réseau dense est inadapté aux images, et compter les paramètres d'une couche dense et d'une couche convolutive sur une même entrée;
• calculer une convolution discrète à la main et en Python, démontrer la formule de la taille de sortie en fonction du noyau, du pas et de la marge, et calculer le champ récepteur d'un empilement de couches;
• écrire les règles de mise à jour de la descente avec moment et d'Adam, énoncer la normalisation par lots, et démontrer que l'abandon (dropout) avec remise à l'échelle conserve l'espérance des activations;
• calculer à la main une attention $\mathrm{softmax}(Q{K}^{\top }/\sqrt{d_k})V$ sur trois mots, décrire un bloc transformeur et expliquer ce que fait un grand modèle de langage;
• situer l'apprentissage auto-supervisé et les modèles génératifs (auto-encodeurs, réseaux antagonistes génératifs) par rapport à l'apprentissage supervisé du cours;
• construire un exemple adverse par la méthode du signe du gradient sur un modèle linéaire, et expliquer ce qu'il révèle sur la robustesse des réseaux.

Pourquoi la profondeur, et pourquoi la structure

Le chapitre 10 a construit le perceptron multicouche: une suite de couches ${\mathbf{a}}^{[\ell ]}=g^{[\ell ]}(W^{[\ell ]}{\mathbf{a}}^{[\ell -1]}+{\mathbf{b}}^{[\ell ]})$ (relation 10.4), entraînée par rétropropagation du gradient. Le théorème d'approximation universelle (théorème 10.6), admis au chapitre 10, y énonce qu'une seule couche cachée suffit, en principe, à approcher n'importe quelle fonction continue sur un compact. Pourquoi, alors, empiler des dizaines de couches, et pourquoi inventer des couches d'une forme particulière? Ce chapitre répond à ces deux questions, et la réponse tient en un mot: . Le théorème ne dit rien du nombre de neurones nécessaires, ni de la quantité de données qu'il faudrait pour les régler. Un réseau qui épouse la structure de ses données — la géométrie d'une image, l'ordre des mots d'une phrase — apprend avec beaucoup moins de paramètres et beaucoup moins d'exemples qu'un réseau générique de même capacité.

L'expression apprentissage profond (deep learning) désigne l'ensemble des méthodes qui entraînent de tels réseaux à nombreuses couches, de bout en bout, par descente de gradient. Ce n'est pas une rupture mathématique avec les chapitres précédents: la perte est encore une entropie croisée (chapitre 4), l'optimiseur encore une descente de gradient stochastique (chapitre 3), la régularisation encore un moyen de lutter contre le surapprentissage (chapitre 6), et le gradient encore calculé par la règle de la chaîne (chapitre 10). Ce qui change, c'est l'architecture, l'échelle, et une série de procédés pratiques sans lesquels ces grands réseaux ne s'entraînent pas. Nous les verrons dans l'ordre: les réseaux convolutifs pour les images, les techniques d'entraînement, l'attention et les transformeurs pour les suites, puis trois questions qui dépassent le cadre supervisé — apprendre sans étiquettes, générer des données, et résister à un adversaire.

Une image est un tableau à trois indices

Le jeu de données classique des chiffres manuscrits MNIST, diffusé par LeCun et ses coauteurs à la fin des années 1990, contient des images de $28\times 28$ pixels en niveaux de gris, soit $28\times 28\times 1=784$ nombres par image. Pour un perceptron multicouche, une telle image n'est qu'un vecteur $\mathbf{x}\in {\mathbb{R}}^{784}$, obtenu en mettant les lignes bout à bout. Une première couche cachée de 100 neurones a alors une matrice $W^{[1]}$ de taille et un biais de taille 100, soit

paramètres. Pour une photographie en couleurs de $224\times 224$ pixels, taille courante, l'entrée compte $224\times 224\times 3=150528$ nombres, et chaque neurone de la première couche en porte autant de poids.

Le nombre n'est pas le seul défaut. Mettre les lignes bout à bout détruit la géométrie: deux pixels voisins verticalement se retrouvent à 28 positions l'un de l'autre dans le vecteur, et le réseau dense n'en sait rien — si l'on permutait une fois pour toutes les 784 coordonnées de toutes les images, il apprendrait exactement aussi bien, ce qui prouve qu'il n'utilise pas la disposition des pixels. Pire, il doit réapprendre chaque motif à chaque position: un trait vertical en haut à gauche et le même trait en bas à droite activent des poids complètement différents. Or nous savons deux choses sur les images, et le réseau convolutif les inscrit dans son architecture:

• l'information pertinente est d'abord locale: un bord, un coin, une texture se reconnaissent dans un petit voisinage de pixels;
• elle est la même partout: un bord vertical reste un bord vertical à n'importe quel endroit de l'image.

Ces deux hypothèses sont des a priori sur le monde, au même titre que la linéarité du modèle de loyers du chapitre 2. Elles sont très bien vérifiées pour les images, et c'est pourquoi elles paient.

La convolution

Définition et premier calcul

L'idée est de faire glisser sur l'image un petit tableau de poids, le noyau, et de calculer en chaque position une somme pondérée des pixels qu'il recouvre.

Les mathématiciens appellent (11.1) une corrélation croisée (cross-correlation): la convolution au sens de l'analyse retourne le noyau, $K_{k+1-u,k+1-v}$ au lieu de $K_{uv}$. La distinction est sans conséquence ici, puisque le noyau est appris: un réseau qui aurait besoin du noyau retourné l'apprendrait retourné. Toutes les bibliothèques d'apprentissage profond calculent (11.1) et l'appellent convolution; nous suivons cet usage, mais l'exercice 11.2 vérifie que vous ne retournez pas le noyau.

La taille de la sortie

Combien de positions la fenêtre peut-elle prendre? La question paraît anodine; elle décide de la forme de chaque tenseur d'un réseau, et une erreur d'une unité y fait échouer un programme entier.

Démonstration. Après ajout de la marge, l'image a $m=n+2p$ lignes, numérotées de 1 à $m$. D'après (11.1), la sortie de rang $i$ utilise les lignes $s(i-1)+1$ à $s(i-1)+k$. La première ligne utilisée est toujours dans l'image; la position est donc valide si et seulement si la dernière l'est aussi:

Comme $i-1$ est un entier, cette condition équivaut à $i-1\le \lfloor (m-k)/s\rfloor$, et ce nombre est positif ou nul puisque $k\le m$. Les positions valides sont donc $i=1,2,\dots ,\lfloor (m-k)/s\rfloor +1$, et leur nombre est (11.2). Le même raisonnement vaut pour les colonnes.

Trois cas particuliers reviennent sans cesse. Sans marge et avec un pas de 1, $n^{\prime }=n-k+1$: chaque convolution rogne l'image de $k-1$ pixels, $6-3+1=4$ à l'exemple 11.1. Avec un noyau de côté impair et un pas de 1, la marge donne : c'est la convolution «de même taille» (), qui permet d'empiler des couches sans voir l'image fondre: une image de parcourue par un noyau avec une marge de 2 garde son côté de 28. Enfin, un pas divise le côté par deux environ: avec un noyau , une marge de 3 et un pas de 2, une image de côté 224 en donne une de côté .

Plusieurs canaux, plusieurs filtres

Une image en couleurs a trois canaux, et une couche convolutive doit produire plusieurs cartes, une par motif recherché. La définition 11.2 s'étend sans difficulté.

Une couche convolutive est un cas particulier de couche dense. Si l'on aplatit $X$ et $Y$ en vecteurs, (11.3) est bien de la forme $g(W\mathbf{x}+\mathbf{b})$, pour une matrice $W$ très particulière: presque tous ses coefficients sont nuls (chaque sortie ne dépend que d'une fenêtre $k\times k$), et les coefficients non nuls se répètent d'une ligne à l'autre (chaque sortie utilise les mêmes poids). Ce sont deux contraintes, et elles divisent le nombre de paramètres de façon spectaculaire.

Démonstration. Chaque filtre est un tableau $k\times k\times C_{\text{in}}$, soit $k^2{C}_{\text{in}}$ poids, auquel s'ajoute un biais: $k^2{C}_{\text{in}}+1$ paramètres. Il y a filtres, d'où (11.4). Aucun de ces nombres ne dépend de ni de , parce que le partage des poids fait servir chaque filtre à toutes les positions. La couche dense, elle, a une matrice de poids dont le nombre de lignes est le nombre de sorties, , et le nombre de colonnes celui des entrées, , plus un biais par sortie: paramètres.

Sur une image MNIST, une couche de six filtres $5\times 5$ avec une marge de 2 produit six cartes de $28\times 28$ et compte $6\times (25+1)=156$ paramètres. Une couche dense de même entrée et de même sortie en compterait $(784+1)\times 4704=3692640$, plus de vingt mille fois plus. Le rapport croît avec la taille de l'image: la couche convolutive ne grossit pas, la couche dense grossit comme le carré du nombre de pixels.

L'explorateur suivant applique quatre noyaux classiques à une petite image fictive. Ces noyaux sont écrits à la main; dans un réseau, les poids des filtres sont appris, et l'on constate que les filtres de la première couche d'un réseau entraîné sur des photographies ressemblent souvent à des détecteurs de bords et de taches de couleur de ce genre.

Remarquez, dans l'explorateur, la deuxième colonne de la sortie pour le détecteur de bords verticaux: la barre de valeur 5, dans la deuxième colonne de l'image, y donne $-12$ (transition de 5 à 1 en allant vers la droite) et non $+12$, alors que le bord gauche du rectangle clair, de 1 à 8, donne $+21$. Le signe porte la direction de la transition; c'est pourquoi un réseau a besoin de plusieurs filtres, et pourquoi la ReLU qui suit, en annulant les valeurs négatives, rend chaque carte sensible à une seule des deux directions.

Équivariance par translation

Le partage des poids a une conséquence géométrique précise: si l'on déplace l'image, la carte de caractéristiques se déplace de la même façon.

Démonstration. Calculons le membre de gauche en $(i,j)$ avec (11.1), pour $s=1$:

La dernière somme est exactement $(X\star K{)}_{i-a,j-b}$, c'est-à-dire $({\tau }_{a,b}(X\star K){)}_{ij}$.

En mots: détecter puis déplacer revient à déplacer puis détecter. Un bord vertical produit la même réponse où qu'il se trouve, simplement à un autre endroit de la carte. Sur une image finie et sans marge circulaire, l'identité (11.5) ne vaut qu'à l'écart des bords: ce qui sort de l'image est perdu. Décalez d'une colonne vers la droite l'image de l'exemple 11.1 (en complétant à gauche par des 1): la première ligne de la carte devient $(0,0,14,21)$, la première ligne d'origine $(0,14,21,7)$ décalée d'une case, le 7 étant sorti par la droite.

Il faut distinguer équivariance et invariance. La convolution est équivariante: la sortie bouge avec l'entrée. Pour classer une image, on veut au contraire une sortie invariante — «il y a un chat» ne doit pas dépendre de la position du chat. L'invariance s'obtient progressivement, en résumant les cartes sur des régions de plus en plus grandes, ce qui est le rôle du sous-échantillonnage.

Sous-échantillonnage et champ récepteur

Appliqué à la carte de l'exemple 11.1, le maximum sur des blocs $2\times 2$ donne $\left(\begin{array}{cc}14& 21\\ 0& 21\end{array}\right)$. Il garde la réponse la plus forte de chaque bloc et oublie sa position exacte à l'intérieur du bloc: un petit déplacement du motif qui ne le fait pas changer de bloc ne change rien. C'est une invariance approximative et locale seulement — l'exercice 11.2 montre qu'un décalage d'une colonne peut tout de même modifier la sortie, quand le maximum passe d'un bloc au voisin. Le sous-échantillonnage a un second effet, plus important encore: il agrandit la région de l'image que voit chaque neurone des couches suivantes.

La relation (11.6) se lit ainsi: un neurone de la couche $\ell$ regarde $k_{\ell }$ neurones voisins de la couche précédente, espacés de $j_{\ell -1}$ pixels d'entrée; ils couvrent ensemble $(k_{\ell }-1)j_{\ell -1}$ pixels de plus qu'un seul d'entre eux. Pour un empilement «convolution , convolution , maximum de pas 2, convolution », tous les pas de convolution valant 1, on trouve successivement , , puis , avec qui passe de 1 à 2 après le sous-échantillonnage. Le dernier neurone voit un carré de pixels, alors que chacun de ses filtres n'a que coefficients. Deux convolutions successives voient autant qu'une seule (), avec poids par paire de canaux au lieu de 25, et une non-linéarité de plus entre les deux. C'est ainsi que les réseaux profonds construisent une : les premières couches voient des bords, les suivantes des combinaisons de bords — des coins, des textures —, puis des parties d'objets, et les dernières l'objet entier.

Un petit réseau convolutif

Les couches de convolution, de sous-échantillonnage et les couches denses s'assemblent en un réseau convolutif (convolutional neural network, CNN). Le premier à avoir été largement utilisé est le réseau LeNet, décrit par LeCun, Bottou, Bengio et Haffner en 1998 pour lire des chiffres manuscrits, notamment sur des chèques. Nous en étudions une version simplifiée, inspirée de LeNet-5 mais pas identique à lui: l'original prenait des images de $32\times 32$ et reliait ses cartes de façon partielle, ce qui donne d'autres nombres de paramètres que ceux de l'exemple suivant.

Cette disposition — des convolutions et des sous-échantillonnages qui réduisent la taille spatiale en augmentant le nombre de canaux, puis quelques couches denses — est restée le schéma de base des réseaux de vision pendant longtemps. Le réseau de Krizhevsky, Sutskever et Hinton, présenté en 2012 et souvent appelé AlexNet, l'a porté à une tout autre échelle sur la base d'images ImageNet: plus de couches, des images en couleurs bien plus grandes, la ReLU, l'abandon, l'augmentation de données et un entraînement sur cartes graphiques. Sa nette victoire au concours de classification ImageNet de 2012 est le moment où l'apprentissage profond s'est imposé en vision par ordinateur. Les architectures qui ont suivi ont surtout ajouté de la profondeur, et les procédés de la section suivante sont ceux qui l'ont rendue possible.

Entraîner un réseau profond

Un réseau profond s'entraîne comme tous les modèles du cours: on minimise une fonction de coût $J(\mathbf{\theta })$ par descente de gradient, le gradient étant calculé par rétropropagation (chapitre 10). Mais trois difficultés grandissent avec la profondeur et la taille. Le coût est très mal conditionné, au sens du chapitre 3, et la descente simple y progresse lentement. Les activations et les gradients changent d'échelle d'une couche à l'autre, ce qui rend l'entraînement instable. Et le nombre de paramètres dépasse souvent celui des exemples, si bien que le surapprentissage menace en permanence. Chacune de ces difficultés a ses remèdes.

Moment et Adam

Le chapitre 3 a présenté la descente stochastique par mini-lots et annoncé, sans les écrire, les deux améliorations qui l'accompagnent presque toujours. Notons ${\mathbf{g}}^{(k)}=\nabla J_{B_k}({\mathbf{\theta }}^{(k)})$ le gradient calculé sur le mini-lot $B_k$ à l'itération ; c'est une estimation sans biais du gradient complet.

L'article d'Adam note $\mathbf{v}$ la seconde moyenne; nous l'appelons $\mathbf{r}$ pour ne pas la confondre avec la vitesse du moment. En déroulant (11.7), ${\mathbf{v}}^{(k+1)}={\mathbf{g}}^{(k)}+\beta {\mathbf{g}}^{(k-1)}+{\beta }^2{\mathbf{g}}^{(k-2)}+\cdots$: le pas est une somme des gradients passés, pondérés par des puissances de . Si le gradient garde le même signe, les termes s'accumulent jusqu'à fois le gradient, soit dix fois avec ; s'il change de signe à chaque itération, comme dans le zigzag d'une vallée étroite (chapitre 3), ils se compensent. Pour mesurer l'effet, prenons la fonction quadratique , de conditionnement , et partons de . La descente simple avec , juste sous la limite du chapitre 3, a besoin de 361 itérations pour que passe sous . Avec le même pas et , le moment y parvient en 132 itérations, et en 58 avec le réglage optimal pour cette fonction, et .

Adam répond à une autre difficulté: des paramètres dont les gradients ont des échelles très différentes. Le facteur $1/\sqrt{{\hat{r}}_j}$ divise chaque coordonnée par une estimation de l'amplitude de ses gradients récents. Au premier pas, la correction de biais donne ${\hat{m}}_j=g_j$ et , donc un pas , presque exactement fois le de : que le gradient vaille ou , la coordonnée bouge de . Sans la division par et , les moyennes mobiles, parties de zéro, seraient faussées au début: pour un premier gradient , on aurait et , et un pas de au lieu de . L'exercice 11.3 reprend ces calculs.

Normalisation par lots et connexions résiduelles

Dans un réseau profond, la distribution des entrées de chaque couche change à chaque mise à jour des couches précédentes, et ses valeurs peuvent dériver vers des échelles où les activations saturent ou explosent. La normalisation par lots (batch normalization), proposée par Ioffe et Szegedy en 2015, standardise chaque pré-activation sur le mini-lot, exactement comme le chapitre 3 standardisait les caractéristiques. Pour une coordonnée $z$ et un mini-lot de $b$ valeurs $z_1,\dots ,z_b$ (la taille $b$ du chapitre 3), elle calcule

où $\gamma$ et $\beta$ sont deux paramètres appris, qui permettent au réseau de retrouver n'importe quelle moyenne et n'importe quel écart type s'il en a besoin. Pendant l'entraînement, ${\mu }_B$ et ${\sigma }_B^2$ sont ceux du mini-lot; au test, on utilise des moyennes de ces quantités accumulées pendant l'entraînement, pour que la prédiction d'un exemple ne dépende pas des autres exemples du lot. Le procédé permet en pratique des pas plus grands et rend l'entraînement moins sensible à l'initialisation; l'explication proposée à l'origine, en termes de dérive des distributions internes, est discutée, et le mécanisme exact de son efficacité fait encore l'objet de recherches.

Le second procédé est la connexion résiduelle (residual connection, ou skip connection), popularisée par les réseaux ResNet de He, Zhang, Ren et Sun (2016): un bloc calcule ${\mathbf{a}}^{[\ell +1]}={\mathbf{a}}^{[\ell ]}+F({\mathbf{a}}^{[\ell ]})$ au lieu de $F({\mathbf{a}}^{[\ell ]})$. La dérivée de la sortie par rapport à l'entrée du bloc contient alors le terme identité, et le gradient rétropropagé dispose d'un chemin direct à travers tous les blocs: c'est un remède à la disparition du gradient décrite au chapitre 10. Ces connexions ont permis d'entraîner des réseaux de plus de cent couches, et on les retrouvera dans le transformeur.

L'abandon

Un grand réseau peut mémoriser son jeu d'entraînement, comme la règle du plus proche voisin du chapitre 1. Les régularisations du chapitre 6 — pénalité sur les poids $\lambda \Vert \mathbf{w}{\Vert }_2^2$ (weight decay, définition 10.6) et arrêt précoce — s'appliquent toujours. L'abandon en est une autre, propre aux réseaux, proposée par Srivastava, Hinton, Krizhevsky, Sutskever et Salakhutdinov (2014).

Chaque passage d'entraînement utilise ainsi un sous-réseau tiré au hasard. Un neurone ne peut pas compter sur la présence d'un voisin précis pour corriger ses erreurs, ce qui décourage les co-adaptations fragiles entre neurones et force des représentations redondantes. On peut aussi voir l'abandon comme l'entraînement simultané d'un nombre exponentiel de sous-réseaux qui partagent leurs poids, dont le réseau complet, au test, fait une sorte de moyenne. Reste à justifier le facteur $1/(1-p)$.

Démonstration. La variable ${\xi }_j$ vaut 1 avec probabilité $1-p$, donc $\mathbb{E}[{\xi }_j]=1-p$. Par linéarité, $a_j$ et étant des constantes,

De même, $\mathbb{E}[z]={\sum }_j{w}_j\mathbb{E}[{\tilde{a}}_j]+b={\mathbf{w}}^{\top }\mathbf{a}+b$.

Sans le facteur $1/(1-p)$, la couche suivante recevrait pendant l'entraînement des entrées d'espérance $(1-p)a_j$, et au test des entrées $a_j$, plus grandes: le réseau verrait au test des échelles qu'il n'a jamais rencontrées. Il y a deux façons équivalentes de corriger cet écart. L'article de 2014 entraîne sans remise à l'échelle et multiplie les poids sortants par la probabilité de conservation au test; la version (11.9), dite abandon inversé, fait la correction pendant l'entraînement et laisse le réseau de test intact, ce qui est la convention des bibliothèques actuelles. Attention à une autre différence de convention: l'article note la probabilité de un neurone, les bibliothèques la probabilité de l', comme nous.

Le théorème parle de l'espérance de la pré-activation, qui est linéaire en $\tilde{\mathbf{a}}$. Après une non-linéarité, l'espérance n'est plus conservée exactement, puisque $\mathbb{E}[g(z)]\ne g(\mathbb{E}[z])$ en général: le réseau de test n'est qu'une approximation de la moyenne des sous-réseaux. L'approximation fonctionne bien en pratique, ce qui est un constat empirique et non un théorème. Pour fixer les idées, avec $\mathbf{a}=(2,4,6,8)$ et , le masque transmet ; la moyenne exacte de sur les seize masques possibles, pondérés par leurs probabilités, redonne .

Augmentation de données et apprentissage par transfert

La meilleure régularisation reste d'avoir plus de données. Quand on ne peut pas en collecter, on peut parfois en fabriquer: c'est l'augmentation de données (data augmentation). On applique à chaque image d'entraînement, à chaque époque, une transformation aléatoire qui ne change pas son étiquette — un recadrage légèrement décalé, une symétrie gauche–droite, une petite rotation, une variation de luminosité ou de contraste —, et le réseau voit à chaque passage une version un peu différente de la même image. C'est une manière d'enseigner l'invariance que l'architecture ne garantit pas: la convolution est équivariante par translation, mais elle ne sait rien des rotations ni des changements d'éclairage.

Le choix des transformations est un a priori sur le problème, et il peut être faux. Une symétrie gauche–droite convient à des photographies d'animaux; elle transforme un «b» en «d» et ne convient pas à la lecture de lettres. Une rotation de 180 degrés change un 6 en 9. Une augmentation doit préserver l'étiquette pour la tâche visée, pas en général.

L'apprentissage par transfert (transfer learning) répond au même manque de données par un autre moyen. Les premières couches d'un réseau entraîné sur un grand jeu d'images généralistes ont appris des détecteurs de bords, de textures et de formes qui servent pour presque toutes les images. Pour un nouveau problème avec peu d'exemples — reconnaître une dizaine de maladies sur des feuilles de vigne à partir de quelques centaines de photographies, disons —, on reprend ce réseau préentraîné, on remplace sa dernière couche par une couche adaptée aux nouvelles classes, et l'on n'entraîne d'abord que cette couche, les autres étant gelées; on peut ensuite ajuster finement (fine-tune) tout le réseau avec un petit pas. La dernière couche est alors une régression logistique multinomiale (chapitre 4) sur des caractéristiques apprises ailleurs: le réseau préentraîné joue le rôle de la conception des caractéristiques du chapitre 1, mais apprise au lieu d'être écrite à la main.

Attention et transformeurs

Le problème des suites

Une phrase, une série temporelle, une séquence d'ADN sont des suites de longueur variable, et le sens d'un élément dépend des autres, parfois très éloignés. Dans «le chat que les enfants du voisin ont recueilli l'hiver dernier dort», le verbe «dort» s'accorde avec «chat», neuf mots plus tôt. Une convolution ne voit qu'une fenêtre locale; il faudrait en empiler beaucoup pour relier des mots éloignés. Les réseaux récurrents (recurrent neural networks), qui lisent la suite mot à mot en entretenant un état, ont longtemps été la réponse, mais ils doivent transporter l'information de proche en proche, et leur calcul est séquentiel par nature. Le mécanisme d'attention permet au contraire à chaque position de consulter directement toutes les autres, en un seul calcul parallèle. Le transformeur (transformer), introduit par Vaswani et ses coauteurs en 2017 dans un article intitulé «Attention Is All You Need», repose entièrement sur lui.

Une suite de $n$ éléments est représentée par une matrice $X\in {\mathbb{R}}^{n\times d}$ dont la ligne $t$ est un vecteur ${\mathbf{x}}_t$ décrivant l'élément $t$. Pour un texte, les éléments sont des jetons (tokens) — des mots ou des morceaux de mots — et ${\mathbf{x}}_t$ est un (): un vecteur appris, une ligne d'une table de taille où est le vocabulaire. Le chapitre 13 montre comment de tels vecteurs peuvent se lire comme une factorisation des cooccurrences de mots.

L'attention par produit scalaire

L'idée est celle d'une recherche dans une table associative, rendue continue. Chaque position émet une requête (query) ${\mathbf{q}}_t$; chaque position offre une clé (key) ${\mathbf{k}}_s$ et une valeur (value) ${\mathbf{v}}_s$. La requête est comparée à toutes les clés par un produit scalaire, les scores sont transformés en poids par une softmax, et la sortie est la moyenne des valeurs pondérée par ces poids. Une table ordinaire rendrait la valeur de la seule clé égale à la requête; l'attention rend un mélange, dominé par les clés les plus semblables.

C'est la promesse du chapitre 4 tenue: la softmax qui transformait des scores de classes en probabilités transforme ici des scores de ressemblance en poids de mélange. Ses deux propriétés y servent aussitôt. Les poids sont positifs et de somme 1, donc chaque sortie est une moyenne pondérée des valeurs, dans leur enveloppe convexe. Et l'invariance par ajout d'une constante permet de soustraire le plus grand score de chaque ligne avant l'exponentielle.

Pourquoi diviser par $\sqrt{d_k}$? Si les coordonnées des requêtes et des clés sont indépendantes, centrées et de variance 1, le produit scalaire ${\mathbf{q}}^{\top }\mathbf{k}={\sum }_{i=1}^{d_k}{q}_i{k}_i$ est une somme de termes centrés de variance 1, donc de variance (Probabilités et statistique, chapitre 7). Ses valeurs typiques sont de l'ordre de : pour , des scores de plusieurs dizaines, et une softmax si piquée qu'elle met presque tout le poids sur une seule clé, avec des gradients presque nuls pour les autres. La division ramène la variance des scores à 1, quelle que soit la dimension.

L'auto-attention

Dans l'exemple, $Q$, $K$ et $V$ étaient donnés. Dans un transformeur, ils sont calculés à partir de la même suite: c'est l'auto-attention.

Chaque tête peut apprendre une forme de relation différente — l'une reliant un verbe à son sujet, une autre un pronom à ce qu'il désigne, par exemple —, même si l'interprétation des têtes d'un réseau entraîné est souvent moins nette que ces exemples ne le suggèrent. Les paramètres $W_Q$, $W_K$, $W_V$ sont partagés entre toutes les positions: comme la convolution, l'auto-attention a un nombre de paramètres qui ne dépend pas de la longueur de la suite. Mais elle n'a aucune notion d'ordre, et c'est pourquoi l'encodage positionnel est indispensable.

Démonstration. Remplacer $X$ par $PX$ remplace $Q$, $K$ et $V$ par $PQ$, $PK$ et $PV$. La matrice des scores devient $PQ(PK{)}^{\top }/\sqrt{d_k}=P(Q{K}^{\top }/\sqrt{d_k})P^{\top }$: ses lignes et ses colonnes sont permutées de la même façon. La softmax s'applique ligne par ligne, et elle commute avec une permutation des coordonnées d'un vecteur, puisque permuter les permute les sans changer leur somme. Donc pour toute matrice de scores . En notant , il vient

puisque $P^{\top }P=I$ pour une matrice de permutation. $\square$

«Le chat mange la souris» et «la souris mange le chat» contiennent les mêmes jetons: sans information de position, l'auto-attention leur attribuerait les mêmes sorties, simplement réordonnées. En ajoutant ${\mathbf{p}}_t$ à ${\mathbf{x}}_t$, le même mot reçoit une représentation différente selon sa place. Les sinus de (11.11) oscillent à des fréquences qui décroissent géométriquement avec $i$: avec $d=4$, la position $t=1$ reçoit , la position 2 reçoit . Les premières coordonnées distinguent des positions voisines, les dernières varient lentement et situent la position à grande échelle. De nombreux modèles récents apprennent plutôt leurs encodages, ou les remplacent par d'autres procédés; l'idée reste d'injecter l'ordre que l'attention ignore.

Le bloc transformeur

Un transformeur empile des blocs identiques dans leur forme, chacun avec ses propres paramètres. Le bloc encodeur de l'article de 2017 enchaîne deux sous-blocs, chacun entouré d'une connexion résiduelle suivie d'une normalisation de couche (layer normalization), qui standardise chaque vecteur ${\mathbf{x}}_t$ sur ses $d$ coordonnées — et non sur le mini-lot comme la normalisation par lots:

où $\mathrm{MH}$ désigne l'auto-attention multi-têtes (multi-head). Le sous-bloc $\mathrm{FF}$ (feed-forward) est un perceptron à une couche cachée, $\mathrm{FF}(\mathbf{u})=W_2\mathrm{ReLU}(W_1\mathbf{u}+{\mathbf{b}}_1)+{\mathbf{b}}_2$, appliqué ; sa couche cachée a une largeur supérieure à . Les deux sous-blocs se partagent le travail: l'attention fait circuler l'information les positions, le réseau la transforme position. Plusieurs variantes placent la normalisation avant chaque sous-bloc plutôt qu'après; le principe est le même.

Le coût de l'attention est le prix de sa portée. La matrice des scores a $n^2$ coefficients par tête, et son calcul demande de l'ordre de $n^{2}d$ opérations: doubler la longueur du texte quadruple ce coût. Les paramètres, eux, ne dépendent pas de $n$; le problème guidé 11.1 les compte pour la configuration de base de l'article de 2017.

Les grands modèles de langage

Un modèle de langage (language model) attribue une probabilité à une suite de jetons $w_1,\dots ,w_T$. La règle de multiplication des probabilités conditionnelles l'écrit sans perte de généralité comme un produit de prédictions du jeton suivant.

Un grand modèle de langage (large language model, LLM) est un modèle de ce genre réalisé par un transformeur de grande taille: une pile de blocs comme (11.12), dans laquelle l'attention est masquée pour que la position $t$ ne consulte que les positions $1$ à $t$ — on met à $-\infty$ les scores des positions futures avant la softmax, ce qui annule leurs poids (exercice 11.4). La dernière couche produit $|\mathcal{V}|$ scores, et la softmax en fait la loi du jeton suivant: c'est, à l'échelle d'un vocabulaire de dizaines de milliers de jetons, exactement la régression logistique multinomiale du chapitre 4, appliquée à des caractéristiques calculées par le transformeur. Les plus grands modèles dont l'architecture a été publiée comptent des dizaines, voire des centaines de milliards de paramètres; l'article qui a décrit GPT-3 (Brown et al., 2020), par exemple, fait état de 175 milliards. Les détails des modèles commerciaux récents ne sont généralement pas publiés, et nous n'en citerons pas.

Pour générer un texte, on tire le jeton suivant selon la loi prédite, on l'ajoute à la suite, et l'on recommence. Le tirage est souvent modulé par une température $\tau >0$, qui remplace les scores $\mathbf{z}$ par $\mathbf{z}/\tau$ avant la softmax. Avec les scores $(2;1;0,1)$ du chapitre 4, la température $1$ donne $(0,659;0,242;0,099)$, la température donne , plus déterministe, et la température donne , plus variée.

Il faut dire honnêtement ce que ce mécanisme est, et ce qu'il n'est pas. Le modèle est entraîné à produire des continuations probables de textes semblables à ceux de son corpus; rien dans la perte (11.14) ne distingue un énoncé vrai d'un énoncé plausible. Un modèle de langage peut donc produire avec assurance des affirmations fausses, des références qui n'existent pas ou des calculs erronés — on parle d'hallucinations. Les modèles conversationnels subissent, après ce préentraînement, un ajustement sur des exemples d'instructions et des préférences exprimées par des humains, qui améliore beaucoup leur utilité sans changer la nature de l'objectif de départ. Leur évaluation pose aussi un problème que le chapitre 5 vous a appris à reconnaître: un corpus d'entraînement prélevé sur le web peut contenir les questions mêmes d'un test publié, et un score élevé sur ce test peut alors mesurer en partie la mémorisation plutôt que la généralisation.

Au-delà de l'apprentissage supervisé

Apprendre sans étiquettes: l'auto-supervision

Les étiquettes coûtent cher; le texte et les images brutes, beaucoup moins. L'apprentissage auto-supervisé (self-supervised learning) fabrique une tâche supervisée à partir des données elles-mêmes, en cachant une partie de chaque exemple et en demandant au réseau de la retrouver. La prédiction du jeton suivant, perte (11.14), en est l'exemple le plus important: chaque texte fournit ses propres étiquettes, autant qu'il a de jetons, sans aucune annotation humaine. D'autres variantes masquent des mots au milieu d'une phrase et les font deviner à partir du contexte des deux côtés — c'est l'objectif du modèle BERT —, ou, pour les images, masquent des morceaux d'image à reconstruire, ou demandent que deux versions augmentées d'une même image reçoivent des représentations proches et que des images différentes en reçoivent d'éloignées (apprentissage contrastif). Dans tous les cas, la tâche de prétexte n'est pas le but: elle force le réseau à construire des représentations qui servent ensuite, par transfert, à des tâches supervisées pour lesquelles on n'a que peu d'étiquettes. C'est la frontière entre le supervisé et le non supervisé du chapitre 1 qui devient poreuse: les données sont non étiquetées, la méthode est supervisée.

Les modèles génératifs

Tous les modèles du cours, jusqu'ici, prédisent une étiquette $y$ à partir de $\mathbf{x}$. Un modèle génératif apprend au contraire la loi des $\mathbf{x}$ eux-mêmes, assez bien pour en produire de nouveaux: des images de visages qui n'existent pas, des phrases, des sons. Un modèle de langage autorégressif est déjà un modèle génératif de texte. Deux autres familles méritent d'être nommées.

Un auto-encodeur (autoencoder) est formé d'un encodeur $\mathrm{enc}$, qui comprime $\mathbf{x}$ en un code $\mathbf{c}=\mathrm{enc}(\mathbf{x})$ de petite dimension, et d'un décodeur $\mathrm{dec}$ qui tente de le reconstruire; on minimise l'erreur de reconstruction $\frac{1}{n}{\sum }_i\Vert {\mathbf{x}}_i-\mathrm{dec}(\mathrm{enc}({\mathbf{x}}_i)){\Vert }^2$. Le goulet d'étranglement oblige le code à retenir l'essentiel. Avec un encodeur et un décodeur linéaires, le meilleur auto-encodeur retrouve le sous-espace de l'analyse en composantes principales du chapitre 13; avec des réseaux profonds, il apprend des compressions non linéaires. Pour en faire un générateur, il faut savoir quels codes tirer: c'est ce qu'ajoutent les (), qui imposent au code une loi simple, gaussienne par exemple.

Pour $G$ fixé, maximiser (11.15) en $D$, c'est entraîner une régression logistique (au sens large: $D$ est un réseau) à distinguer les vrais exemples, étiquette 1, des faux, étiquette 0: l'objectif est l'opposé d'une entropie croisée binaire du chapitre 4. Le générateur, lui, cherche à tromper ce classifieur. L'exercice 11.5 montre que, pour $G$ fixé, le meilleur discriminateur vaut $D^{\ast }(\mathbf{x})=p_{\text{donneˊes}}(\mathbf{x})/(p_{\text{donneˊes}}(\mathbf{x})+p_G(\mathbf{x}))$, et qu'il ne peut faire mieux que partout quand la loi des faux coïncide avec celle des vrais. L'entraînement alterne des pas de gradient sur et sur ; il est notoirement délicat, et l'un de ses échecs typiques est l' (), où le générateur ne produit plus qu'une petite variété d'exemples qui trompent bien le discriminateur. Les , qui apprennent à débruiter progressivement une image partie d'un bruit pur, sont une autre famille générative très utilisée aujourd'hui pour les images; nous n'en dirons pas plus.

Les exemples adverses

Un classifieur d'images peut atteindre une excellente erreur de test et se tromper pourtant sur une image modifiée de façon imperceptible pour un humain. Szegedy et ses coauteurs l'ont documenté en 2014 sur des réseaux profonds; Goodfellow, Shlens et Szegedy (2015) en ont proposé une explication simple et une méthode de construction rapide. On cherche, pour un exemple $(\mathbf{x},y)$ bien classé, une perturbation $\mathbf{\delta }$ petite qui fasse croître la perte $\ell (f(\mathbf{x}+\mathbf{\delta }),y)$ le plus possible. «Petite» se mesure le plus souvent coordonnée par coordonnée: aucun pixel ne bouge de plus de $\epsilon$, c'est-à-dire $\Vert \mathbf{\delta }{\Vert }_{\infty }={\max }_j|{\delta }_j|\le \epsilon$.

Pourquoi le signe? Au premier ordre, $\ell (\mathbf{x}+\mathbf{\delta })\approx \ell (\mathbf{x})+{\nabla }_{\mathbf{x}}{\ell }^{\top }\mathbf{\delta }$, et la méthode choisit la perturbation qui maximise ce terme linéaire sous la contrainte $\Vert \mathbf{\delta }{\Vert }_{\infty }\le \epsilon$. Pour un modèle linéaire, l'approximation est exacte au niveau du score, et le résultat est un théorème.

Démonstration. La variation du score est ${\mathbf{w}}^{\top }\mathbf{\delta }={\sum }_j{w}_j{\delta }_j$. Par l'inégalité triangulaire et $|{\delta }_j|\le \epsilon$,

Pour ${\delta }_j=\epsilon \mathrm{signe}(w_j)$, chaque terme vaut $w_j\epsilon \mathrm{signe}(w_j)=\epsilon |w_j|$, et la somme vaut exactement ; le signe opposé donne .

Pour la régression logistique, le chapitre 4 a montré que le gradient de l'entropie croisée par rapport au score vaut $\hat{p}-y$; par la règle de la chaîne, son gradient par rapport à l'entrée vaut $(\hat{p}-y)\mathbf{w}$. Pour un exemple de classe $y=1$, $\hat{p}-y<0$, et (11.16) donne : exactement la perturbation qui fait baisser le score au maximum.

C'est l'explication «linéaire» de Goodfellow, Shlens et Szegedy: pour une perturbation de taille $\epsilon$ par coordonnée, l'effet sur un score linéaire croît comme $\epsilon \Vert \mathbf{w}{\Vert }_1$, donc typiquement proportionnellement à la dimension, alors que la perturbation reste imperceptible coordonnée par coordonnée. Les réseaux profonds, construits de couches affines et de ReLU linéaires par morceaux, se comportent souvent de façon assez linéaire au voisinage d'un exemple pour que la même attaque fonctionne. Un exemple adverse ne prouve donc pas qu'un réseau est «bête»; il montre qu'il s'appuie sur une accumulation de petits indices dont aucun, isolément, ne compterait pour un humain, et que sa frontière de décision passe très près de presque tous les exemples dans certaines directions.

Ce constat a des conséquences pratiques. Un système de vision dont une décision a des conséquences — conduite automatisée, contrôle d'accès, filtrage de contenus — peut être attaqué par quelqu'un qui connaît ou devine son gradient; et des perturbations construites pour un réseau trompent souvent aussi d'autres réseaux entraînés sur les mêmes données. Le remède le plus étudié est l'entraînement adverse (adversarial training): on ajoute à chaque mini-lot des exemples adverses construits contre le réseau courant, avec leur vraie étiquette. Il améliore la robustesse contre les attaques de la taille prévue, généralement au prix d'une erreur un peu plus élevée sur les exemples non perturbés, et sans garantie contre des attaques d'une autre forme. La robustesse d'un modèle, comme son absence de biais (chapitre 1), ne se lit pas dans son erreur de test: une erreur de test mesure la performance moyenne sur des données tirées de la même loi, pas le pire cas face à un adversaire.

Synthèse

• Les réseaux convolutifs inscrivent dans leur architecture deux hypothèses sur les images, la localité et l'invariance des motifs par translation. Une couche convolutive est une couche dense contrainte: chaque sortie ne voit qu'une fenêtre $k\times k$, et les mêmes poids servent partout. Elle a $C_{\text{out}}(k^2{C}_{\text{in}}+1)$ paramètres quelle que soit la taille de l'image, et sa sortie a pour côté .

Exercices

Vous pouvez afficher le corrigé directement sous chaque énoncé après avoir cherché la solution.

Références

• Goodfellow, I., Bengio, Y. et Courville, A., Deep Learning, MIT Press, 2016, chap. 7 (régularisation, abandon, augmentation de données), 8 (optimisation, moment, Adam, normalisation par lots) et 9 (réseaux convolutifs).
• LeCun, Y., Bottou, L., Bengio, Y. et Haffner, P., «Gradient-Based Learning Applied to Document Recognition», Proceedings of the IEEE, 1998 (réseaux convolutifs, LeNet-5).
• Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I. et Salakhutdinov, R., «Dropout: A Simple Way to Prevent Neural Networks from Overfitting», Journal of Machine Learning Research, 2014.
• Kingma, D. P. et Ba, J., «Adam: A Method for Stochastic Optimization», International Conference on Learning Representations, 2015.
• Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł. et Polosukhin, I., «Attention Is All You Need», Advances in Neural Information Processing Systems, 2017.
• Goodfellow, I. J., Shlens, J. et Szegedy, C., «Explaining and Harnessing Adversarial Examples», International Conference on Learning Representations, 2015.