ResNet : Guide Complet

Résumé

ResNet (Residual Network, ou réseau résiduel en français) est une architecture révolutionnaire présentée par Kaiming He et ses collaborateurs en 2015 dans leur article fondateur « Deep Residual Learning for Image Recognition ». Cette contribution a remporté la première place du défi ILSVRC 2015 avec une erreur de classification de seulement 3,57 %, surpassant pour la première fois la précision humaine sur ImageNet.

L’innovation centrale de ResNet réside dans les connexions résiduelles (ou skip connections), qui permettent d’entraîner des réseaux extrêmement profonds — jusqu’à 152 couches et bien au-delà — sans souffrir du fameux problème de dégradation (degradation problem) qui limitait jusque-là la profondeur des réseaux de neurones convolutifs.

Avant ResNet, les chercheurs constataient avec perplexité qu’augmenter la profondeur d’un réseau au-delà d’une certaine limite n’améliorait pas les performances, mais les détériorait. Ce phénomène, appelé problème de dégradation, n’était pas lié au surapprentissage (overfitting) puisque l’erreur augmentait également sur l’ensemble d’entraînement. ResNet a résolu ce paradoxe grâce à une idée mathématiquement élégante et remarquablement simple : au lieu de forcer chaque bloc à apprendre une transformation complète, on lui demande d’apprendre uniquement la différence (le résidu) par rapport à son entrée. Ce changement de perspective a ouvert la voie à des réseaux de plus de mille couches et a profondément transformé le domaine de la vision par ordinateur.

Principe Mathématique de ResNet

La formulation résiduelle : H(x) = F(x) + x

La contribution mathématique fondamentale de ResNet repose sur une reformulation de ce qu’un bloc de couches doit apprendre.

Dans un réseau de neurones conventionnel, un bloc de n couches apprend directement une transformation complexe H(x) à partir de l’entrée x. Le réseau doit modéliser l’intégralité de la fonction souhaitée :

sortie = H(x)

ResNet propose au contraire de décomposer cette transformation en deux parties :

H(x) = F(x) + x

où :

• x est l’entrée du bloc (transmise directement via une connexion résiduelle, appelée skip connection ou raccourci).
• F(x) est le résidu appris par les couches du bloc. C’est la différence entre la transformation souhaitée H(x) et l’identité x.
• H(x) est la sortie finale du bloc, obtenue en additionnant le résidu F(x) à l’entrée x.

Pourquoi cette reformulation est-elle si efficace ? Plusieurs raisons mathématiques profondes expliquent ce succès :

1. Initialisation vers l’identité. Si la transformation optimale est simplement l’identité (c’est-à-dire que le réseau n’a rien besoin de modifier à ce niveau), alors il suffit que F(x) → 0. Or il est beaucoup plus facile pour un réseau d’« éteindre » ses poids (les amener vers zéro) que de construire une transformation identité à partir de zéro. Les poids de convolution sont typiquement initialisés avec de petites valeurs aléatoires proches de zéro, ce qui signifie que F(x) est naturellement proche de zéro au démarrage de l’entraînement. Le réseau part donc déjà près de la solution identité.

2. Flux de gradient direct. Pendant la rétropropagation, le gradient qui arrive au bloc peut circuler directement à travers la connexion résiduelle, sans passer par les transformations non linéaires des couches internes. Mathématiquement, si la perte finale est ℒ, alors :

∂ℒ/∂x = ∂ℒ/∂H × ∂H/∂x = ∂ℒ/∂H × (∂F/∂x + I)

Le terme +I (matrice identité) garantit qu’une partie du gradient atteint directement les couches initiales, atténuant considérablement le problème du gradient qui s’évanouit (vanishing gradient problem). C’est comme si on construisait une autoroute pour le gradient, lui permettant de voyager de la fin du réseau jusqu’au début sans être dilué par des dizaines de multiplications successives.

3. Apprentissage incrémental progressif. Au lieu de devoir apprendre une fonction arbitrairement complexe dès le départ, le réseau peut commencer par apprendre des modifications subtiles (des résidus faibles) puis les affiner progressivement. Cette approche correspond à une forme intuitive d’apprentissage curriculaire : le réseau part d’une base raisonnable (l’identité, ou la transmission de l’entrée telle quelle) et y ajoute progressivement des transformations de plus en plus précises et significatives.

Les deux types de blocs résiduels

ResNet définit deux types de blocs selon la compatibilité des dimensions entre l’entrée et la sortie :

Bloc identité (identity block)

Ce bloc s’utilise lorsque les dimensions de l’entrée x et du résidu F(x) sont identiques. L’addition est alors directe et immédiate :

sortie = F(x) + x

Dans ce cas, la connexion résiduelle est une simple addition élément par élément. Aucune transformation n’est nécessaire car les tenseurs ont déjà la même forme (mêmes dimensions spatiales et même nombre de canaux).

Bloc projection (projection block)

Lorsque les dimensions ne correspondent pas — typiquement parce que le bloc modifie la taille spatiale de l’image (via un stride de 2 dans une convolution) ou change le nombre de filtres — il faut adapter les dimensions de x avant l’addition. On utilise alors une convolution 1×1 sur la connexion résiduelle :

sortie = F(x) + W_s · x

où W_s est une convolution 1×1 sans terme de biais (les convolutions de projection utilisent généralement use_bias=False car le biais serait redondant avec la normalisation par lots qui suit). Cette convolution adapte à la fois le nombre de canaux et la résolution spatiale si nécessaire.

Architectures profondes : ResNet-34 et ResNet-50+

ResNet propose plusieurs variantes qui diffèrent par leur nombre de couches et la structure de leurs blocs fondamentaux :

ResNet-34 (et versions plus légères) — Basic Block :
Les versions ResNet-18 et ResNet-34 utilisent un bloc fondamental simple composé de deux convolutions 3×3 consécutives, chacune suivie d’une normalisation par lots (batch normalization) et d’une activation ReLU. Ce bloc est efficace mais relativement coûteux pour des réseaux très profonds car chaque bloc contient deux convolutions 3×3 coûteuses.

ResNet-50, ResNet-101 et ResNet-152 — Bottleneck Block :
Pour les architectures plus profondes, ResNet utilise un bloc en goulot d’étranglement (bottleneck) plus sophistiqué, composé de trois convolutions :

1×1 (réduction) → 3×3 (traitement) → 1×1 (expansion)

Ce design est ingénieux et économiquement efficace :

1. La première convolution 1×1 réduit le nombre de canaux (par exemple de 256 à 64), diminuant considérablement le coût computationnel de la convolution centrale.
2. La deuxième convolution 3×3 travaille sur un espace de features réduit, ce qui est beaucoup moins coûteux en calculs.
3. La troisième convolution 1×1 restaure le nombre original de canaux (de 64 à 256).

Par exemple, dans le bloc bottleneck de ResNet-50, un bloc avec 64-64-256 canaux effectue environ 96% de calculs en moins qu’un bloc basic équivalent. Sans ce bottleneck, ResNet-152 serait pratiquement impossible à entraîner en temps raisonnable.

Voici la structure typique de ResNet-50 :
– Couche initiale : convolution 7×7 avec 64 filtres (stride=2) + max pooling 3×3
– 4 étapes (stages) de blocs bottleneck :
– Stage 1 : 3 blocs (64 → 64 → 256 canaux)
– Stage 2 : 4 blocs (128 → 128 → 512 canaux)
– Stage 3 : 6 blocs (256 → 256 → 1024 canaux)
– Stage 4 : 3 blocs (512 → 512 → 2048 canaux)
– Global Average Pooling + couche dense finale (softmax)

Intuition : L’Artiste et l’Esquisse

Pour comprendre profondément pourquoi ResNet fonctionne si bien, imaginons l’analogie suivante :

Pensez à un artiste qui réalise un portrait. Deux approches sont possibles :

Approche classique (réseau conventionnel) : L’artiste part d’une toile complètement blanche et doit peindre l’intégralité du portrait, trait par trait, couleur par couleur. Chaque couche du réseau est comme un artiste qui doit ajouter une contribution significative. Pour les premières couches, c’est facile : poser les contours généraux, définir la composition. Mais pour les couches profondes, la tâche devient extraordinairement difficile — il faut que chaque nouvelle couche modifie précisément l’image existante sans la détruire, comme un artiste qui peindrait par-dessus les couches précédentes tout en devant préserver ce qui a déjà été fait.

C’est exactement le problème des réseaux profonds conventionnels : chaque couche doit apprendre une transformation complète et significative. Quand le réseau est très profond, les couches les plus lointaines de l’entrée doivent gérer des représentations devenues extrêmement abstraites et complexes, ce qui est numériquement instable et difficile à optimiser.

Approche ResNet (réseau résiduel) : Maintenant, imaginez que l’artiste commence par une esquisse grossière mais raisonnable du visage. Son travail ne consiste plus à peindre le portrait entier, mais simplement à apporter des retouches à l’esquisse existante. Les premiers coups de pinceau corrigent la forme des yeux, les suivants ajustent l’ombre du nez, puis on affine la couleur des lèvres, et ainsi de suite.

C’est exactement ce que fait ResNet ! L’entrée x est l’esquisse, et F(x) sont les retouches. Si une couche profonde se rend compte qu’elle n’a rien de pertinent à ajouter — qu’elle ne peut pas améliorer la représentation — elle peut simplement apprendre F(x) ≈ 0 et laisser passer l’esquisse telle quelle. Aucune information n’est perdue, aucun dégât n’est fait.

Cette analogie explique pourquoi ResNet résout le problème de dégradation : même si certaines couches profondes ne contribuent pas significativement, les skip connections garantissent que l’information des couches précédentes n’est jamais détruite. Le réseau peut être aussi profond que nécessaire sans risque de « casser » les représentations utiles des premières couches.

De plus, les couches profondes peuvent passer l’information directement via les skip connections, comme si l’esquisse originale traversait toute la toile jusqu’au résultat final en ne subissant que des ajustements mineurs à chaque étape. Cette capacité de transmission directe est ce qui permet d’entraîner des réseaux de plus de cent couches sans que l’information ne se dégrade.

Implémentation Python avec Keras

Voici une implémentation complète de ResNet à partir de zéro, utilisant l’API fonctionnelle de Keras. Nous présenterons le bloc basic, le bloc bottleneck, puis un entraînement sur CIFAR-10.

Bloc résiduel de base (basic block)

import tensorflow as tf
from tensorflow.keras.layers import (
    Conv2D, BatchNormalization, Activation, Add,
    Input, GlobalAveragePooling2D, Dense, MaxPooling2D
)
from tensorflow.keras.models import Model
from tensorflow.keras.regularizers import l2

def basic_block(x, filters, stride=1, name_prefix=None):
    """
    Bloc résiduel basic : 2 convolutions 3x3.

    Utilisé dans ResNet-18 et ResNet-34.

    Arguments :
        x : tenseur d'entrée
        filters : nombre de filtres de sortie
        stride : pas de la première convolution (2 pour réduire la résolution)
        name_prefix : préfixe pour nommer les couches

    Retourne :
        Le tenseur de sortie du bloc
    """
    shortcut = x

    # --- Branche principale (F(x)) ---
    x = Conv2D(
        filters, kernel_size=3, strides=stride,
        padding="same", use_bias=False,
        kernel_regularizer=l2(1e-4),
        name=f"{name_prefix}_conv1"
    )(x)
    x = BatchNormalization(name=f"{name_prefix}_bn1")(x)
    x = Activation("relu", name=f"{name_prefix}_relu1")(x)

    x = Conv2D(
        filters, kernel_size=3, strides=1,
        padding="same", use_bias=False,
        kernel_regularizer=l2(1e-4),
        name=f"{name_prefix}_conv2"
    )(x)
    x = BatchNormalization(name=f"{name_prefix}_bn2")(x)

    # --- Connexion résiduelle (projection si nécessaire) ---
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = Conv2D(
            filters, kernel_size=1, strides=stride,
            padding="same", use_bias=False,
            kernel_regularizer=l2(1e-4),
            name=f"{name_prefix}_proj"
        )(shortcut)
        shortcut = BatchNormalization(name=f"{name_prefix}_proj_bn")(shortcut)

    # --- Addition et activation ---
    x = Add(name=f"{name_prefix}_add")([x, shortcut])
    x = Activation("relu", name=f"{name_prefix}_relu_final")(x)

    return x

Bloc bottleneck (bottleneck block)

def bottleneck_block(x, filters, stride=1, expand_ratio=4, name_prefix=None):
    """
    Bloc résiduel bottleneck : 1x1 (réduction) → 3x3 → 1x1 (expansion).

    Utilisé dans ResNet-50, ResNet-101 et ResNet-152.

    Arguments :
        x : tenseur d'entrée
        filters : nombre de filtres intermédiaires (bottleneck)
        stride : pas de la convolution 3x3
        expand_ratio : facteur d'expansion (par défaut 4)
        name_prefix : préfixe pour nommer les couches

    Retourne :
        Le tenseur de sortie du bloc
    """
    shortcut = x
    expanded_filters = filters * expand_ratio  # ex: 64 * 4 = 256

    # --- Branche principale (F(x)) ---
    # Étape 1 : réduction (1x1)
    x = Conv2D(
        filters, kernel_size=1, strides=1,
        padding="valid", use_bias=False,
        kernel_regularizer=l2(1e-4),
        name=f"{name_prefix}_conv1"
    )(x)
    x = BatchNormalization(name=f"{name_prefix}_bn1")(x)
    x = Activation("relu", name=f"{name_prefix}_relu1")(x)

    # Étape 2 : convolution principale 3x3
    x = Conv2D(
        filters, kernel_size=3, strides=stride,
        padding="same", use_bias=False,
        kernel_regularizer=l2(1e-4),
        name=f"{name_prefix}_conv2"
    )(x)
    x = BatchNormalization(name=f"{name_prefix}_bn2")(x)
    x = Activation("relu", name=f"{name_prefix}_relu2")(x)

    # Étape 3 : expansion (1x1)
    x = Conv2D(
        expanded_filters, kernel_size=1, strides=1,
        padding="valid", use_bias=False,
        kernel_regularizer=l2(1e-4),
        name=f"{name_prefix}_conv3"
    )(x)
    x = BatchNormalization(name=f"{name_prefix}_bn3")(x)

    # --- Connexion résiduelle ---
    if stride != 1 or shortcut.shape[-1] != expanded_filters:
        shortcut = Conv2D(
            expanded_filters, kernel_size=1, strides=stride,
            padding="same", use_bias=False,
            kernel_regularizer=l2(1e-4),
            name=f"{name_prefix}_proj"
        )(shortcut)
        shortcut = BatchNormalization(name=f"{name_prefix}_proj_bn")(shortcut)

    # --- Addition et activation finale ---
    x = Add(name=f"{name_prefix}_add")([x, shortcut])
    x = Activation("relu", name=f"{name_prefix}_relu_final")(x)

    return x

Construction du modèle ResNet-34 complet

def build_resnet34(input_shape=(32, 32, 3), num_classes=10):
    """
    Construit un modèle ResNet-34 avec l'API fonctionnelle de Keras.

    Architecture : 
    - Couche initiale + MaxPooling
    - Stage 1 : 3 blocs basic (filtres=64)
    - Stage 2 : 4 blocs basic (filtres=128)
    - Stage 3 : 6 blocs basic (filtres=256)
    - Stage 4 : 3 blocs basic (filtres=512)
    - GAP + Dense

    Retourne : modèle Keras compilé
    """
    inputs = Input(shape=input_shape)

    # Couche initiale (première conv)
    x = Conv2D(
        64, kernel_size=3, strides=1, padding="same",
        use_bias=False, kernel_regularizer=l2(1e-4),
        name="stem_conv"
    )(inputs)
    x = BatchNormalization(name="stem_bn")(x)
    x = Activation("relu", name="stem_relu")(x)
    x = MaxPooling2D(pool_size=3, strides=1, padding="same", name="stem_pool")(x)

    # Stage 1 : (64 filtres, 3 blocs)
    x = basic_block(x, filters=64, stride=1, name_prefix="stage1_block1")
    x = basic_block(x, filters=64, stride=1, name_prefix="stage1_block2")
    x = basic_block(x, filters=64, stride=1, name_prefix="stage1_block3")

    # Stage 2 : (128 filtres, 4 blocs)
    x = basic_block(x, filters=128, stride=2, name_prefix="stage2_block1")
    for i in range(2, 5):
        x = basic_block(x, filters=128, stride=1, name_prefix=f"stage2_block{i}")

    # Stage 3 : (256 filtres, 6 blocs)
    x = basic_block(x, filters=256, stride=2, name_prefix="stage3_block1")
    for i in range(2, 7):
        x = basic_block(x, filters=256, stride=1, name_prefix=f"stage3_block{i}")

    # Stage 4 : (512 filtres, 3 blocs)
    x = basic_block(x, filters=512, stride=2, name_prefix="stage4_block1")
    x = basic_block(x, filters=512, stride=1, name_prefix="stage4_block2")
    x = basic_block(x, filters=512, stride=1, name_prefix="stage4_block3")

    # Global Average Pooling + classification
    x = GlobalAveragePooling2D(name="global_avg_pool")(x)
    outputs = Dense(num_classes, activation="softmax", name="predictions")(x)

    model = Model(inputs, outputs, name="ResNet34")
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
        loss="sparse_categorical_crossentropy",
        metrics=["accuracy"]
    )
    return model

# Construction et résumé
model = build_resnet34()
model.summary()

Entraînement sur CIFAR-10 et comparaison avec VGG

import numpy as np

# Chargement des données CIFAR-10
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# Construction du modèle ResNet-34
model = build_resnet34(input_shape=(32, 32, 3), num_classes=10)

# Callbacks : réduction du learning rate et arrêt anticipé
callbacks = [
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss", factor=0.1, patience=5, min_lr=1e-6
    ),
    tf.keras.callbacks.EarlyStopping(
        monitor="val_accuracy", patience=15, restore_best_weights=True
    ),
]

# Entraînement (sur un GPU moderne, ~2-4h avec 50 époques)
history = model.fit(
    x_train, y_train,
    validation_split=0.1,
    epochs=50,
    batch_size=128,
    callbacks=callbacks,
    verbose=1,
)

# Évaluation
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Précision ResNet-34 sur CIFAR-10 : {test_acc:.4f}")

# --- Comparaison avec VGG-16 ---
# VGG-16 est un réseau « plain » (sans skip connections) de 16 couches.
# Sur CIFAR-10, avec le même nombre d'époques, VGG-16 atteint ~90-92%
# alors que ResNet-34 atteint typiquement ~92-94%, démontrant que
# la profondeur utile dépasse la performance brute.
#
# Le vrai avantage de ResNet se révèle sur ImageNet :
# VGG-16 : erreur ~7,3% (16 couches)
# ResNet-50 : erreur ~3,6% (50 couches)
# ResNet-152 : erreur ~3,57% (152 couches)
# ResNet-34 n'a que deux fois plus de couches que VGG-16,
# mais ses skip connections lui permettent d'être bien plus efficace.

Hyperparamètres Clés

Recommandation importante : pour ResNet, le SGD avec momentum (0.9) et un learning rate schedule décroissant par paliers (×0.1 aux époques 30, 60, 90) reste l’optimiseur de référence pour atteindre les meilleures performances sur ImageNet. En pratique, Adam converge plus rapidement et donne également d’excellents résultats, particulièrement utile pour le prototypage et l’entraînement sur des jeux de données plus modestes.

Avantages et Limites

Avantages

1. Profondeur sans dégradation — Les skip connections éliminent le problème de dégradation : on peut entraîner des réseaux de 150+ couches qui continuent de s’améliorer avec la profondeur, contrairement aux réseaux conventionnels.
2. Flux de gradient préservé — Le gradient circule directement via les connexions résiduelles, atténuant massivement le vanishing gradient et rendant l’optimisation beaucoup plus stable.
3. Généralisation exceptionnelle — Les représentations apprises par ResNet sont remarquablement transférables à d’autres tâches, d’autres domaines et d’autres modalités.
4. Architecture élégante et modulaire — Le design en blocs indépendants est extrêmement propre et facile à adapter, étendre ou combiner avec d’autres architectures.
5. Impact durable et fondamental — Le concept de connexion résiduelle est devenu un standard universel, réutilisé dans pratiquement toutes les architectures modernes (EfficientNet, RegNet, ConvNeXt, et même les réseaux de transformeurs comme les residual connections dans les blocs d’attention).
6. Compatibilité avec la normalisation — L’ordre Conv → BN → ReLU → Conv → BN → Add → ReLU (pré-activation variant) s’est avéré particulièrement stable et efficace.

Limites

1. Coût computationnel élevé — ResNet-152 requiert environ 11 milliards d’opérations (FLOPs) pour une seule image, ce qui est considérable pour un déploiement en temps réel ou sur des dispositifs embarqués.
2. Taille mémoire importante — Les activations intermédiaires doivent être stockées en mémoire pendant l’entraînement, limitant la taille maximale des lots sur des GPUs aux ressources limitées.
3. Redondance des couches profondes — Des études ont montré que dans les ResNets très profonds, de nombreuses couches apprennent des résidus quasi-nuls (F(x) ≈ 0), suggérant que certaines couches sont redondantes et que le réseau pourrait être compressé sans perte de performance significative.
4. Pas optimal pour les tâches nécessitant une grande précision spatiale — ResNet utilise des convolutions standards qui perdent de l’information spatiale fine au fur et à mesure de la profondeur. Pour des tâches comme la segmentation sémantique ou la détection d’objets précise, des architectures comme U-Net ou FPN sont plus appropriées.
5. Sensibilité à l’initialisation — Bien que moins sensible que les réseaux plain, ResNet reste sensible à une initialisation correcte des poids et à l’utilisation de Batch Normalization pour stabiliser l’entraînement.

4 Cas d’Usage Concrets

1 Classification d’Images Médicales

Les ResNets pré-entraînés sur ImageNet sont largement utilisés pour la classification de radiographies thoraciques, la détection de nodules pulmonaires, ou l’analyse de cellules cancéreuses dans des biopsies. Le transfer learning à partir de ResNet-50 ou ResNet-101 permet d’atteindre des performances de qualité clinique avec seulement quelques milliers d’images annotées, car les features de bas niveau (bords, textures, motifs) apprises sur ImageNet sont universellement transférables.

Exemple : Détection précoce de la rétinopathie diabétique à partir de photographies rétiniennes, avec un ResNet-50 fine-tuné atteignant une sensibilité supérieure à 90%.

2 Détection d’Anomalies Industrielles

Dans l’industrie manufacturière, ResNet est intégré dans des systèmes d’inspection visuelle automatisée pour détecter les défauts sur les chaînes de production : fissures, déformations, imperfections de surface, assemblages défectueux. Un ResNet-34 fine-tuné peut classifier des centaines de types de défauts en temps réel avec une précision inatteignable par les méthodes traditionnelles de vision artificielle.

3 Backbone pour la Détection d’Objets

ResNet constitue le backbone (réseau d’extraction de features) de référence pour de nombreux détecteurs d’objets : Faster R-CNN, RetinaNet, et Mask R-CNN utilisent tous ResNet comme extracteur de caractéristiques. Les features multi-échelles extraites par les différents stages de ResNet sont parfaites pour détecter des objets de tailles variées dans une image.

4 Classification de Texte et Séries Temporelles

Bien que conçu pour la vision, ResNet s’applique aussi au traitement du texte (en remplaçant les convolutions spatiales par des convolutions 1D sur des embeddings) et à l’analyse de séries temporelles (sismologie, finance, IoT). La notion de connexion résiduelle est universelle : elle s’applique à toute architecture profonde où le flux d’information doit être préservé à travers de nombreuses transformations successives.

Voir Aussi

• Maîtrisez les Périodes de Pisano en Python : Guide Complet pour Développeurs
• Windows | Ajouter Git aux variables d’environnement