Transfer Learning : Guide complet — Apprentissage par Transfert

Résumé — Le Transfer Learning (apprentissage par transfert) consiste à réutiliser un modèle pré-entraîné sur une tâche source pour résoudre une tâche cible différente mais connexe. Plutôt que d’entraîner un réseau de neurones à partir de zéro (ce qui demande des millions de données et des jours de calcul), on part d’un modèle déjà performant et on l’adapte. C’est aujourd’hui la pratique standard en deep learning, utilisée dans les domaines de la vision par ordinateur, du traitement du langage et de l’audio.

Principe mathématique

1. Concept fondamental

L’idée centrale est que les premières couches d’un réseau profond apprennent des features génériques et réutilisables :

• Couches basses (près de l’entrée) : détectent des motifs simples (bords, textures, gradients en vision; n-grammes, syntaxe en NLP).
• Couches intermédiaires : combinent ces motifs en structures plus complexes (formes, motifs répétitifs, phrases).
• Couches hautes (près de la sortie) : apprennent des features spécifiques à la tâche (visages, roues, mots-clés spécifiques).

Le transfer learning exploite ce principe : on garde les couches basses (génériques) et on remplace les couches hautes (spécifiques).

2. Approches de transfert

Feature Extraction (extraction de features) :
On gèle toutes les couches du modèle pré-entraîné et on ajoute un nouveau classifieur en tête :

$$\hat{y} = g_\theta(f_{pre}(x))$$

où $f_{pre}$ est le modèle pré-entraîné (paramètres figés) et $g_\theta$ est le nouveau classifieur (seuls paramètres entraînés).

Fine-Tuning (ajustement fin) :
On dégèle partiellement le modèle et on ré-entraîne certaines couches avec un faible learning rate :

$$\theta_{new} = \theta_{pre} – \eta_{small} \cdot \nabla_\theta L(\theta)$$

Le faible learning rate garantit que les poids pré-entraînés ne sont pas détruits par les mises à jour.

3. Stratégie de congélation progressive

La stratégie recommandée en pratique est :
1. Phase 1 :geler tout le backbone, entraîner uniquement la tête de classification.
2. Phase 2 :dégeler les dernières couches du backbone (derniers 20-30%), fine-tuner avec lr faible.
3. Phase 3 (optionnelle) :dégeler davantage si le dataset cible est grand.

4. Modèles pré-entraînés populaires

Intuition

Imaginez un musicien classique qui décide d’apprendre le jazz.

Sans transfer learning (de zéro) : il apprendrait à tenir un instrument, lire une partition, comprendre le rythme — comme un enfant qui découvre la musique.

Avec transfer learning : il utilise sa technique déjà acquise (lecture de notes, dextérité des doigts, sens du rythme) et se concentre uniquement sur ce qui change en jazz (improvisation, swing, harmonies étendues). Son apprentissage est 50 fois plus rapide.

C’est exactement ce que fait le transfer learning : les couches basses du modèle sont comme la technique musicale de base — elles sont universelles et se transfèrent partout.

Implémentation Python

Exemple 1 : Feature Extraction avec VGG16

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models

# Charger VGG16 pré-entraîné sans la tête de classification
base_model = keras.applications.VGG16(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3),
    pooling='avg'
)

# Geler toutes les couches
base_model.trainable = False

# Ajouter notre classifieur
model = models.Sequential([
    base_model,
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')  # Classification binaire
])

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])
model.summary()

Exemple 2 : Fine-Tuning avec ResNet50

# Charger ResNet50
base = keras.applications.ResNet50(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3),
    pooling='avg'
)

# Phase 1: geler tout et entraîner la tête
base.trainable = False
head = keras.Sequential([
    base,
    layers.Dense(512, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')  # 10 classes
])
head.compile(optimizer='adam', loss='categorical_crossentropy',
             metrics=['accuracy'])
# head.fit(train_data, epochs=5) # entraînement phase 1

# Phase 2: dégeler les 50 dernières couches
base.trainable = True
for layer in base.layers[:-50]:
    layer.trainable = False

# Fine-tuning avec learning rate très faible
head.compile(optimizer=keras.optimizers.Adam(learning_rate=1e-5),
             loss='categorical_crossentropy',
             metrics=['accuracy'])
# head.fit(train_data, epochs=10) # entraînement phase 2

Exemple 3 : Data Augmentation pour le transfert

# Data augmentation essentielle quand le dataset cible est petit
data_aug = keras.Sequential([
    layers.RandomFlip('horizontal'),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
    layers.RandomContrast(0.1),
], name='data_augmentation')

model_aug = models.Sequential([
    data_aug,
    keras.applications.MobileNetV2(weights='imagenet',
        include_top=False, input_shape=(224, 224, 3), pooling='avg'),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(1, activation='sigmoid')
])

# Note : les couches d'augmentation sont inactives en mode inférence

Hyperparamètres

Avantages du Transfer Learning

1. Performance avec peu de données : Un modèle pré-entraîné atteint des performances acceptables avec seulement 100-1000 exemples par classe, là où un entraînement from scratch nécessiterait des dizaines de milliers d’exemples.
2. Gain de temps colossal : Au lieu de jours ou semaines d’entraînement sur GPUs, le fine-tuning prend quelques minutes à quelques heures.
3. Meilleure convergence : Les poids pré-entraînés sont déjà dans une bonne région de l’espace des paramètres. La convergence est plus rapide et plus stable.
4. Accessibilité : Pas besoin de clusters de GPUs pour bénéficier du deep learning. Un seul GPU suffit pour fine-tuner un modèle de pointe.
5. Standard de l’industrie : En 2026, il est extrêmement rare d’entraîner un modèle from scratch. Le transfer learning est la norme dans tous les domaines.

Limites du Transfer Learning

1. Domain gap : Si le dataset source (ImageNet) et le dataset cible (images médicales par exemple) sont trop différents, les features apprises peuvent ne pas se transférer efficacement.
2. Biais du modèle source : Les biais présents dans les données d’entraînement source se propagent au modèle fine-tuné (biais de genre, ethnique, culturel).
3. Taille du modèle : Les modèles pré-entraînés comme VGG16 pèsent 500 Mo. Pour le déploiement sur edge devices, des modèles légers comme MobileNet sont nécessaires.
4. Overfitting sur petits datasets : Si on dégèle trop de couches sur un dataset minuscule, le modèle peut surapprendre rapidement.
5. Dépendance à l’architecture source : Si le dataset cible a une résolution différente ou un format d’entrée non standard, l’adaptation nécessite des ajustements techniques supplémentaires.

4 cas d’usage concrets

1. Détection de pathologies en imagerie médicale

Un modèle pré-entraîné sur ImageNet (images naturelles) est fine-tuné sur des radiographies pulmonaires pour détecter la pneumonie. Les premières couches de VGG16, qui détectent bords et textures, se transfèrent parfaitement aux contours osseux et aux textures pulmonaires.

2. Classification de produits e-commerce

Les plateformes e-commerce fine-tunent des modèles de vision pour classifier automatiquement les photos de produits par catégorie (vêtements, électronique, meubles). Un ResNet50 pré-entraîné atteint 95%+ de précision avec seulement quelques centaines d’images par catégorie.

3. Analyse de sentiments en français avec mBERT

Le multilingual BERT (mBERT), pré-entraîné sur 104 langues, est fine-tuné sur un corpus français annoté pour la classification de sentiments (positif/négatif/neutre). Grâce au transfert multilingue, les performances sont excellentes même avec peu de données françaises.

4. Détection de défauts industriels

Dans l’industrie manufacturière, la détection de défauts sur des pièces nécessite peu d’exemples de défauts (car les défauts sont rares par nature). Un modèle pré-entraîné comme EfficientNet, fine-tuné avec quelques centaines de photos de défauts, atteint des taux de détection supérieurs à 99%.

Conclusion

Le Transfer Learning est sans doute la technique la plus pratique du deep learning moderne. Il démocratise l’accès à des modèles de pointe en réduisant le besoin en données et en puissance de calcul de plusieurs ordres de grandeur.

La recette est simple : choisir un modèle pré-entraîné adapté au domaine, geler le backbone, ajouter une tête de classification, entraîner cette tête, puis fine-tuner les dernières couches avec un faible learning rate.

En 2026, le transfer learning n’est plus une option — c’est le point de départ par défaut de tout projet de deep learning. Toute équipe qui ignore cette approche se condamne à des résultats médiocres avec un budget exponentiel.

Voir aussi

• Trouver la Plus Grande Sous-Matrice Zéro en Python
• Maîtriser Python : Résoudre le Problème ‘Birds on a Wire’ avec Efficacité