Accueil › Glossaire › Residual Connection

Connexion Résiduelle (Residual Connection / Skip Connection)

Une connexion résiduelle (ou skip connection) est un raccourci qui permet à l’entrée d’une couche de contourner une ou plusieurs couches et d’être ajoutée directement à la sortie : y = F(x) + x. Au lieu d’apprendre la transformation complète de l’entrée vers la sortie, le réseau n’apprend que le résidu (la différence). Cette innovation a rendu possible l’entraînement de réseaux de 100, 152, voire 1000+ couches.

L’idée est d’une élégance remarquable. Si la transformation optimale est proche de l’identité (ne rien changer), le réseau n’a qu’à apprendre F(x) ≈ 0, ce qui est facile (mettre tous les poids à zéro). Sans connexion résiduelle, apprendre la fonction identité à travers plusieurs couches non linéaires est étonnamment difficile. C’est comme la différence entre réécrire une phrase entière et simplement corriger ce qui ne va pas : la correction est toujours plus simple que la réécriture complète.

Le problème que les connexions résiduelles résolvent

En 2015, les réseaux de neurones profonds démontraient déjà des résultats impressionnants en vision par ordinateur. AlexNet (2012) avait 8 couches, VGGNet (2014) en avait 19. La logique semblait simple : plus de couches = meilleure capacité d’apprentissage = meilleurs résultats.

Mais un phénomène contre-intuitif se produisait : un réseau de 56 couches avait une erreur d’entraînement supérieure à un réseau de 20 couches. Ce n’était pas de l’overfitting (l’erreur de test ET l’erreur d’entraînement étaient pires). C’est le problème de dégradation : au-delà d’une certaine profondeur, ajouter des couches dégrade les performances, même sur les données d’entraînement.

La raison est double. Premièrement, le vanishing gradient : les gradients s’atténuent en traversant chaque couche, et après 20-30 couches avec des fonctions d’activation saturantes, ils deviennent trop petits pour permettre l’apprentissage. Deuxièmement, même avec ReLU (qui atténue le vanishing gradient), les couches profondes ont du mal à apprendre la fonction identité quand c’est la transformation optimale. Le réseau ne peut pas facilement « ne rien faire » sur certaines couches.

La solution : apprendre le résidu

He et al. ont eu une intuition clé : si la transformation optimale H(x) est proche de l’identité, au lieu de forcer les couches à apprendre H(x) directement, on leur demande d’apprendre le résidu F(x) = H(x) – x. La sortie du bloc est alors :

y = F(x) + x

Le « + x » est la connexion résiduelle (skip connection). C’est une simple addition élément par élément entre l’entrée du bloc et la sortie des couches de transformation. Si la transformation optimale est l’identité, F(x) converge vers 0 et y = x. C’est trivial à apprendre. Si des ajustements sont nécessaires, F(x) apprend ces ajustements incrémentaux. Chaque bloc résiduel effectue un raffinement itératif de la représentation, un petit ajustement à la fois plutôt qu’une transformation complète.

Impact sur le flux de gradient

Le bénéfice mathématique est immédiat. La dérivée de y par rapport à x est :

∂y/∂x = ∂F(x)/∂x + 1

Le terme « + 1 » est crucial. Même si ∂F(x)/∂x est très petit (vanishing gradient dans les couches de transformation), le gradient total ne descend jamais en dessous de 1. Le gradient a un chemin direct, non atténué, de la sortie vers l’entrée via la connexion résiduelle. C’est un « highway de gradient » qui permet aux couches les plus profondes de recevoir des signaux d’apprentissage significatifs.

Comprendre visuellement la connexion résiduelle

Imaginez une chaîne de production où chaque poste (couche) modifie un produit. Sans connexion résiduelle, si le poste 15 fait une erreur, le produit est définitivement altéré et tous les postes suivants travaillent sur un produit corrompu. Avec une connexion résiduelle, chaque poste reçoit le produit original en plus de la version modifiée par le poste précédent. Il peut comparer les deux et ne garder que les modifications utiles. Si un poste n’apporte rien de valeur, le produit original traverse sans modification.

Techniquement, cela signifie que chaque bloc résiduel effectue un raffinement itératif. La recherche (Jastrzębski et al., 2018) a montré que les blocs résiduels fonctionnent exactement comme ça : chaque bloc améliore légèrement la représentation du bloc précédent. Un ResNet de 100 couches effectue 50 petits raffinements successifs plutôt qu’une seule grosse transformation. C’est plus robuste et plus facile à optimiser.

Une observation fascinante (Veit et al., 2016) est qu’un ResNet se comporte comme un ensemble de réseaux relativement peu profonds. Grâce aux skip connections, les données peuvent emprunter de nombreux chemins différents à travers le réseau (certains traversant toutes les couches, d’autres en sautant plusieurs). Le réseau fonctionne comme un ensemble implicite de sous-réseaux de différentes profondeurs. Cela explique pourquoi les ResNets sont remarquablement robustes : supprimer quelques couches au milieu du réseau ne dégrade que légèrement les performances, alors que dans un réseau classique cela serait catastrophique.

ResNet : l’architecture qui a tout changé

ResNet (Residual Network), publié par He, Zhang, Ren et Sun de Microsoft Research en 2015, a remporté ImageNet avec un réseau de 152 couches et un taux d’erreur top-5 de 3,57 %, surpassant les performances humaines estimées à environ 5 %. C’était une réduction drastique par rapport aux 6,7 % de GoogLeNet (22 couches) l’année précédente.

L’architecture utilise des blocs résiduels empilés. Un bloc basique contient deux couches convolutives 3×3 avec BatchNorm et ReLU, plus la skip connection. Un bloc bottleneck (utilisé dans ResNet-50/101/152) utilise trois couches : une convolution 1×1 pour la réduction de dimension, une convolution 3×3 pour le traitement, et une convolution 1×1 pour la restauration de dimension. Ce design bottleneck réduit le coût computationnel tout en maintenant la capacité du réseau.

ResNet a ensuite été entraîné avec 200 et même plus de 1000 couches, démontrant que les connexions résiduelles éliminent effectivement le plafond de profondeur. Les variantes incluent ResNeXt (convolutions groupées), Wide ResNet (plus de canaux, moins de couches), et Res2Net (connexions résiduelres multi-échelles au sein d’un même bloc).

Connexions résiduelles dans les transformers

Tous les transformers utilisent des connexions résiduelles. C’est un composant non négociable : les transformers profonds ne peuvent pas être entraînés sans elles. Chaque bloc transformer contient deux sous-couches (attention multi-tête et réseau feed-forward), et chacune est entourée d’une connexion résiduelle combinée avec la normalisation de couche.

Architecture Post-Norm (originale, 2017)

Dans le paper « Attention Is All You Need » :

output = LayerNorm(x + SubLayer(x))

La connexion résiduelle ajoute x à la sortie de la sous-couche, puis LayerNorm est appliquée au résultat.

Architecture Pre-Norm (GPT-2+, standard moderne)

Depuis GPT-2, la plupart des transformers utilisent Pre-Norm :

output = x + SubLayer(LayerNorm(x))

LayerNorm est appliquée avant la sous-couche, et la connexion résiduelle contourne la normalisation. Cela préserve un chemin résiduel « propre » (identité pure, sans normalisation) pour le gradient, ce qui améliore significativement la stabilité de l’entraînement pour les réseaux très profonds.

Connexions résiduelles dans les LLM

Les LLM modernes comme GPT-4, Claude, Gemini et LLaMA utilisent tous des connexions résiduelles dans chaque bloc transformer. Un modèle avec 96 couches transformer contient 192 connexions résiduelles (une par sous-couche d’attention et une par sous-couche feed-forward dans chaque bloc).

Le concept de « residual stream » est central pour comprendre comment fonctionnent les LLM. Les chercheurs en interprétabilité mécanistique voient le flux résiduel comme un espace vectoriel partagé dans lequel chaque couche lit, modifie, et réécrit des représentations. L’attention lit des informations contextuelles et les ajoute au flux. Le feed-forward transforme les représentations et ajoute ses modifications. Chaque couche fait un petit ajustement incrémental, pas une transformation radicale.

La technique de Stochastic Depth (ou DropPath), qui supprime aléatoirement des blocs résiduels pendant l’entraînement en laissant passer uniquement la skip connection, est utilisée comme technique de régularisation dans les vision transformers (ViT) et certains LLM. Elle démontre que le réseau peut fonctionner même quand certaines couches sont « éteintes », ce qui renforce l’idée que chaque couche effectue un raffinement incrémental plutôt qu’une transformation indispensable.

Les connexions résiduelles sont partout

L’impact des connexions résiduelles dépasse largement la vision par ordinateur. Elles sont devenues un composant architectural universel du deep learning.

AlphaGo Zero et AlphaZero (DeepMind) : le réseau de neurones qui a battu les champions du monde de Go utilise 40 blocs résiduels. AlphaFold (DeepMind) : le système de prédiction de structure des protéines, considéré comme l’une des plus grandes avancées scientifiques récentes, utilise des connexions résiduelles dans son architecture Evoformer. AlphaStar (DeepMind) : le système qui a atteint le niveau Grandmaster à StarCraft II utilise des connexions résiduelles. Diffusion models (Stable Diffusion, DALL-E) : les modèles de génération d’images utilisent des architectures U-Net avec des skip connections. Les GANs : de nombreuses architectures de réseaux adversariaux (StyleGAN, BigGAN) intègrent des connexions résiduelles pour stabiliser l’entraînement.

En résumé, si un réseau de neurones a plus de 10 couches, il utilise presque certainement des connexions résiduelles sous une forme ou une autre. C’est l’innovation architecturale la plus universellement adoptée du deep learning moderne.

Implémentation en Python

import torch
import torch.nn as nn

# Bloc résiduel simple
class ResidualBlock(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(d_model, d_model),
            nn.ReLU(),
            nn.Linear(d_model, d_model)
        )

    def forward(self, x):
        return x + self.layers(x)  # Skip connection : y = F(x) + x

# Bloc transformer avec Pre-Norm et connexions résiduelles
class TransformerBlock(nn.Module):
    def __init__(self, d_model=512, n_heads=8):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_model * 4),
            nn.GELU(),
            nn.Linear(d_model * 4, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

    def forward(self, x):
        # Connexion résiduelle #1 (attention)
        normed = self.norm1(x)
        attn_out, _ = self.attn(normed, normed, normed)
        x = x + attn_out  # ← Skip connection

        # Connexion résiduelle #2 (feed-forward)
        normed = self.norm2(x)
        ffn_out = self.ffn(normed)
        x = x + ffn_out   # ← Skip connection
        return x

Au-delà de ResNet : autres formes de skip connections

DenseNet (2016) : au lieu d’additionner l’entrée à la sortie (comme ResNet), DenseNet concatène l’entrée de chaque couche avec les sorties de toutes les couches précédentes. Chaque couche reçoit les features maps de toutes les couches antérieures. Cela favorise la réutilisation des features et réduit le nombre de paramètres nécessaires.

U-Net : utilisé pour la segmentation d’images (notamment en imagerie médicale), U-Net utilise des skip connections longues qui connectent l’encodeur (chemin contractant) au décodeur (chemin expansif). Ces connexions permettent au décodeur de récupérer les détails spatiaux fins perdus lors du sous-échantillonnage dans l’encodeur.

Highway Networks (2015) : un précurseur de ResNet qui utilise des mécanismes de porte (gate) appris pour contrôler le flux d’information. ResNet est équivalent à un Highway Network avec toutes les portes ouvertes. En pratique, ResNet a supplanté les Highway Networks car la skip connection non-gatée est plus simple et fonctionne tout aussi bien.

Bonnes pratiques en production

Utilisez toujours des connexions résiduelles dans les réseaux de plus de 10 couches. Il n’y a aucune raison de s’en priver : le coût computationnel est quasi nul (une addition) et le bénéfice en termes de stabilité d’entraînement est massif. Pour les transformers, adoptez l’architecture Pre-Norm (normalisation avant la sous-couche, connexion résiduelle après) qui est le standard depuis GPT-2 et offre une stabilité supérieure.

Attention à la compatibilité des dimensions. La skip connection additionne l’entrée et la sortie élément par élément, ce qui exige que les deux aient la même dimension. Si les dimensions changent (par exemple, passage de 256 à 512 canaux dans un CNN), vous devez ajouter une projection linéaire (convolution 1×1) sur le chemin résiduel pour adapter les dimensions. Cette projection ajoute des paramètres mais reste légère.

L’initialisation des poids est importante. Avec des connexions résiduelles, l’initialisation de He/Kaiming (conçue pour ReLU) est recommandée pour les couches de transformation. Certaines architectures récentes initialisent les poids de la dernière couche de chaque bloc résiduel à zéro, de sorte que le bloc commence par une identité pure (F(x) = 0, donc y = x) et apprend progressivement à s’en écarter. Cette technique améliore la stabilité des premiers pas d’entraînement.

La technique de Stochastic Depth (DropPath) est une forme de régularisation spécifique aux architectures résiduelles. Pendant l’entraînement, certains blocs résiduels sont aléatoirement désactivés (seule la skip connection transmet le signal). Cela force le réseau à ne pas dépendre d’un bloc spécifique et améliore la généralisation. Cette technique est largement utilisée dans les Vision Transformers (ViT) et peut réduire le temps d’entraînement tout en améliorant les performances finales.

Pour le debugging, surveillez les normes des sorties de chaque bloc résiduel. Si la norme augmente de manière exponentielle à travers les couches, vous avez un problème d’exploding gradient. Si elle diminue régulièrement, les blocs de transformation n’apprennent pas efficacement. La normalisation de couche combinée aux connexions résiduelles maintient typiquement des normes stables à travers toutes les couches.

Questions fréquentes sur les connexions résiduelles

Qu’est-ce qu’une connexion résiduelle simplement ?

C’est un raccourci qui ajoute directement l’entrée d’un bloc de couches à sa sortie : y = F(x) + x. Au lieu d’apprendre la transformation complète, le réseau apprend seulement le « résidu » (la correction à apporter). C’est comme corriger un texte plutôt que le réécrire de zéro. Cette technique permet d’entraîner des réseaux très profonds (100+ couches) sans que les gradients ne s’évanouissent.

Pourquoi les connexions résiduelles sont-elles nécessaires dans les transformers ?

Les transformers profonds (12, 24, 96+ couches) ne peuvent pas être entraînés sans connexions résiduelles. Elles maintiennent un flux de gradient direct à travers toutes les couches (le terme « +1 » dans la dérivée empêche le gradient de s’évanouir) et permettent à chaque couche de faire un raffinement incrémental plutôt qu’une transformation complète. Le « residual stream » est le canal de communication central du transformer.

Quelle est la différence entre ResNet et un réseau classique ?

Dans un réseau classique, chaque couche doit apprendre la transformation complète F(x). Dans ResNet, chaque bloc apprend seulement le résidu F(x) et l’ajoute à l’entrée : y = F(x) + x. Si la transformation optimale est proche de l’identité, le résidu est proche de zéro, ce qui est facile à apprendre. C’est ce qui a permis à ResNet d’entraîner des réseaux de 152 couches là où les réseaux classiques plafonnaient à 20-30 couches.

Les connexions résiduelles ajoutent-elles des paramètres ?

Non. La skip connection par identité (y = F(x) + x) est une simple addition, sans aucun paramètre supplémentaire. C’est l’une des raisons de son succès : un gain massif en capacité d’entraînement pour un coût computationnel quasi nul. Quand les dimensions d’entrée et de sortie diffèrent, une projection linéaire (convolution 1×1 dans les CNN) est ajoutée, mais cela reste minimal.

Quelle est la différence entre Pre-Norm et Post-Norm pour les connexions résiduelles ?

Post-Norm (original, 2017) : y = LayerNorm(x + SubLayer(x)). La normalisation s’applique après l’addition résiduelle. Pre-Norm (GPT-2+, standard) : y = x + SubLayer(LayerNorm(x)). La normalisation s’applique avant la sous-couche, préservant un chemin résiduel pur. Pre-Norm est nettement plus stable pour les réseaux profonds et est le standard de l’industrie pour les LLM.