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ées | Similarité avec la tâche source | Stratégie recommandée |
|---|---|---|
| Petite (< 1000) | Élevée | Remplacer uniquement la tête de classification finale, geler tout le backbone. |
| Petite (< 1000) | Faible | Affiner les couches moins profondes, geler les couches plus profondes. |
| Moyenne (1000~10000) | Élevée | Affiner l'ensemble du réseau avec un faible taux d'apprentissage. |
| Moyenne (1000~10000) | Faible | Affiner les couches plus profondes, geler les couches moins profondes. |
| Grand (> 10000) | Any | Affiner 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 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
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èle | Attribut de la tête de classification |
|---|---|
| ResNet / RegNet | model.fc |
| VGG / AlexNet | model.classifier[-1] |
| DenseNet | model.classifier |
| EfficientNet | model.classifier[-1] |
| MobileNetV2/V3 | model.classifier[-1] |
| ViT (Vision Transformer) | model.heads.head |
| ConvNeXt | model.classifier[-1] |
| Inception V3 | model.fc |
| Swin Transformer | model.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.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.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.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
# 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èle | Précision Top-1 | Parameters | Vitesse d'inférence | Scénarios applicables |
|---|---|---|---|---|
| ResNet-18 | 69.8% | 11.7M | Extrêmement rapide | Ressources limitées, prototypage rapide |
| ResNet-50 | 80.9% | 25.6M | Rapide | Premier choix polyvalent |
| EfficientNet-B4 | 83.4% | 19.3M | Moyenne | Équilibre précision-efficacité |
| ConvNeXt-Base | 84.1% | 88.6M | Moyenne | CNN haute précision |
| ViT-B/16 | 81.1% | 86.6M | Moyenne | Scénarios de données massives |
| ViT-L/16 | 85.1% | 307M | Lent | Précision la plus élevée |
4.2 Modèles de détection d'objets
Exemple
# 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
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
# 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
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 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
# 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
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 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.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
# 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
# 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ème | Approche recommandée |
|---|---|
| Taille des données < 500 | Geler toutes les couches, entraîner uniquement la tête de classification |
| Taille des données 500~2000 | Geler les 2/3 premiers, affiner le dernier 1/3 |
| Taille des données 2000~10000 | Fine-tuning complet, backbone à 1e-5, tête à 1e-3 |
| Taille des données > 10000 | Fine-tuning complet, envisagez un taux d'apprentissage plus élevé ou un entraînement à partir de zéro |
| Vitesse d'entraînement lente | Gelez et entraînez d'abord pendant quelques epochs, puis dégelez ; utilisez la précision mixte AMP |
| Goulot d'étranglement de performance | Passez à un backbone plus grand/plus récent ; essayez ConvNeXt / ViT |
| Le modèle doit être déployé en production | Privilégiez les modèles légers tels que EfficientNet-B0 / MobileNetV3 |
| Tâches NLP en chinois | BERT-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