Les réseaux convolutifs pour la vision

Donnez une photographie à la couche dense de Qu’est-ce qu’un réseau de neurones ? et quelque chose déraille immédiatement : une modeste image couleur de $224 \times 224$ contient 150 528 nombres, et relier chacun d’eux à chaque unité d’une couche de 1 000 unités demande plus de 150 millions de poids - pour une seule couche. Pire, le modèle devrait apprendre à quoi ressemble un contour séparément pour chaque position de l’image, car rien ne lie le poids d’un pixel à celui de son voisin.

La convolution règle les deux problèmes par une seule idée : faire glisser un petit jeu de poids sur toute l’image. Cet article définit précisément l’opération, déroule un détecteur de contours à la main, puis couvre le basculement qui l’a rendue centrale en vision - les noyaux ont cessé d’être conçus par des humains pour être appris.

A. Les images, et ce que « bas niveau » veut dire en vision

Une image est un tableau d’intensités. Russell et Norvig caractérisent les premières opérations d’une chaîne de vision par deux propriétés : elles sont locales, c’est-à-dire réalisables dans une partie de l’image sans considérer quoi que ce soit au-delà de quelques pixels, et elles sont sans connaissance, c’est-à-dire exécutées sans aucune considération des objets qui pourraient être dans la scène. Ils notent que cela en fait de bonnes candidates pour du matériel parallèle - un GPU, ou un œil.

La localité est la propriété que la convolution est faite pour exploiter. Un détecteur de contour vertical a besoin de voir une poignée de pixels voisins ; il n’a pas besoin des 150 000 autres.

B. La convolution, définie

Russell et Norvig en donnent directement la définition. La fonction $h$ est la convolution de $f$ et $g$, notée $f * g$, quand

$$h(x, y) = (f * g)(x, y) = \sum_{u=-\infty}^{+\infty} \sum_{v=-\infty}^{+\infty} f(u, v)\, g(x - u,\, y - v) .$$

En pratique $g$ - le noyau ou filtre - est nul hors d’une petite fenêtre, si bien que les sommes portent sur un carré $3\times3$ ou $5\times5$ plutôt que sur le plan entier. Chaque pixel de sortie est une somme pondérée d’un petit voisinage de pixels d’entrée, avec les mêmes poids à toutes les positions.

Une note d’honnêteté notationnelle. La définition ci-dessus comporte $g(x-u,\, y-v)$ : le noyau est retourné avant d’être appliqué. Les cadriciels d’apprentissage profond sautent le retournement et calculent $\sum_u \sum_v f(x+u,\,y+v)\,g(u,v)$ - strictement une corrélation croisée - tout en appelant la couche une convolution. Pour le noyau de Sobel ci-dessous, les deux diffèrent d’un signe : notre fenêtre donne $+320$ en corrélation croisée et $-320$ en convolution véritable. Cela ne change rien en pratique dans un réseau, parce que le noyau est appris : quelle que soit la convention du cadriciel, l’entraînement trouve simplement le noyau qui marche sous cette convention. Cela ne compte que lorsque vous comparez des formules entre un manuel et une bibliothèque.

C. Un détecteur de contours déroulé

Les contours, selon la définition de Russell et Norvig, sont des droites ou des courbes dans le plan image le long desquelles la luminosité change significativement. Les trouver relève d’une forme de compression : abstraire l’image brouillonne de plusieurs mégaoctets vers une représentation plus compacte. Ils prennent soin de distinguer quatre causes physiques qui produisent toutes le même type de contour dans l’image - discontinuités de profondeur, discontinuités d’orientation de surface, discontinuités de réflectance, et discontinuités d’éclairement telles que les ombres. La détection de contours travaille sur la seule image et ne peut pas les distinguer ; un traitement ultérieur le doit.

Prenons une image $5\times5$ avec un unique contour vertical - sombre à gauche, clair à droite :

$$I = \begin{bmatrix} 10 & 10 & 10 & 90 & 90\\ 10 & 10 & 10 & 90 & 90\\ 10 & 10 & 10 & 90 & 90\\ 10 & 10 & 10 & 90 & 90\\ 10 & 10 & 10 & 90 & 90 \end{bmatrix}, \qquad K = \begin{bmatrix} -1 & 0 & 1\\ -2 & 0 & 2\\ -1 & 0 & 1 \end{bmatrix} .$$

$K$ est le noyau Sobel horizontal : il soustrait ce qui est à gauche de ce qui est à droite, il répond donc aux contours verticaux et ignore les régions plates.

Une fenêtre plate. La fenêtre $3\times3$ en haut à gauche n’est faite que de $10$ :

$$(-1)(10) + (0)(10) + (1)(10) + (-2)(10) + (0)(10) + (2)(10) + (-1)(10) + (0)(10) + (1)(10) = 0 .$$

Les poids négatifs et positifs se compensent exactement. Un noyau dont les poids somment à zéro renvoie zéro sur toute fenêtre constante - il mesure une différence, pas une luminosité.

Une fenêtre à cheval sur le contour. La fenêtre commençant à la colonne 2 :

$$\begin{bmatrix}10 & 10 & 90\\ 10 & 10 & 90\\ 10 & 10 & 90\end{bmatrix} \;\longrightarrow\; (-1)(10) + (1)(90) + (-2)(10) + (2)(90) + (-1)(10) + (1)(90)$$ $$= -10 + 90 - 20 + 180 - 10 + 90 = 320 .$$

En glissant le noyau non retourné sur les neuf positions valides (corrélation croisée, notée $\star$, comme la calculent les cadriciels ; la convolution véritable $I * K$ change le signe de chaque entrée) :

$$I \star K = \begin{bmatrix} 0 & 320 & 320\\ 0 & 320 & 320\\ 0 & 320 & 320 \end{bmatrix} .$$

La sortie - une carte de caractéristiques - est une image de l’endroit où se trouve le contour. Les régions plates sont nulles ; les deux colonnes qui enjambent le saut d’intensité s’allument.

D. Lisser d’abord, et un théorème qui épargne une passe

Les images réelles sont bruitées, et la différenciation amplifie le bruit. Le remède standard est de lisser d’abord avec une gaussienne,

$$N_\sigma(x, y) = \frac{1}{2\pi\sigma^2}\,e^{-(x^2 + y^2)/2\sigma^2},$$

en convolant l’image avec elle, $I * N_\sigma$. Russell et Norvig notent qu’un $\sigma$ d’un pixel lisse une petite quantité de bruit tandis que deux pixels lissent davantage mais coûtent du détail, et que puisque l’influence de la gaussienne s’estompe vite, les sommes infinies peuvent être tronquées à $\pm 3\sigma$.

Il y a ici une jolie économie. C’est un théorème que pour tous $f$ et $g$,

$$(f * g)' = f * (g') ,$$

la dérivée d’une convolution égale la convolution avec la dérivée. Ainsi, au lieu de lisser l’image puis de la dériver, vous pouvez convoler l’image une fois avec la dérivée de la fonction de lissage, $N'_\sigma$, et marquer comme contours les pics de réponse qui dépassent un seuil. Deux passes deviennent une.

E. Pourquoi pas simplement une couche dense

Deux propriétés font de la convolution le bon outil, et toutes deux se comptent.

Le partage de paramètres. Un noyau $3\times3$ sur 3 canaux de couleur, c’est $3 \times 3 \times 3 = 27$ poids, et une couche de 64 tels filtres, $1{,}728$. La couche dense de l’ouverture - $224\times224\times3$ entrées vers 1 000 unités - compte $150{,}528{,}000$ poids. Soit un facteur d’environ 87 000. La couche dense doit en outre apprendre un détecteur de contours indépendamment à chaque emplacement ; la couche convolutive en apprend un et l’applique partout.

L’équivariance. Élargissez notre image à six colonnes, pour que le contour déplacé reste dans la région valide, et déplacez le contour d’une colonne vers la droite : la réponse se déplace avec lui, sans changer de valeur :

$$\text{edge at column 3:}\; \begin{bmatrix}0 & 320 & 320 & 0\end{bmatrix} \qquad \text{edge at column 4:}\; \begin{bmatrix}0 & 0 & 320 & 320\end{bmatrix}$$

(lignes omises ; toutes les lignes sont identiques). Le détecteur se moque de l’endroit où est le contour, ce qui est exactement juste - un contour est un contour où qu’il apparaisse.

Équivariance n’est pas invariance. La réponse s’est translatée avec l’entrée au lieu de rester fixe. La convolution donne l’équivariance par translation ; un classifieur devant produire la même étiquette quelle que soit la position a besoin de quelque chose de plus - typiquement des étapes de sous-échantillonnage ou de pooling qui écartent progressivement la résolution spatiale, de sorte qu’à la couche finale une entrée décalée donne la même réponse. Les deux termes sont couramment confondus, et ce ne sont pas la même propriété.

F. Quand les noyaux ont cessé d’être conçus

Tout ce qui précède utilise un noyau que quelqu’un a choisi. Les poids de Sobel sont l’encodage humain de « cherche un gradient horizontal de luminosité ». C’est ainsi que la vision a fonctionné pendant des décennies, et l’exemple d’époque de Chollet est exact : avant que les réseaux convolutifs ne réussissent la classification des chiffres MNIST, les solutions reposaient typiquement sur des caractéristiques codées en dur telles que le nombre de boucles dans l’image d’un chiffre, la hauteur du chiffre, ou un histogramme des valeurs de pixels.

Le changement est que les entrées du noyau sont devenues des poids, appris par la même descente de gradient qui entraîne toute autre couche. Le cadrage de l’apprentissage profond chez Chollet est qu’il automatise entièrement l’ingénierie des caractéristiques - on apprend toutes les caractéristiques en une passe au lieu de les concevoir soi-même, ce qui remplace souvent une chaîne multi-étapes sophistiquée par un unique modèle de bout en bout. Empilez de telles couches et vous obtenez ce que promettait la section A : des couches successives de représentations de plus en plus utiles, les premières répondant aux contours et les suivantes à leurs combinaisons.

Le verdict empirique fut décisif. Chollet consigne que depuis 2012 les convnets sont l’algorithme de référence pour pratiquement toutes les tâches de vision par ordinateur, qu’en 2015 l’exactitude top-5 gagnante sur ImageNet atteignait 96,4 % et que la tâche était considérée comme résolue, et qu’après 2015 il était presque impossible de trouver une présentation dans une grande conférence de vision qui ne les impliquait pas.

Appris ne veut pas dire sans contrainte. Une couche convolutive intègre toujours des hypothèses fortes - que les caractéristiques utiles sont locales, et qu’une caractéristique méritant d’être détectée quelque part mérite de l’être partout. Ces hypothèses sont ce qui la rend efficace, et aussi pourquoi elle est la mauvaise architecture quand elles ne tiennent pas. Chollet range le choix d’architecture parmi les a priori de modélisation dont vous êtes responsable, aux côtés de la fonction de perte et de la configuration d’entraînement.

À retenir

• La convolution est $\sum_u\sum_v f(u,v)\,g(x-u,\,y-v)$ - chaque pixel de sortie est une somme pondérée d’un petit voisinage, avec les mêmes poids partout.
• Les cadriciels calculent une corrélation croisée (sans retournement du noyau) et l’appellent convolution ; avec des noyaux appris cela ne change rien en pratique.
• Un noyau dont les poids somment à zéro mesure une différence, pas une luminosité : notre filtre de Sobel renvoie $0$ sur les fenêtres plates et $320$ en travers du contour (sans retournement ; $-320$ en convolution véritable).
• Lisser avant de différencier maîtrise le bruit, et $(f*g)' = f*(g')$ ramène les deux passes à une.
• La convolution bat une couche dense d’environ 87 000× en paramètres sur une image $224\times224$, et partage un détecteur entre toutes les positions.
• La convolution est équivariante par translation, non invariante - la réponse se déplace avec la caractéristique.
• Le changement décisif fut d’apprendre les noyaux plutôt que de les concevoir, remplaçant des caractéristiques codées en dur comme « le nombre de boucles dans un chiffre ».

La suite

Les images sont des grilles dotées d’une notion naturelle de localité. Le texte ne l’est pas - le contexte pertinent d’un mot peut siéger n’importe où dans la séquence, si bien qu’une fenêtre locale fixe est un a priori tout à fait erroné. Traiter cela demande un autre mécanisme, développé dans L’attention et l’auto-attention, et, avant lui, un moyen de transformer le texte en vecteurs : La tokenisation et les plongements.