Accueil › Glossaire › ResNet

ResNet (Residual Network)

ResNet (Residual Network) est une architecture de réseau de neurones convolutif introduite par Kaiming He et son équipe (Microsoft Research) en 2015. Son innovation fondamentale : les connexions résiduelles (skip connections) qui permettent au gradient de contourner des couches, rendant possible l’entraînement de réseaux de 50, 101, voire 152+ couches là où les réseaux précédents plafonnaient à 20-30 couches.

Le problème de la dégradation

Avant ResNet, la logique semblait simple : plus un réseau est profond, plus il peut apprendre de features complexes. En pratique, l’inverse se produisait. Des réseaux de 56 couches avaient une erreur d’entraînement (pas seulement de test) plus élevée que des réseaux de 20 couches. Ce n’était pas un problème de surapprentissage : le réseau profond était strictement moins bon même sur les données d’entraînement.

Ce phénomène, appelé problème de dégradation, est distinct du vanishing gradient (qui empêche la convergence). La dégradation signifie que le réseau converge, mais vers une solution sous-optimale. L’optimiseur ne parvient pas à trouver les bons poids dans un espace devenu trop complexe.

L’observation clé de He et al. : si un réseau de 56 couches ne peut pas au minimum reproduire les performances d’un réseau de 20 couches (en laissant les 36 couches supplémentaires apprendre la fonction identité), c’est que les couches non linéaires ont du mal à apprendre la transformation identité y = x. C’est paradoxal mais vrai : un empilement de convolutions + ReLU + BatchNorm a énormément de difficulté à apprendre « ne rien faire ».

La solution : les connexions résiduelles

Au lieu de demander à un bloc de couches d’apprendre directement la transformation souhaitée H(x), ResNet reformule le problème : le bloc apprend la fonction résiduelle F(x) = H(x) – x. La sortie du bloc est alors :

y = F(x) + x

Le terme + x est la skip connection (ou shortcut connection) : l’entrée du bloc est ajoutée directement à sa sortie, en contournant les couches internes.

Si la transformation optimale est proche de l’identité, le réseau n’a qu’à apprendre F(x) ≈ 0 (mettre les poids à zéro), ce qui est trivial. C’est beaucoup plus facile que d’apprendre la fonction identité complète à travers des couches non linéaires.

Flux du gradient

L’addition dans y = F(x) + x crée un chemin direct pour le gradient. Lors de la rétropropagation, le gradient se propage à travers deux chemins : le chemin principal (à travers les couches) ET le raccourci (la skip connection). Même si le gradient s’atténue dans le chemin principal, il passe intact par le raccourci.

C’est cette propriété qui permet d’entraîner des réseaux de centaines de couches : le gradient peut toujours atteindre les couches basses via les skip connections, même si le chemin principal a des gradients faibles.

Les blocs résiduels

Basic Block (ResNet-18, ResNet-34)

Le bloc le plus simple : deux couches de convolution 3×3 empilées, chacune suivie de Batch Normalization et ReLU. La skip connection ajoute l’entrée directement à la sortie du bloc.

# Basic Block (simplifié)
# Entrée: x
# Conv 3x3 -> BN -> ReLU -> Conv 3x3 -> BN
# Sortie: F(x) + x -> ReLU

Ce bloc est utilisé dans ResNet-18 (8 basic blocks) et ResNet-34 (16 basic blocks). Suffisant pour les tâches de taille modérée.

Bottleneck Block (ResNet-50, 101, 152)

Pour les réseaux très profonds, le basic block devient trop coûteux en calcul. Le bottleneck block résout ce problème avec trois couches :

1. Convolution 1×1 : réduit le nombre de canaux (ex. 256 → 64). C’est le « goulot d’étranglement » (bottleneck).
2. Convolution 3×3 : effectue le travail principal sur les canaux réduits.
3. Convolution 1×1 : restaure le nombre de canaux (ex. 64 → 256).

# Bottleneck Block (simplifié)
# Entrée: x (256 canaux)
# Conv 1x1 (256 -> 64) -> BN -> ReLU
# Conv 3x3 (64 -> 64)  -> BN -> ReLU
# Conv 1x1 (64 -> 256)  -> BN
# Sortie: F(x) + x -> ReLU

Le bottleneck traite l’information dans un espace réduit (64 canaux au lieu de 256), ce qui divise le nombre de paramètres et de FLOPs tout en maintenant la capacité du réseau. ResNet-50 utilise 16 bottleneck blocks et atteint de meilleures performances que ResNet-34 (16 basic blocks) avec un coût computationnel comparable.

Projection shortcut

Quand les dimensions spatiales ou le nombre de canaux changent entre l’entrée et la sortie d’un bloc (par exemple lors d’un downsampling), une simple addition n’est plus possible. ResNet utilise alors une projection shortcut : une convolution 1×1 avec le stride approprié pour adapter les dimensions de l’entrée avant l’addition.

Les variantes de ResNet

La famille ResNet : choisir la bonne taille

Implémentation avec PyTorch

Utilisation d’un ResNet pré-entraîné (transfer learning)

import torch
import torch.nn as nn
import torchvision.models as models

# Charger ResNet-50 pré-entraîné sur ImageNet
model = models.resnet50(weights='IMAGENET1K_V2')

# Remplacer la dernière couche pour votre tâche
num_classes = 10  # ex: 10 types de défauts industriels
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Option 1 : Fine-tuning complet
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

# Option 2 : Feature extraction (geler le backbone)
for param in model.parameters():
    param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

print(f"Paramètres totaux : {sum(p.numel() for p in model.parameters()):,}")
print(f"Paramètres entraînables : {sum(p.numel() for p in model.parameters() if p.requires_grad):,}")

Bloc résiduel custom

class BasicBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        
        # Projection shortcut si les dimensions changent
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, 
                         stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        identity = self.shortcut(x)   # Skip connection
        
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        
        out += identity               # Addition résiduelle
        out = self.relu(out)
        return out

L’influence de ResNet au-delà de la vision

La connexion résiduelle n’est pas restée confinée aux CNN. Elle est devenue un composant fondamental de quasiment toute architecture de deep learning moderne :

Transformers : chaque bloc Transformer (GPT, BERT, ViT) contient une connexion résiduelle. Sans elle, les Transformers de 100+ couches ne convergeraient pas. La variante pre-normalization (LayerNorm avant le bloc, comme dans GPT-2+) est directement inspirée de ResNet-v2.

AlphaFold : l’architecture de prédiction de structure protéique de DeepMind utilise massivement les connexions résiduelles dans son module Evoformer.

Modèles de diffusion : les U-Nets utilisés dans Stable Diffusion, DALL-E et Midjourney emploient des blocs résiduels dans chaque étage du réseau.

Highway Networks : une architecture parallèle (Srivastava, Greff, Schmidhuber, 2015) utilise des skip connections avec des portes apprenables. ResNet peut être vu comme un Highway Network avec des portes fixées à 1 (identité pure).

Cas d’usage concrets

Classification d’images : la tâche originale de ResNet. Depuis sa victoire à ILSVRC 2015, ResNet est devenu la référence pour le benchmarking en classification. En transfer learning, un ResNet-50 pré-entraîné sur ImageNet produit des résultats compétitifs sur des datasets spécialisés (plantes, maladies, textures industrielles) avec seulement quelques centaines d’images par classe.

Détection d’objets : ResNet-50 avec FPN (Feature Pyramid Network) est le backbone standard de Faster R-CNN et Mask R-CNN. Les features multi-échelle extraites par les différents stages du ResNet alimentent le FPN, qui produit des représentations à plusieurs résolutions pour détecter aussi bien les petits que les grands objets.

Segmentation sémantique : les architectures comme DeepLab v3+ et PSPNet utilisent un ResNet comme encodeur. Les skip connections du ResNet aident à préserver les détails spatiaux perdus lors du downsampling, ce qui est crucial pour la segmentation pixel par pixel.

Imagerie médicale : classification de radiographies (pneumonie, COVID-19, fractures), analyse de coupes histologiques, détection de tumeurs. Le transfer learning depuis ImageNet fonctionne remarquablement bien même sur des images médicales très différentes des photos naturelles.

Véhicules autonomes : les systèmes de perception utilisent des backbones ResNet pour la détection de piétons, véhicules, panneaux et obstacles en temps réel.

Extraction de features : les couches intermédiaires d’un ResNet pré-entraîné produisent des embeddings visuels riches, utilisables pour la recherche d’images similaires, le clustering visuel ou comme entrée pour d’autres modèles.

Limites de ResNet

Rendements décroissants en profondeur : ajouter des couches au-delà de 100-150 apporte des gains marginaux. Wide ResNet a montré qu’élargir le réseau (plus de canaux par couche) est souvent plus efficace qu’augmenter la profondeur. Le mythe « plus profond = meilleur » est une simplification.

Coût computationnel de ResNet-50 : avec ~4.1 GFLOPs et ~25.6M de paramètres, ResNet-50 est nettement plus lourd que des architectures modernes comme EfficientNet-B0 (~0.4 GFLOPs, ~5.3M paramètres) pour des performances comparables. Si l’efficacité compte, ResNet n’est plus le choix optimal.

Design statique : les skip connections de ResNet sont fixes (identité ou projection 1×1). Elles ne s’adaptent pas au contenu de l’image. Les architectures avec attention (SE-ResNet, Vision Transformers) offrent une adaptabilité dynamique que ResNet standard ne possède pas.

Pas d’attention globale : ResNet ne capture que les dépendances locales (limitées par le champ récepteur des convolutions). Pour les tâches nécessitant une compréhension globale de l’image, les Vision Transformers sont supérieurs.

Bonnes pratiques

Utilisez ResNet-50 pré-entraîné comme point de départ. C’est le backbone le plus fiable et le mieux documenté. Le transfer learning depuis ImageNet fonctionne remarquablement bien même sur des domaines très différents (imagerie médicale, satellite, industriel).

Fine-tuning progressif. Commencez par entraîner uniquement la dernière couche (feature extraction), puis dégeler progressivement les couches du backbone avec un learning rate faible (1e-5 à 1e-4). Cette approche est plus stable que le fine-tuning complet dès le départ.

Utilisez les poids IMAGENET1K_V2 dans PyTorch. Ce sont des poids réentraînés avec des techniques modernes (data augmentation avancée, optimiseur amélioré) qui donnent de meilleures performances que les poids V1 originaux (+3-4% top-1 sur ImageNet).

Considérez EfficientNet ou ConvNeXt si vous avez besoin de meilleures performances. ResNet-50 est un excellent point de départ, mais ces architectures plus récentes offrent un meilleur rapport performance/coût. EfficientNet-B0 est comparable à ResNet-50 avec 5x moins de paramètres.

Pour la détection d’objets, utilisez un ResNet-50 avec FPN (Feature Pyramid Network). C’est le backbone standard de Faster R-CNN et Mask R-CNN, et l’écosystème (Detectron2, MMDetection) le supporte nativement.