Retour à la bibliothèque
arXiv 2023NeurIPS 2023ReparamétrisationNotes de lecture

VanillaNet

La simplicité saveur vanille

Article original

VanillaNet: the Power of Minimalism in Deep Learning

Auteurs de l’article

Hanting Chen · Yunhe Wang · Jianyuan Guo · Dacheng Tao

Publication
NeurIPS 2023Conférence
Premier dépôt sur arXiv
arXiv:2305.12972
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{reparameterizationvanillanet2023,
  title = {{VanillaNet: the Power of Minimalism in Deep Learning}},
  author = {Hanting Chen and Yunhe Wang and Jianyuan Guo and Dacheng Tao},
  year = {2023},
  eprint = {2305.12972},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2305.12972}
}
Sur cette page

Après dix ans de popularité des réseaux convolutionnels profonds, on peut encore tomber sur une œuvre d'un tel minimalisme.

Définir le problème

Ces dernières années, la recherche en vision par ordinateur a progressé à une vitesse folle. D'AlexNet jusqu'aux plus récentes architectures hybrides CNN-Transformer, il y a de quoi en perdre le fil.

Pour grimper dans le classement ImageNet, les chercheurs ont sans cesse complexifié les modèles, faisant exploser le coût de calcul et les besoins en ressources. Ces architectures compliquent aussi le déploiement : ResNet consomme, par exemple, beaucoup de mémoire supplémentaire pendant son exécution, tandis que les fenêtres décalées de Swin Transformer demandent un travail d'ingénierie complexe, jusqu'à la réécriture de code CUDA.

Pourquoi les CNN sans connexions résiduelles ont-ils perdu leur place ?

Je parle d'AlexNet et de VGG.

Tout le monde connaît la raison : les réseaux profonds souffrent de disparition des gradients et de dégradation. La structure résiduelle proposée à l'époque par ResNet a justement résolu ces problèmes. Sans connexions résiduelles, les architectures ne peuvent donc pas rivaliser en précision ; c'est une réalité difficile à éviter.

Les réseaux simples semblaient alors voués à une impasse, et presque plus personne ne s'y intéressait.

Avec le développement des puces IA, les GPU modernes parallélisent facilement les calculs. Le goulot d'étranglement de l'inférence n'est plus nécessairement le nombre de FLOPs ou de paramètres : la complexité et la profondeur des modèles peuvent au contraire ralentir leur exécution.

C'est alors qu'on s'aperçoit, stupéfait, que la limite finale était peut-être déjà inscrite dans les choix faits au départ.

Résoudre le problème

Architecture du modèle

Les auteurs proposent une architecture neuronale toute simple, VanillaNet, illustrée ci-dessus.

À la voir, on se croirait revenu dix ans en arrière :

  • AlexNet ! Qu'est-ce que tu fais ici ?

Contrairement aux réseaux profonds actuels, chaque étape de sous-échantillonnage ne comporte ici qu'« une seule couche ».

Dans le stem, une convolution de taille 4×4×3×C4 \times 4 \times 3 \times C et de stride 4 projette l'image dans un espace de caractéristiques de dimension CC.

Des étapes 1 à 3, un MaxPool de stride 2 réduit la taille des cartes de caractéristiques et double le nombre de canaux. À l'étape 4, celui-ci n'augmente plus.

Un pooling global moyen et une couche de classification produisent enfin la sortie. À part la convolution 4×44 \times 4 du stem, toutes les convolutions sont de taille 1×11 \times 1, ce qui réduit le calcul par couche. Elles sont suivies d'une fonction d'activation, et une BatchNorm stabilise l'entraînement.

Pas de connexion résiduelle, pas d'attention, encore moins de fenêtres décalées : seulement les convolutions et le pooling les plus élémentaires.

Ça ne peut pas marcher, si ?

Comment une architecture aussi dépouillée pourrait-elle donner de bons résultats ?

Les auteurs soulignent qu'il lui manque une propriété essentielle : des « couches non linéaires ».

Nous savons que la force des réseaux neuronaux réside dans leur non-linéarité, indispensable pour approcher des fonctions complexes. Comment en donner davantage à ce réseau ? Nous y reviendrons ; regardons d'abord un autre problème, la « profondeur ».

Stratégie d'entraînement profond

Dans un CNN, la combinaison des convolutions et des activations permet au réseau de capter les caractéristiques non linéaires des données.

Au début de l'entraînement, les auteurs remplacent une convolution par deux convolutions séparées par une activation. Le réseau possède ainsi, au départ, une forte capacité non linéaire pour mieux apprendre les caractéristiques. À mesure que l'entraînement avance, la non-linéarité de cette activation intermédiaire s'affaiblit jusqu'à devenir une fonction identité.

Cette évolution de l'activation s'exprime par :

A′(x)=(1−λ)A(x)+λx,A'(x) = (1 - \lambda)A(x) + \lambda x,

Ici, λ\lambda est un hyperparamètre qui varie au cours de l'entraînement. Au départ, λ=0\lambda = 0 et A′(x)=A(x)A'(x) = A(x) : l'activation agit à pleine intensité. Ensuite, λ\lambda augmente progressivement ; à la fin, λ=1\lambda = 1 et A′(x)=xA'(x) = x, si bien que l'activation devient l'identité.

Les deux convolutions peuvent alors être fusionnées en une seule, ce qui réduit le temps d'inférence et améliore l'efficacité du modèle. Cette fusion nous ramène à une reparamétrisation familière :

  • Fusion de BatchNorm :

    On fusionne d'abord chaque BatchNorm avec la convolution qui la précède.

    Soient W∈RCout×Cin×k×kW \in \mathbb{R}^{C_{out} \times C_{in} \times k \times k} et B∈RCoutB \in \mathbb{R}^{C_{out}} les matrices des poids et des biais de la convolution ; les paramètres d'échelle, de décalage, de moyenne et d'écart-type de la BN sont γ,β,μ,σ∈RCout\gamma, \beta, \mu, \sigma \in \mathbb{R}^{C_{out}}. Ici, σ\sigma inclut le terme ϵ\epsilon de la BN.

    Les nouveaux poids et biais sont :

    Wi′=γiσiWi,Bi′=(Bi−μi)γiσi+βi,W'_i = \frac{\gamma_i}{\sigma_i} W_i, \quad B'_i = \frac{(B_i - \mu_i) \gamma_i}{\sigma_i} + \beta_i,

    L'indice ii représente le ii-ième canal de sortie.

  • Fusion de deux convolutions 1×11 \times 1 :

    Après les BN, nous fusionnons les deux convolutions 1×11 \times 1.

    Soient x∈RCin×H×Wx \in \mathbb{R}^{C_{in} \times H \times W} et y∈RCout×H′×W′y \in \mathbb{R}^{C_{out} \times H' \times W'} les caractéristiques d'entrée et de sortie. La convolution peut s'écrire :

    y=W∗x=W⋅im2col(x)=W⋅X,y = W * x = W \cdot \text{im2col}(x) = W \cdot X,

    Ici, ∗* est la convolution, ⋅\cdot la multiplication matricielle, et XX la matrice produite par im2col à partir de l'entrée. Pour une convolution 1×11 \times 1, im2col devient un simple remodelage ; on peut donc combiner les matrices des poids W1W_1 et W2W_2 :

    y=W1∗(W2∗x)=W1⋅W2⋅im2col(x)=(W1⋅W2)⋅X,y = W_1 * (W_2 * x) = W_1 \cdot W_2 \cdot \text{im2col}(x) = (W_1 \cdot W_2) \cdot X,

    Si les deux couches ont des biais, le biais fusionné doit aussi inclure W1B2+B1W_1 B_2+B_1. Les deux convolutions 1×11 \times 1 deviennent donc une seule couche, réduisant le nombre de couches à l'inférence.

Cette stratégie d'entraînement profond présente plusieurs avantages :

  1. Renforcer la non-linéarité du modèle : une forte activation non linéaire au début de l'entraînement l'aide à saisir des motifs complexes et améliore ses performances.
  2. Passer progressivement à un modèle simplifié : l'activation devient peu à peu l'identité et l'architecture finale, plus simple, accélère l'inférence.
  3. Faciliter la fusion des couches : les deux convolutions se combinent aisément à la fin de l'entraînement, réduisant le calcul et améliorant l'efficacité.

Activation informée par une série (Series Informed)

Selon les résultats théoriques existants, les capacités limitées des réseaux simples et peu profonds viendraient surtout d'une « non-linéarité insuffisante ». Ce point les distingue des réseaux profonds et complexes et a encore été peu étudié.

Il existe en effet deux manières d'augmenter la non-linéarité d'un réseau :

  1. Empiler les couches d'activation non linéaire ;
  2. Augmenter la non-linéarité de chaque couche d'activation.

La plupart des réseaux actuels choisissent la première voie, mais celle-ci produit une forte latence lorsque la capacité de calcul parallèle est abondante.


L'idée directe pour accroître la non-linéarité des activations est de les empiler. Cet empilement « en série » est au cœur des réseaux profonds.

Dans cet article, les auteurs choisissent plutôt de les empiler « en parallèle ».

Soit A(x)A(x) une activation appliquée à une entrée xx du réseau, par exemple une ReLU ou une Tanh.

L'empilement parallèle s'écrit :

As(x)=∑i=1naiA(x+bi)A_s(x) = \sum_{i=1}^{n} a_i A(x + b_i)

nn est le nombre d'activations empilées ; aia_i et bib_i sont leurs facteurs d'échelle et de décalage. Cet empilement peut accroître fortement la non-linéarité. Mathématiquement, la formule est une série, c'est-à-dire une somme de plusieurs termes.

Pour améliorer sa capacité d'approximation, les auteurs permettent aussi à la « fonction construite en série d'apprendre une information globale en faisant varier les entrées de son voisinage », dans l'esprit de BNET.

Pour une entrée x∈RH×W×Cx \in \mathbb{R}^{H \times W \times C}, où HH, WW et CC désignent hauteur, largeur et nombre de canaux, l'activation s'écrit :

As(xh,w,c)=∑i=−nn∑j=−nnai,j,cA(xi+h,j+w,c+bc)A_s(x_{h,w,c}) = \sum_{i=-n}^{n}\sum_{j=-n}^{n} a_{i,j,c} A(x_{i+h,j+w,c} + b_c)

avec h∈{1,2,...,H}h \in \{1, 2, ..., H\}, w∈{1,2,...,W}w \in \{1, 2, ..., W\} et c∈{1,2,...,C}c \in \{1, 2, ..., C\}.

Pour n=0n = 0, aucun voisinage n'est mélangé ; la formule ne retrouve l'activation ordinaire A(x)A(x) que si a0,0,c=1a_{0,0,c}=1 et bc=0b_c=0. Ici, nn est un rayon spatial, différent du nombre de termes de la formule précédente. Les auteurs prennent ReLU comme activation de base.

Discussion

Nous disions que la capacité des réseaux peu profonds était limitée surtout par leur « non-linéarité insuffisante ». L'activation empilée en parallèle peut-elle améliorer les performances ?

Ablation : fonction d'activation

Le tableau ci-dessus compare VanillaNet selon différentes valeurs de n.

Avec n=0n=0, sans agrégation du voisinage, le modèle atteint 60,53 % de top-1 dans cette expérience ImageNet ; l'article considère ce réglage comme une référence ReLU ordinaire.

À n = 1, la précision grimpe à 74,53 % : le progrès est énorme. À n = 3, précision et vitesse d'inférence offrent le meilleur compromis.

Ablation : entraînement profond

VanillaNet étant très peu profond, les auteurs proposent d'accroître sa non-linéarité pendant l'entraînement pour améliorer ses résultats.

Le tableau montre l'effet de cette méthode : VanillaNet-6 avec l'activation par séries mais sans entraînement profond atteint 75,23 % de top-1 ; avec cet entraînement, 76,36 %. Dans ce cas, la méthode aide donc le réseau peu profond.

Les auteurs appliquent également les deux techniques à d'autres réseaux pour tester leur portée.

Le tableau donne les résultats sur ImageNet d'AlexNet et de ResNet-50. AlexNet original, avec ses 12 couches, n'atteint que 57,52 % de précision.

Avec entraînement profond et activation par séries, il atteint 63,59 %, soit 6,07 points de pourcentage de plus : les deux techniques sont utiles à ce réseau peu profond.

Pour ResNet-50, plus complexe, les deux techniques font passer la précision de 76,13 % à 76,27 %, un résultat même inférieur aux 76,30 % obtenus avec la seule activation par séries. Les auteurs en déduisent que les réseaux profonds disposent peut-être déjà d'une non-linéarité suffisante.

Ablation : connexions résiduelles

Et les connexions résiduelles, si courantes dans les réseaux actuels, qu'apportent-elles ici ?

Dans cette ablation sur VanillaNet-6, les raccourcis placés avant ou après l'activation donnent tous deux un top-1 inférieur aux 76,36 % obtenus sans raccourci.

Selon les auteurs, le problème pourrait être ici une « faible non-linéarité » : en évitant certaines activations, les raccourcis ne la renforcent pas. C'est une interprétation de ces résultats.

Performances sur ImageNet

Les auteurs réalisent des expériences sur ImageNet pour montrer l'efficacité de leur méthode.

La comparaison emploie des images RGB de 224 × 224 pixels. ImageNet-1K contient 1,28 million d'images d'entraînement et 50 000 images de validation, réparties en 1000 classes. Les auteurs utilisent une forte régularisation : chaque couche de VanillaNet possède beaucoup de paramètres qui peuvent extraire de l'information utile à partir d'images dont la non-linéarité est limitée.

La latence est mesurée sur un GPU Nvidia A100. Les auteurs proposent des VanillaNet de profondeurs différentes et les testent avec une taille de lot de 1, ce qui signifie que la puce IA dispose d'une capacité de calcul suffisante pour traiter chaque réseau.

Dans ces conditions, la vitesse d'inférence dépend peu du nombre de FLOPs ou de paramètres. Ainsi, MobileNetV3-Large n'effectue que 0,22 B FLOPs, mais sa latence GPU atteint 7,83 ms, plus que celle de VanillaNet-13 avec ses 11,9 B FLOPs.

Les résultats suggèrent plutôt un lien fort entre vitesse, complexité et profondeur du réseau dans ce réglage. ShuffleNetV2x1.5 et ShuffleNetV2x2 ont ainsi des latences proches, 7,23 et 7,84 ms, malgré leurs différences de paramètres et de FLOPs, 0,3 B contre 0,6 B, parce qu'ils ne diffèrent que par le nombre de canaux.

Dans le tableau, les modèles aux structures plus directes, comme VGGNet et VanillaNet, ont une faible latence. Même ResNet, malgré ses branches résiduelles, est plus rapide que bien des modèles complexes dans certaines configurations. Ce sont les résultats de cette comparaison sur A100 avec des lots de 1.

Conclusion

Grâce à son architecture minimaliste, VanillaNet surpasse des réseaux contemporains en efficacité et en précision, soulignant le potentiel des approches épurées en deep learning.

Cette étude remet en question les idées reçues sur les modèles fondamentaux et trace une nouvelle voie pour des architectures de modèles soignées et efficaces.