Apprentissage par transfert PyTorch

L'apprentissage par transfert est une technique qui consiste à prendre un modèle pré-entraîné sur un jeu de données à grande échelle et à le transférer vers une nouvelle tâche avec une quantité de données plus petite pour l'entraînement.

C'est l'une des techniques les plus largement utilisées dans la pratique de l'apprentissage profond aujourd'hui — dans la plupart des cas, l'apprentissage par transfert est plus performant, plus rapide et nécessite moins de données qu'un entraînement à partir de zéro.


1. Idée centrale de l'apprentissage par transfert

Les caractéristiques apprises par les réseaux de neurones profonds sur ImageNet sont universelles :

  • Couches superficielles : apprennent des caractéristiques générales de bas niveau (bords, textures, dégradés de couleur)
  • Couches intermédiaires : apprennent des caractéristiques générales de niveau intermédiaire (formes, parties, combinaisons de textures)
  • Couches profondes : apprendre des caractéristiques de haut niveau spécifiques à la tâche (visages, roues, texte)

Ces caractéristiques de bas et moyen niveau sont efficaces pour la grande majorité des tâches de vision et n'ont pas besoin d'être réapprises.

Quand utiliser l'apprentissage par transfert ?

Quantité de donnéesSimilarité avec la tâche sourceStratégie recommandée
Petite (< 1000)ÉlevéeRemplacer uniquement la tête de classification finale, geler tout le backbone.
Petite (< 1000)FaibleAffiner les couches moins profondes, geler les couches plus profondes.
Moyenne (1000~10000)ÉlevéeAffiner l'ensemble du réseau avec un faible taux d'apprentissage.
Moyenne (1000~10000)FaibleAffiner les couches plus profondes, geler les couches moins profondes.
Grand (> 10000)AnyAffiner tout, ou envisager un entraînement à partir de zéro.

Comparaison des trois stratégies principales

La structure des couches d'un modèle pré-entraîné (par ex., ResNet50) est la suivante :

  • Couches Conv 1~3 (caractéristiques de bas niveau : bords/textures) : généralement gelées
  • Couches Conv 4~6 (caractéristiques de niveau intermédiaire : formes/parties) : optionnellement gelées
  • Couches Conv 7~N (caractéristiques de haut niveau : informations sémantiques) : affinées
  • Tête de classification : remplacée et entraînée
┌─────────────────────────────────────────────────┐
│              预训练模型(如 ResNet50)             │
│  ┌──────────────────────────────────────────┐   │
│  │  Conv Layer 1~3(低级特征:边缘/纹理)      │  ← 通常冻结
│  ├──────────────────────────────────────────┤   │
│  │  Conv Layer 4~6(中级特征:形状/部件)      │  ← 可选冻结
│  ├──────────────────────────────────────────┤   │
│  │  Conv Layer 7~N(高级特征:语义信息)       │  ← 微调
│  ├──────────────────────────────────────────┤   │
│  │  Classifier Head(分类头)                 │  ← 替换 & 训练
│  └──────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘

2. Chargement des modèles pré-entraînés

PyTorch fournit de nombreux modèles pré-entraînés officiels via torchvision.models, et leur chargement est très simple.

Exemple

import torch
import torchvision.models as models

# Charger le modèle pré-entraîné (télécharge automatiquement les poids)
# PyTorch >= 0.13 recommande la nouvelle syntaxe : utiliser le paramètre weights
from torchvision.models import ResNet50_Weights

model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)

# Ancienne syntaxe (fonctionne toujours, mais déclenchera un avertissement de dépréciation)
model = models.resnet50(pretrained=True)

# Ne pas charger les poids pré-entraînés (utiliser uniquement l'architecture du réseau)
model = models.resnet50(weights=None)

Affichage de la structure du modèle

Exemple

# Afficher la structure complète
print(model)

# Afficher uniquement les dernières couches (tête de classification)
print(model.fc)
# Linear(in_features=2048, out_features=1000, bias=True)

# Compter le nombre de paramètres
total_params    = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Nombre total de paramètres: {total_params:,}")
print(f"Paramètres entraînables : {trainable_params:,}")

Noms des têtes de classification pour divers modèles

Les différents modèles ont des noms d'attributs différents pour leurs têtes de classification ; lors de l'apprentissage par transfert, vous devez remplacer la couche correspondante :

ModèleAttribut de la tête de classification
ResNet / RegNetmodel.fc
VGG / AlexNetmodel.classifier[-1]
DenseNetmodel.classifier
EfficientNetmodel.classifier[-1]
MobileNetV2/V3model.classifier[-1]
ViT (Vision Transformer)model.heads.head
ConvNeXtmodel.classifier[-1]
Inception V3model.fc
Swin Transformermodel.head

3. Trois stratégies d'apprentissage par transfert

3.1 Stratégie 1 : Extraction de caractéristiques (tout geler)

Geler tous les paramètres du modèle pré-entraîné et n'entraîner que la tête de classification nouvellement remplacée.

Adapté aux scénarios avec très peu de données (quelques centaines d'images) ou lorsque la tâche est très similaire à la tâche source.

Exemple

import torch
import torch.nn as nn
import torchvision.models as models
from torchvision.models import ResNet18_Weights

NUM_CLASSES = 5   # Nombre de classes pour la tâche cible

# Étape 1 : charger le modèle pré-entraîné
model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)

# Étape 2 : Geler tous les paramètres
for param in model.parameters():
    param.requires_grad = False

# Étape 3 : Remplacer la tête de classification (ces paramètres ont requires_grad=True par défaut)
in_features = model.fc.in_features    # 512
model.fc = nn.Linear(in_features, NUM_CLASSES)

# Vérifier : seule la tête de classification est entraînable
trainable = [(n, p.shape) for n, p in model.named_parameters() if p.requires_grad]
print(f"Nombre de couches entraînables : {len(trainable)}")
for name, shape in trainable:
    print(f" {name}: {shape}")
# Sortie :
# fc.weight: torch.Size([5, 512])
# fc.bias: torch.Size([5])

# Étape 4 : Transmettre uniquement les paramètres entraînables à l'optimiseur (plus efficace)
optimizer = torch.optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-3
)
# Ou une approche équivalente, plus propre :
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

L'extraction de caractéristiques est la stratégie d'apprentissage par transfert la plus simple et la plus couramment utilisée, particulièrement adaptée aux scénarios avec de petites quantités de données.

3.2 Stratégie 2 : Fine-tuning

Dégeler toutes ou certaines des couches pré-entraînées et entraîner l'ensemble du modèle avec un taux d'apprentissage plus faible.

Adapté aux scénarios avec une quantité moyenne de données, ou lorsque la tâche diffère de la tâche source.

Exemple

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

NUM_CLASSES = 10
model = models.resnet50(weights='IMAGENET1K_V2')

# Méthode A : Fine-tuning complet (dégeler toutes les couches)
# D'abord, geler
for param in model.parameters():
    param.requires_grad = False

# Ensuite, dégeler (équivalent à un fine-tuning complet ; ce style est couramment utilisé dans les scénarios de dégel progressif)
for param in model.parameters():
    param.requires_grad = True

# Remplacer la tête de classification
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

# Fine-tuning complet : utiliser un faible taux d'apprentissage pour le backbone et un taux d'apprentissage élevé pour la tête (voir Stratégie 3)
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)


# Méthode B : dégeler les N dernières couches (fine-tuning partiel)
model = models.resnet50(weights='IMAGENET1K_V2')

# Geler d'abord toutes les couches
for param in model.parameters():
    param.requires_grad = False

# Dégeler uniquement layer4 et fc (le dernier bloc et la tête de classification de ResNet)
for param in model.layer4.parameters():
    param.requires_grad = True

model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)  # fc est entraînable par défaut

print("Paramètres entraînables :")
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f" {name}")

3.3 Stratégie 3 : Taux d'apprentissage différentiels par couche

Utilisez un petit taux d'apprentissage pour le backbone (afin de préserver les connaissances pré-entraînées) et un taux d'apprentissage élevé pour la tête de classification (afin de s'adapter rapidement à la nouvelle tâche).

Il s'agit de la stratégie de fine-tuning la plus couramment utilisée dans l'industrie et elle offre les meilleures performances globales.

Exemple

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

NUM_CLASSES = 8
model = models.resnet50(weights='IMAGENET1K_V2')
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

# Option 1 : Deux taux d'apprentissage (backbone vs tête)
optimizer = torch.optim.Adam([
    {'params': model.fc.parameters(),  'lr': 1e-3},     # Tête de classification : taux d'apprentissage élevé
    {'params': [p for n, p in model.named_parameters()  # Backbone : petit taux d'apprentissage
                if not n.startswith('fc')],
     'lr': 1e-5},
])


# Option 2 : Taux d'apprentissage décroissant par couche (le plus fin)
# Les couches les plus proches de la sortie ont des taux d'apprentissage plus élevés
layer_groups = [
    (model.layer1, 1e-5),    # Couche la plus superficielle, taux d'apprentissage le plus faible
    (model.layer2, 3e-5),
    (model.layer3, 1e-4),
    (model.layer4, 3e-4),    # Couche la plus profonde du réseau principal
    (model.fc,     1e-3),    # Tête de classification, taux d'apprentissage le plus élevé
]

param_groups = [
    {'params': layer.parameters(), 'lr': lr}
    for layer, lr in layer_groups
]
optimizer = torch.optim.Adam(param_groups)


# Option 3 : dégel progressif
# Au début de l'entraînement, n'entraîner que la tête, puis dégeler progressivement davantage de couches (recommandé par fastai)
model = models.resnet50(weights='IMAGENET1K_V2')
for param in model.parameters():
    param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

def unfreeze_layers(model, num_layers):
    """Dégeler les derniers blocs de couches num_layers de ResNet"""
    layers = [model.layer4, model.layer3, model.layer2, model.layer1]
    for i in range(min(num_layers, len(layers))):
        for param in layers[i].parameters():
            param.requires_grad = True

# Époque 1-5 : entraîner uniquement la tête de classification
# Époque 6-10 : dégeler layer4
unfreeze_layers(model, num_layers=1)
# Époque 11+ : dégeler plus de couches
unfreeze_layers(model, num_layers=3)

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

4.1 Modèles de classification d'images

Exemple

import torchvision.models as models

# Série ResNet (la plus classique, adaptée à la plupart des tâches)
resnet18  = models.resnet18(weights='IMAGENET1K_V1')   # Léger, adapté aux appareils en périphérie
resnet50  = models.resnet50(weights='IMAGENET1K_V2')   # Choix équilibré
resnet101 = models.resnet101(weights='IMAGENET1K_V2')  # Plus puissant, plus lent

# Série EfficientNet (rapport précision-efficacité extrêmement élevé)
effnet_b0 = models.efficientnet_b0(weights='IMAGENET1K_V1')  # Le plus léger
effnet_b4 = models.efficientnet_b4(weights='IMAGENET1K_V1')  # Équilibré
effnet_b7 = models.efficientnet_b7(weights='IMAGENET1K_V1')  # Le plus puissant

# Vision Transformer (choix privilégié pour les tâches sur données à grande échelle)
vit_b16 = models.vit_b_16(weights='IMAGENET1K_V1')    # ViT-Base/16
vit_l16 = models.vit_l_16(weights='IMAGENET1K_V1')    # ViT-Large/16

# MobileNet (déploiement mobile/embarqué)
mobilenet_v3 = models.mobilenet_v3_small(weights='IMAGENET1K_V1')

# ConvNeXt (CNN modernisé, performances proches de ViT)
convnext_t = models.convnext_tiny(weights='IMAGENET1K_V1')
convnext_b = models.convnext_base(weights='IMAGENET1K_V1')

Comparaison des performances des modèles courants (Précision Top-1 ImageNet) :

ModèlePrécision Top-1ParametersVitesse d'inférenceScénarios applicables
ResNet-1869.8%11.7MExtrêmement rapideRessources limitées, prototypage rapide
ResNet-5080.9%25.6MRapidePremier choix polyvalent
EfficientNet-B483.4%19.3MMoyenneÉquilibre précision-efficacité
ConvNeXt-Base84.1%88.6MMoyenneCNN haute précision
ViT-B/1681.1%86.6MMoyenneScénarios de données massives
ViT-L/1685.1%307MLentPrécision la plus élevée

4.2 Modèles de détection d'objets

Exemple

import torchvision.models.detection as detection

# Faster R-CNN (détecteur classique à deux étapes)
faster_rcnn = detection.fasterrcnn_resnet50_fpn(weights='DEFAULT')

# SSD (détecteur en une seule étape, rapide)
ssd = detection.ssd300_vgg16(weights='DEFAULT')

# RetinaNet
retinanet = detection.retinanet_resnet50_fpn(weights='DEFAULT')

# FCOS
fcos = detection.fcos_resnet50_fpn(weights='DEFAULT')

# Remplacer la tête de classification de Faster R-CNN (adapter au nouveau nombre de classes)
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor

NUM_CLASSES = 5 + 1   # 5 classes d'objets + 1 classe d'arrière-plan

faster_rcnn = detection.fasterrcnn_resnet50_fpn(weights='DEFAULT')
in_features = faster_rcnn.roi_heads.box_predictor.cls_score.in_features
faster_rcnn.roi_heads.box_predictor = FastRCNNPredictor(in_features, NUM_CLASSES)

4.3 Modèles de texte (HuggingFace)

L'apprentissage par transfert pour les tâches de NLP utilise généralement la bibliothèque transformers de HuggingFace :

Exemple

# pip install transformers
from transformers import (
    BertForSequenceClassification,
    RobertaForSequenceClassification,
    AutoModelForSequenceClassification,
    AutoTokenizer,
)

NUM_CLASSES = 3

# BERT (meilleur choix pour la classification de texte)
model = BertForSequenceClassification.from_pretrained(
    'bert-base-chinese',     # BERT chinois
    num_labels=NUM_CLASSES
)
tokenizer = AutoTokenizer.from_pretrained('bert-base-chinese')

# RoBERTa (BERT amélioré, plus performant)
model = RobertaForSequenceClassification.from_pretrained(
    'roberta-base',
    num_labels=NUM_CLASSES
)

# Méthode de chargement générique (identifie automatiquement le type de modèle)
model = AutoModelForSequenceClassification.from_pretrained(
    'hfl/chinese-roberta-wwm-ext',    # RoBERTa chinois
    num_labels=NUM_CLASSES
)

5. Prétraitement et augmentation des données

Lors de l'utilisation de poids pré-entraînés ImageNet dans l'apprentissage par transfert, vous devez utiliser les mêmes paramètres de normalisation que ceux du pré-entraînement ; sinon, les distributions de caractéristiques ne correspondront pas et les performances chuteront considérablement.

Exemple

from torchvision import transforms

# Paramètres de normalisation standard d'ImageNet (communs à tous les modèles pré-entraînés torchvision)
IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD  = [0.229, 0.224, 0.225]

# Ensemble d'entraînement : avec augmentation de données
train_transforms = transforms.Compose([
    transforms.RandomResizedCrop(224),          # Recadrage et redimensionnement aléatoires
    transforms.RandomHorizontalFlip(p=0.5),    # Retournement horizontal aléatoire
    transforms.ColorJitter(                    # Variation de couleur
        brightness=0.2, contrast=0.2,
        saturation=0.2, hue=0.1
    ),
    transforms.RandomRotation(degrees=15),     # Rotation aléatoire
    transforms.ToTensor(),
    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
])

# Ensemble de validation/test : sans augmentation aléatoire
val_transforms = transforms.Compose([
    transforms.Resize(256),                    # D'abord redimensionner à 256
    transforms.CenterCrop(224),                # Puis recadrage central à 224
    transforms.ToTensor(),
    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
])

# Chargement du jeu de données (structure des répertoires : root/class_name/img.jpg)
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader

train_dataset = ImageFolder(root='data/train', transform=train_transforms)
val_dataset   = ImageFolder(root='data/val',   transform=val_transforms)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True,
                          num_workers=4, pin_memory=True)
val_loader   = DataLoader(val_dataset,   batch_size=32, shuffle=False,
                          num_workers=4, pin_memory=True)

print(f"Nombre d'échantillons d'entraînement : {len(train_dataset)}")
print(f"Liste des classes : {train_dataset.classes}")
print(f"Correspondance des classes : {train_dataset.class_to_idx}")

Utilisation du prétraitement officiel recommandé par torchvision

Exemple

# PyTorch >= 0.13 : obtenir le prétraitement standard directement depuis l'objet weights, sans avoir à spécifier manuellement les paramètres
from torchvision.models import ResNet50_Weights

weights   = ResNet50_Weights.IMAGENET1K_V2
model     = models.resnet50(weights=weights)
preprocess = weights.transforms()   # Renvoie automatiquement le pipeline de prétraitement correspondant

# preprocess inclut déjà Resize(232), CenterCrop(224), Normalize, etc.
# Pour l'entraînement, ajoutez simplement de l'augmentation de données par-dessus

Vous devez utiliser les paramètres de normalisation d'ImageNet [0.485, 0.456, 0.406] et [0.229, 0.224, 0.225] ; sinon, les caractéristiques pré-entraînées ne s'aligneront pas correctement.


6. Atelier pratique complet : classification binaire d'images

En utilisant la classification chat contre chien comme exemple, ceci démontre le pipeline complet d'apprentissage par transfert, de la préparation des données à l'entraînement et à l'évaluation :

Exemple

import os
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR
from torchvision import models, transforms, datasets
from torch.utils.data import DataLoader, random_split
from torchvision.models import EfficientNet_B0_Weights

# Configuration
DEVICE      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
NUM_CLASSES = 2
BATCH_SIZE  = 32
EPOCHS      = 20
BASE_LR     = 1e-3
DATA_DIR    = 'data/cats_and_dogs'

# Préparation des données
train_tfm = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.3, contrast=0.3),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],
                         [0.229, 0.224, 0.225]),
])
val_tfm = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],
                         [0.229, 0.224, 0.225]),
])

full_dataset = datasets.ImageFolder(DATA_DIR, transform=train_tfm)

n_val   = int(len(full_dataset) * 0.2)
n_train = len(full_dataset) - n_val
train_set, val_set = random_split(full_dataset, [n_train, n_val])
val_set.dataset = datasets.ImageFolder(DATA_DIR, transform=val_tfm)  # Remplacer la transformation de val

train_loader = DataLoader(train_set, BATCH_SIZE, shuffle=True,
                          num_workers=4, pin_memory=True)
val_loader   = DataLoader(val_set,   BATCH_SIZE, shuffle=False,
                          num_workers=4, pin_memory=True)

# Créer le modèle de transfert
weights = EfficientNet_B0_Weights.IMAGENET1K_V1
model   = models.efficientnet_b0(weights=weights)

# Geler le backbone
for param in model.parameters():
    param.requires_grad = False

# Remplacer la tête de classification (structure de tête EfficientNet-B0)
in_features = model.classifier[1].in_features  # 1280
model.classifier = nn.Sequential(
    nn.Dropout(p=0.2, inplace=True),
    nn.Linear(in_features, NUM_CLASSES),
)

model = model.to(DEVICE)

# Optimiseur : taux d'apprentissage par couche
optimizer = optim.Adam([
    {'params': model.classifier.parameters(), 'lr': BASE_LR},
    {'params': model.features.parameters(),   'lr': BASE_LR * 0.1},
])
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-6)

# Fonctions d'entraînement et de validation
def train_epoch(model, loader, optimizer, criterion):
    model.train()
    total_loss, correct = 0.0, 0
    for imgs, labels in loader:
        imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
        optimizer.zero_grad()
        outputs = model(imgs)
        loss    = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * imgs.size(0)
        correct += (outputs.argmax(1) == labels).sum().item()
    n = len(loader.dataset)
    return total_loss / n, correct / n

def eval_epoch(model, loader, criterion):
    model.eval()
    total_loss, correct = 0.0, 0
    with torch.no_grad():
        for imgs, labels in loader:
            imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
            outputs = model(imgs)
            loss    = criterion(outputs, labels)
            total_loss += loss.item() * imgs.size(0)
            correct += (outputs.argmax(1) == labels).sum().item()
    n = len(loader.dataset)
    return total_loss / n, correct / n

# Entraînement par étapes
print("=== Étape 1 : Entraîner uniquement la tête de classification (Époque 1-5) ===")
best_acc = 0.0

for epoch in range(1, EPOCHS + 1):
    # Dégeler le backbone à l'époque 5, en entrant dans la phase d'affinage complet
    if epoch == 6:
        print("\n=== Étape 2 : Dégeler le backbone et affiner complètement (Époque 6-20) === ")
        for param in model.features.parameters():
            param.requires_grad = True

    train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion)
    val_loss,   val_acc   = eval_epoch(model,  val_loader,   criterion)
    scheduler.step()

    print(f"Époque {epoch:2d}/{EPOCHS} | "
          f"Perte d'entraînement : {train_loss:.4f}, Précision : {train_acc:.4f} | "
          f"Perte de validation : {val_loss:.4f}, Exactitude : {val_acc:.4f} | "
          f"Taux d'apprentissage : {scheduler.get_last_lr()[0]:.2e}")

    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), 'best_model.pth')
        print(f" ✓ Meilleur modèle sauvegardé Acc={best_acc:.4f}")

print(f"\n"Entraînement terminé, meilleure précision de validation : {best_acc:.4f}")

Inférence et prédiction

Exemple

from PIL import Image

# Charger le meilleur modèle
model.load_state_dict(torch.load('best_model.pth', map_location=DEVICE))
model.eval()

# Prédire une seule image
def predict(image_path, model, class_names):
    img = Image.open(image_path).convert('RGB')
    tensor = val_tfm(img).unsqueeze(0).to(DEVICE)  # (1, 3, 224, 224)

    with torch.inference_mode():
        logits = model(tensor)
        probs  = torch.softmax(logits, dim=1)[0]
        pred   = probs.argmax().item()

    for cls, prob in zip(class_names, probs.tolist()):
        print(f" {cls}: {prob:.4f}")
    print(f"Résultat de la prédiction : {class_names[pred]}")
    return class_names[pred]

class_names = train_set.dataset.classes  # ['cat', 'dog']
predict('test_cat.jpg', model, class_names)

7. Atelier pratique complet : Classification de texte (BERT)

Exemple

# pip install transformers datasets
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from transformers import (
    BertTokenizer,
    BertForSequenceClassification,
    AdamW,
    get_linear_schedule_with_warmup,
)

DEVICE      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
MODEL_NAME  = 'bert-base-chinese'
NUM_CLASSES = 3       # Classification de sentiment : positif/neutre/négatif
MAX_LEN     = 128
BATCH_SIZE  = 16
EPOCHS      = 5
LR          = 2e-5    # Plage de taux d'apprentissage recommandée pour le fine-tuning de BERT : 1e-5 ~ 5e-5

# Jeu de données personnalisé
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len):
        self.texts     = texts
        self.labels    = labels
        self.tokenizer = tokenizer
        self.max_len   = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        encoding = self.tokenizer(
            self.texts[idx],
            max_length=self.max_len,
            padding='max_length',
            truncation=True,
            return_tensors='pt',
        )
        return {
            'input_ids': encoding['input_ids'].squeeze(0),
            'attention_mask': encoding['attention_mask'].squeeze(0),
            'label': torch.tensor(self.labels[idx], dtype=torch.long),
        }

# Charger le modèle BERT pré-entraîné
tokenizer = BertTokenizer.from_pretrained(MODEL_NAME)
model     = BertForSequenceClassification.from_pretrained(
    MODEL_NAME,
    num_labels=NUM_CLASSES,
    hidden_dropout_prob=0.1,
)
model = model.to(DEVICE)

# Geler les N couches inférieures (facultatif)
# BERT-base comporte 12 couches Transformer ; vous pouvez geler les premières couches pour économiser du calcul
FREEZE_LAYERS = 6   # Geler les 6 premières couches

for i, layer in enumerate(model.bert.encoder.layer):
    if i < FREEZE_LAYERS:
        for param in layer.parameters():
            param.requires_grad = False

print(f"A gelé les {FREEZE_LAYERS} premières couches, réduisant les mises à jour des paramètres d'environ {FREEZE_LAYERS/12*100:.0f}%")

# Chargement des données
# Données d'exemple (à remplacer par un vrai jeu de données en pratique)
train_texts  = ["Ce film est génial !", "Le service est terrible, décevant", "Comme ci, comme ça, rien de spécial"]
train_labels = [2, 0, 1]  # 0: négatif 1: neutre 2: positif

train_dataset = SentimentDataset(train_texts, train_labels, tokenizer, MAX_LEN)
train_loader  = DataLoader(train_dataset, BATCH_SIZE, shuffle=True)

# Optimiseur et planificateur
# BERT standard: AdamW + warmup linéaire
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped = [
    {'params': [p for n, p in model.named_parameters()
                if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
    {'params': [p for n, p in model.named_parameters()
                if     any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
]
optimizer = AdamW(optimizer_grouped, lr=LR)

total_steps   = len(train_loader) * EPOCHS
warmup_steps  = int(total_steps * 0.1)   # 10% des étapes utilisées pour l'échauffement
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps,
)

# Boucle d'entraînement
for epoch in range(1, EPOCHS + 1):
    model.train()
    total_loss, correct = 0.0, 0

    for batch in train_loader:
        input_ids      = batch['input_ids'].to(DEVICE)
        attention_mask = batch['attention_mask'].to(DEVICE)
        labels         = batch['label'].to(DEVICE)

        optimizer.zero_grad()
        outputs = model(input_ids=input_ids,
                        attention_mask=attention_mask,
                        labels=labels)

        loss   = outputs.loss           # BERT calcule déjà la perte CE en interne
        logits = outputs.logits

        loss.backward()
        # Standard de fine-tuning BERT : écrêtage du gradient pour éviter l'explosion du gradient
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        scheduler.step()

        total_loss += loss.item()
        correct    += (logits.argmax(1) == labels).sum().item()

    avg_loss = total_loss / len(train_loader)
    acc      = correct / len(train_dataset)
    print(f"Époque {epoch}/{EPOCHS} | Perte : {avg_loss:.4f} | Précision : {acc:.4f}")

# Inférence
def predict_sentiment(text, model, tokenizer, id2label):
    model.eval()
    encoding = tokenizer(text, max_length=MAX_LEN, padding='max_length',
                         truncation=True, return_tensors='pt')
    with torch.inference_mode():
        outputs = model(
            input_ids      = encoding['input_ids'].to(DEVICE),
            attention_mask = encoding['attention_mask'].to(DEVICE),
        )
    pred = outputs.logits.argmax(1).item()
    return id2label[pred]

id2label = {0: 'Négatif', 1: 'Neutre', 2: 'Positif'}
print(predict_sentiment("La qualité de ce produit est vraiment bonne !", model, tokenizer, id2label))

8. Conseils de modification de l'architecture du modèle

Méthode générale pour remplacer la tête de classification

Exemple

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

def build_transfer_model(arch, num_classes, pretrained=True, dropout=0.5):
    """
Fonction générique de construction de modèle de transfert qui identifie et remplace automatiquement la tête de classification
Pris en charge : resnet, efficientnet, densenet, mobilenet, vit, convnext
    """

    weights = 'IMAGENET1K_V1' if pretrained else None
    model   = getattr(models, arch)(weights=weights)
    name    = arch.lower()

    if 'resnet' in name or 'resnext' in name or 'inception' in name:
        in_f = model.fc.in_features
        model.fc = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(in_f, num_classes)
        )

    elif 'efficientnet' in name or 'mobilenet' in name or 'convnext' in name:
        in_f = model.classifier[-1].in_features
        model.classifier[-1] = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(in_f, num_classes)
        )

    elif 'densenet' in name:
        in_f = model.classifier.in_features
        model.classifier = nn.Linear(in_f, num_classes)

    elif 'vit' in name or 'swin' in name:
        in_f = model.heads.head.in_features
        model.heads.head = nn.Linear(in_f, num_classes)

    else:
        raise ValueError(f"Architecture non prise en charge : {arch}")

    return model


# Exemple d'utilisation
model_resnet  = build_transfer_model('resnet50',        num_classes=10)
model_effnet  = build_transfer_model('efficientnet_b3', num_classes=10)
model_vit     = build_transfer_model('vit_b_16',        num_classes=10)

Ajout de couches d'extraction de caractéristiques intermédiaires

Exemple

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

class TransferWithAttention(nn.Module):
    """Ajouter un module d'attention personnalisé et une tête de classification après le backbone pré-entraîné"""
    def __init__(self, num_classes, dropout=0.5):
        super().__init__()
        backbone = models.resnet50(weights='IMAGENET1K_V2')

        # Supprimer la tête de classification d'origine, conserver l'extracteur de caractéristiques
        self.backbone  = nn.Sequential(*list(backbone.children())[:-1])
        self.feat_dim  = 2048   # Dimension des caractéristiques de ResNet50

        # Portes d'attention personnalisées
        self.attention = nn.Sequential(
            nn.Linear(self.feat_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 1),
            nn.Sigmoid()
        )

        # Tête de classification
        self.classifier = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(self.feat_dim, 256),
            nn.ReLU(),
            nn.Linear(256, num_classes),
        )

    def forward(self, x):
        feat   = self.backbone(x).flatten(1)          # (N, 2048)
        weight = self.attention(feat)                  # (N, 1)
        feat   = feat * weight                         # Caractéristiques pondérées
        return self.classifier(feat)

9. Bonnes pratiques de l'apprentissage par transfert

Sélection du taux d'apprentissage

Exemple

# Taux d'apprentissage du backbone (couches pré-entraînées)
# Généralement défini à 1/10 ~ 1/100 du taux d'apprentissage de la tête
backbone_lr = 1e-5   # Stratégie conservatrice, recommandée lorsque les données sont rares
head_lr     = 1e-3   # Les nouvelles couches partent d'une initialisation aléatoire et nécessitent un taux d'apprentissage plus élevé

# Taux d'apprentissage pour les Transformers tels que BERT / ViT
# Ces grands modèles sont extrêmement sensibles au taux d'apprentissage ; sortir de la plage peut endommager les connaissances pré-entraînées
bert_lr = 2e-5        # Plage recommandée : 1e-5 ~ 5e-5

Problèmes courants et solutions

Exemple

# Problème 1 : Mémoire GPU insuffisante
# Solution 1 : Réduire la taille du lot
# Solution 2 : Utiliser le gradient checkpointing (échanger du temps contre de la mémoire)
from torch.utils.checkpoint import checkpoint_sequential
model.features = lambda x: checkpoint_sequential(model.features, 4, x)

# Solution 3 : Geler plus de couches (réduire le calcul de rétropropagation)

# Problème 2 : Précision d'entraînement élevée, précision de validation faible (surapprentissage)
# Solution 1 : Renforcer l'augmentation des données
# Solution 2 : Augmenter le Dropout
model.classifier = nn.Sequential(nn.Dropout(0.5), nn.Linear(in_f, num_classes))
# Solution 3 : Utiliser le lissage des étiquettes
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
# Solution 4 : Geler davantage de couches du backbone pour réduire les paramètres entraînables

# Problème 3 : Entraînement instable, oscillation de la perte
# Solution 1 : Réduire le taux d'apprentissage (essayez de le réduire de moitié)
# Solution 2 : Ajouter un warmup
# Solution 3 : Écrêtage du gradient
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# Solution 4 : Changer l'optimiseur (Adam → AdamW)

# Problème 4 : Les paramètres de normalisation ne correspondent pas
# Erreur : L'utilisation d'une normalisation personnalisée ne correspond pas au modèle préentraîné
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
# Correct : Il faut utiliser la moyenne et l'écart-type d'ImageNet
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

Référence rapide de la stratégie globale

ProblèmeApproche recommandée
Taille des données < 500Geler toutes les couches, entraîner uniquement la tête de classification
Taille des données 500~2000Geler les 2/3 premiers, affiner le dernier 1/3
Taille des données 2000~10000Fine-tuning complet, backbone à 1e-5, tête à 1e-3
Taille des données > 10000Fine-tuning complet, envisagez un taux d'apprentissage plus élevé ou un entraînement à partir de zéro
Vitesse d'entraînement lenteGelez et entraînez d'abord pendant quelques epochs, puis dégelez ; utilisez la précision mixte AMP
Goulot d'étranglement de performancePassez à un backbone plus grand/plus récent ; essayez ConvNeXt / ViT
Le modèle doit être déployé en productionPrivilégiez les modèles légers tels que EfficientNet-B0 / MobileNetV3
Tâches NLP en chinoisBERT-base-chinese ou chinese-roberta-wwm-ext

Stratégie d'entraînement complète recommandée

Phase 1 (Epoch 1~N/4) :

  • Gelez le backbone, entraînez uniquement la tête de classification
  • Utiliser un taux d'apprentissage plus élevé (1e-3) pour faire converger rapidement les paramètres de la tête

Phase 2 (Époque N/4~N) :

  • Dégeler le backbone, fine-tuning complet
  • Le backbone utilise un petit taux d'apprentissage (1e-5), la tête conserve (1e-3)
  • Combiner avec un recuit cosinus ou ReduceLROnPlateau

Stratégie de sauvegarde :

  • Enregistrer uniquement le checkpoint avec les meilleures métriques de validation
  • Enregistrer également les états du modèle / de l'optimiseur / du scheduler
Autres extensions