Évaluation et débogage de modèles PyTorch
L'entraînement et l'optimisation des modèles d'apprentissage profond nécessitent des méthodes systématiques d'évaluation et de débogage. Cette section présente comment analyser les courbes de perte, identifier le surapprentissage et le sous-apprentissage, utiliser des matrices de confusion pour évaluer les modèles de classification, ainsi que les techniques de débogage courantes.
1. Analyse de la fonction de perte
La fonction de perte est une métrique centrale pendant l'entraînement, reflétant l'écart entre les prédictions du modèle et les valeurs réelles. Une analyse correcte de la courbe de perte est essentielle pour déboguer les modèles.
1.1 Comparaison de la perte d'entraînement et de validation
En comparant la perte d'entraînement et la perte de validation, l'état du modèle peut être déterminé :
- La perte d'entraînement diminue, la perte de validation diminue: Normal, indiquant que le modèle apprend
- La perte d'entraînement diminue, la perte de validation stagne ou augmente: Surapprentissage, régularisation nécessaire
- La perte d'entraînement ne diminue pas: Problème de taux d'apprentissage ou problème d'architecture du modèle
- La perte d'entraînement oscille: Taux d'apprentissage trop grand ou taille de lot trop petite
1.2 Visualisation de la courbe de perte
Exemple
import numpy as np
def plot_training_history(history):
"""
Tracer l'historique d'entraînement
history: un dict contenant 'train_loss', 'val_loss', 'train_acc', 'val_acc'
"""
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# Courbe de perte
axes[0].plot(history['train_loss'], label='Perte d'entraînement', alpha=0.8)
axes[0].plot(history['val_loss'], label='Perte de validation', alpha=0.8)
axes[0].set_xlabel('Époque')
axes[0].set_ylabel('Perte')
axes[0].set_title('Perte d'entraînement et de validation')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
# Courbe de précision
axes[1].plot(history['train_acc'], label='Préc. entraînement', alpha=0.8)
axes[1].plot(history['val_acc'], label='Préc. validation', alpha=0.8)
axes[1].set_xlabel('Époque')
axes[1].set_ylabel('Précision')
axes[1].set_title('Précision entraînement et validation')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# Simuler les données d'entraînement
history = {
'train_loss': np.linspace(2.0, 0.2, 50) + np.random.normal(0, 0.05, 50),
'val_loss': np.linspace(2.0, 0.3, 50) + np.random.normal(0, 0.08, 50),
'train_acc': np.linspace(0.3, 0.95, 50),
'val_acc': np.linspace(0.3, 0.88, 50),
}
plot_training_history(history)
1.3 Identification du surapprentissage
Lorsque la perte de validation commence à augmenter alors que la perte d'entraînement continue de diminuer, c'est le début du surapprentissage. À ce stade, le modèle commence à « mémoriser » les données d'entraînement au lieu d'apprendre des schémas généraux.
Exemple
import numpy as np
def detect_overfitting(history, patience=5):
"""
Détecter le surapprentissage
patience : nombre d'époques consécutives avec une perte de validation croissante avant d'arrêter l'entraînement
"""
val_loss = history['val_loss']
best_loss = float('inf')
best_epoch = 0
early_stop_epoch = None
for epoch in range(patience, len(val_loss)):
# Vérifier les dernières époques de patience
recent_losses = val_loss[epoch - patience:epoch]
current_loss = val_loss[epoch]
# Si la perte actuelle est supérieure à la perte minimale la plus récente
if min(recent_losses) < current_loss:
early_stop_epoch = epoch
break
if current_loss < best_loss:
best_loss = current_loss
best_epoch = epoch
if early_stop_epoch:
print(f"Surapprentissage détecté ! Meilleure époque : {best_epoch}, devrait s'arrêter à l'époque {early_stop_epoch}")
else:
print("Aucun surapprentissage détecté")
return early_stop_epoch, best_epoch
# Exemple de surapprentissage
overfitting_history = {
'train_loss': np.linspace(1.5, 0.1, 30),
'val_loss': np.concatenate([np.linspace(1.5, 0.3, 15), np.linspace(0.3, 0.8, 15)]),
}
detect_overfitting(overfitting_history)
2. Gestion du surapprentissage et du sous-apprentissage
2.1 Solutions au surapprentissage
| Méthode | Description | Implémentation du code |
|---|---|---|
| Augmenter le volume de données | Collecter plus de données d'entraînement | Augmentation de données |
| Dropout | Désactiver aléatoirement des neurones | nn.Dropout(0.5) |
| Décroissance des poids | Régularisation L2 | weight_decay=1e-4 |
| Arrêt précoce | Arrêter l'entraînement lorsque la perte de validation cesse de diminuer | paramètre de patience |
| Réduire la complexité du modèle | Réduire le nombre de couches ou de neurones | Réduire hidden_size |
| Augmentation de données | Transformations aléatoires pour augmenter la diversité des données | Rotation, retournement, recadrage |
2.2 Solutions au sous-apprentissage
| Méthode | Description |
|---|---|
| Augmenter la complexité du modèle | Augmenter le nombre de couches ou de neurones |
| Entraîner plus longtemps | Augmenter le nombre d'époques d'entraînement |
| Réduire la régularisation | Réduire Dropout ou weight_decay |
| Ajuster le taux d'apprentissage | Essayer un taux d'apprentissage plus élevé |
2.3 Implémentation du mécanisme d'arrêt précoce
Exemple
import torch.nn as nn
import torch.optim as optim
class EarlyStopping:
"""
Mécanisme d'arrêt précoce : arrêter l'entraînement lorsque la perte de validation ne diminue pas pendant des époques consécutives
"""
def __init__(self, patience=7, min_delta=0, mode='min'):
"""
patience : nombre d'époques consécutives sans amélioration avant l'arrêt
min_delta : la variation minimale considérée comme une amélioration
mode : 'min' ou 'max', si la métrique doit être minimisée ou maximisée
"""
self.patience = patience
self.min_delta = min_delta
self.mode = mode
self.counter = 0
self.best_score = None
self.early_stop = False
def __call__(self, val_loss):
score = -val_loss if self.mode == 'min' else val_loss
if self.best_score is None:
self.best_score = score
elif score < self.best_score + self.min_delta:
self.counter += 1
if self.counter >= self.patience:
self.early_stop = True
else:
self.best_score = score
self.counter = 0
return self.early_stop
# Utiliser l'arrêt anticipé
def train_with_early_stopping(model, train_loader, val_loader, patience=7):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
early_stopping = EarlyStopping(patience=patience, mode='min')
best_val_loss = float('inf')
best_model_state = None
for epoch in range(100):
# Entraîner
model.train()
train_loss = 0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item()
# Valider
model.eval()
val_loss = 0
with torch.no_grad():
for inputs, labels in val_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = model(inputs)
loss = criterion(outputs, labels)
val_loss += loss.item()
val_loss /= len(val_loader)
print(f"Époque {epoch+1} : Perte d'entraînement={train_loss:.4f}, Perte de validation={val_loss:.4f}")
# Vérification de l'arrêt précoce
if early_stopping(val_loss):
print(f"Arrêt précoce déclenché ! La perte de validation n'a pas diminué pendant {patience} époques consécutives")
# Enregistrer le meilleur modèle
if val_loss < best_val_loss:
best_val_loss = val_loss
best_model_state = model.state_dict().copy()
# Restaurer le meilleur modèle
model.load_state_dict(best_model_state)
return model
3. Matrice de confusion
La matrice de confusion est un outil important pour évaluer les modèles de classification, montrant la relation entre les prédictions du modèle et les étiquettes réelles.
3.1 Calcul de la matrice de confusion
Exemple
import numpy as np
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
def calculate_confusion_matrix(model, dataloader, device, num_classes):
"""
Calculer la matrice de confusion
"""
model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for inputs, labels in dataloader:
inputs = inputs.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(labels.numpy())
cm = confusion_matrix(all_labels, all_preds)
return cm
def plot_confusion_matrix(cm, class_names):
"""
Tracer la matrice de confusion
"""
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=class_names, yticklabels=class_names)
plt.xlabel('Étiquette prédite')
plt.ylabel('Étiquette réelle')
plt.title('Matrice de confusion')
plt.tight_layout()
plt.show()
# Exemple d'utilisation
# Supposons qu'il y ait 10 classes
class_names = [f'Classe {i}' for i in range(10)]
cm = np.array([
[45, 1, 0, 0, 0, 0, 2, 1, 1, 0],
[0, 42, 2, 0, 0, 0, 0, 3, 2, 1],
[1, 1, 38, 3, 0, 0, 0, 2, 3, 2],
[0, 0, 1, 41, 2, 1, 0, 1, 1, 3],
[0, 0, 0, 1, 44, 0, 1, 0, 2, 2],
[1, 0, 0, 0, 0, 43, 2, 1, 1, 2],
[2, 1, 0, 0, 1, 1, 39, 2, 2, 2],
[0, 2, 1, 1, 0, 0, 1, 40, 3, 2],
[1, 2, 2, 0, 1, 1, 1, 2, 36, 4],
[0, 1, 1, 2, 2, 2, 2, 1, 2, 37],
])
plot_confusion_matrix(cm, class_names)
3.2 Métriques d'évaluation de la classification
Plusieurs métriques d'évaluation peuvent être calculées à partir de la matrice de confusion :
Exemple
def classification_metrics(cm):
"""
Calculez diverses métriques d'évaluation à partir de la matrice de confusion
"""
# Exactitude
accuracy = np.trace(cm) / np.sum(cm)
# Calculer la précision, le rappel et le F1 pour chaque classe
num_classes = cm.shape[0]
precisions = []
recalls = []
f1s = []
for i in range(num_classes):
tp = cm[i, i]
fp = np.sum(cm[:, i]) - tp
fn = np.sum(cm[i, :]) - tp
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
precisions.append(precision)
recalls.append(recall)
f1s.append(f1)
# Moyenne macro
macro_precision = np.mean(precisions)
macro_recall = np.mean(recalls)
macro_f1 = np.mean(f1s)
# Moyenne pondérée
class_counts = np.sum(cm, axis=1)
weights = class_counts / np.sum(class_counts)
weighted_precision = np.average(precisions, weights=weights)
weighted_recall = np.average(recalls, weights=weights)
weighted_f1 = np.average(f1s, weights=weights)
return {
'accuracy': accuracy,
'macro_precision': macro_precision,
'macro_recall': macro_recall,
'macro_f1': macro_f1,
'weighted_precision': weighted_precision,
'weighted_recall': weighted_recall,
'weighted_f1': weighted_f1,
}
# Calculer les métriques
metrics = classification_metrics(cm)
print("=" * 50)
print("Métriques d'évaluation de classification")
print("=" * 50)
print(f"Exactitude : {metrics['accuracy']:.4f}")
print(f"Précision macro : {metrics['macro_precision']:.4f}")
print(f"Rappel macro : {metrics['macro_recall']:.4f}")
print(f"F1 macro : {metrics['macro_f1']:.4f}")
print(f"Précision pondérée : {metrics['weighted_precision']:.4f}")
print(f"Rappel pondéré : {metrics['weighted_recall']:.4f}")
print(f"F1 pondéré : {metrics['weighted_f1']:.4f}")
3.3 Rapport de classification
Exemple
# Utiliser le rapport de classification de sklearn
y_true = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10 # Simuler les étiquettes réelles
y_pred = [0, 1, 2, 3, 4, 5, 6, 7, 8, 8] * 10 # Simuler les prédictions
report = classification_report(y_true, y_pred, digits=4)
print(report)
4. Planification du taux d'apprentissage
Le taux d'apprentissage est l'un des hyperparamètres les plus importants pour l'entraînement des modèles d'apprentissage profond. Une planification appropriée du taux d'apprentissage peut considérablement améliorer l'efficacité de l'entraînement.
4.1 Stratégies de planification du taux d'apprentissage
| Stratégie | Description | Scénarios applicables |
|---|---|---|
| StepLR | Décroissance à pas fixe | Lorsque le taux d'apprentissage optimal est connu |
| MultiStepLR | Décroissance aux époques spécifiées | Décroissance non uniforme |
| CosineAnnealingLR | Décroissance cosinusoïdale | Convergence en douceur |
| ReduceLROnPlateau | Décroissance lorsque la perte de validation cesse de diminuer | Réglage automatique |
| Préchauffage | Augmenter d'abord, puis diminuer | Stabiliser l'entraînement précoce |
4.2 Implémentation de la planification du taux d'apprentissage
Exemple
import torch.optim as optim
import matplotlib.pyplot as plt
# Simuler les époques d'entraînement
époques = 50
# 1. Step LR : réduire de moitié toutes les 10 époques
scheduler_step = optim.lr_scheduler.StepLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
step_size=10, gamma=0.5
)
# 2. MultiStep LR : réduire aux époques spécifiées
scheduler_multistep = optim.lr_scheduler.MultiStepLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
milestones=[15, 30, 45], gamma=0.1
)
# 3. Recuit cosinus
scheduler_cosine = optim.lr_scheduler.CosineAnnealingLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
T_max=50
)
# 4. ReduceLROnPlateau
scheduler_plateau = optim.lr_scheduler.ReduceLROnPlateau(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
mode='min', factor=0.5, patience=5
)
# Tracer les courbes de taux d'apprentissage
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
# LR par étapes
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler_step.step()
axes[0, 0].plot(lr_history)
axes[0, 0].set_title('LR par paliers')
# Réinitialiser
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[15, 30, 45], gamma=0.1)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[0, 1].plot(lr_history)
axes[0, 1].set_title('LR multi-paliers')
# Cosinus
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[1, 0].plot(lr_history)
axes[1, 0].set_title('LR avec recuit cosinus')
# Échauffement + Cosinus
def warmup_cosine(optimizer, warmup_epochs, total_epochs, min_lr=1e-6):
def lr_lambda(epoch):
if epoch < warmup_epochs:
return epoch / warmup_epochs
return min_lr + 0.5 * (1 - min_lr) * (1 + np.cos(np.pi * (epoch - warmup_epochs) / (total_epochs - warmup_epochs)))
return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = warmup_cosine(optimizer, warmup_epochs=5, total_epochs=50)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[1, 1].plot(lr_history)
axes[1, 1].set_title('Échauffement + Cosinus')
for ax in axes.flat:
ax.set_xlabel('Époque')
ax.set_ylabel('Taux d'apprentissage')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
5. Diagnostic des problèmes de gradient
5.1 Disparition et explosion du gradient
import torch.nn as nn
def analyze_gradients(model):
"""
Analyser les gradients de chaque couche du modèle
"""
grad_stats = {}
for name, param in model.named_parameters():
if param.grad is not None:
grad = param.grad
grad_stats[name] = {
'mean': grad.mean().item(),
'std': grad.std().item(),
'max': grad.abs().max().item(),
'min': grad.abs().min().item(),
'norm': grad.norm().item(),
}
return grad_stats
def detect_gradient_issues(model):
"""
Détecter les problèmes de gradient
"""
tickets = []
grad_norms = []
for param in model.parameters():
if param.grad is not None:
grad_norms.append(param.grad.norm().item())
avg_grad_norm = sum(grad_norms) / len(grad_norms) if grad_norms else 0
if avg_grad_norm < 1e-7:
issues.append("Disparition du gradient : les gradients sont trop petits, le modèle peut être incapable d'apprendre")
elif avg_grad_norm > 100:
issues.append("Explosion du gradient : les gradients sont trop grands, l'entraînement est instable")
return issues, avg_grad_norm
# Exemple : détection de gradients
model = nn.Sequential(
nn.Linear(100, 50),
nn.ReLU(),
nn.Linear(50, 50),
nn.ReLU(),
nn.Linear(50, 10)
)
# Simuler la propagation avant et la rétropropagation
x = torch.randn(32, 100)
y = model(x)
loss = y.sum()
loss.backward()
issues, avg_norm = detect_gradient_issues(model)
print(f"Norme moyenne du gradient: {avg_norm:.6f}")
if issues:
for issue in issues:
print(f"Avertissement: {issue}")
else:
print("L'état du gradient est normal")
5.2 Écrêtage du gradient
Exemple
import torch.nn as nn
import torch.optim as optim
import torch.nn.utils as utils
# Exemple d'écrêtage du gradient
def train_with_gradient_clipping(model, dataloader, max_norm=1.0):
"""
Entraîner avec écrêtage du gradient
max_norm: norme maximale du gradient; les gradients dépassant cette valeur seront écrêtés
"""
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
model.train()
for inputs, labels in dataloader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
# Écrêtage du gradient : éviter l'explosion du gradient
utils.clip_grad_norm_(model.parameters(), max_norm=max_norm)
optimizer.step()
return model
# Écrêtage élément par élément (plus conservateur)
def clip_grad_by_value(model, clip_value=1.0):
"""
Écrêter les gradients par valeur
"""
for param in model.parameters():
if param.grad is not None:
param.grad.data.clamp_(min=-clip_value, max=clip_value)
6. Analyse des performances du modèle
6.1 Calcul du nombre de paramètres et des FLOPs
Exemple
import torch.nn as nn
from thop import profile
def count_parameters(model):
"""Calcule le nombre de paramètres entraînables dans le modèle"""
total = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
return total, trainable
def count_flops(model, input_size=(1, 3, 224, 224)):
"""Calculer les FLOPs (nécessite la bibliothèque thop)"""
input_tensor = torch.randn(input_size)
flops, params = profile(model, inputs=(input_tensor,), verbose=False)
return flops, params
# Exemple : analyser le modèle
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(256, 10)
)
total, trainable = count_parameters(model)
print(f"Nombre total de paramètres : {total:,}")
print(f"Paramètres entraînables : {trainable:,}")
print(f"Taille du modèle : {total * 4 / 1024 / 1024:.2f} MB")
# Calcul des FLOPs
try:
flops, _ = count_flops(model)
print(f"FLOPs : {flops / 1e9:.2f} G")
except ImportError:
print("Veuillez installer la bibliothèque thop : pip install thop")
6.2 Test de vitesse d'inférence
import time
def measure_inference_speed(model, input_size, device='cuda', num_iterations=100):
"""
Mesurer la vitesse d'inférence
"""
model.eval()
model = model.to(device)
# Échauffement
dummy_input = torch.randn(input_size).to(device)
with torch.no_grad():
for _ in range(10):
_ = model(dummy_input)
# Chronométrage
start = time.time()
with torch.no_grad():
for _ in range(num_iterations):
_ = model(dummy_input)
if device == 'cuda':
torch.cuda.synchronize()
end = time.time()
avg_time = (end - start) / num_iterations * 1000 # ms
return avg_time
# Exemple d'utilisation
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(64, 10)
)
# Vitesse d'inférence CPU
cpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cpu')
print(f"Temps d'inférence CPU : {cpu_time:.2f} ms/image")
# Vitesse d'inférence GPU (si CUDA est disponible)
if torch.cuda.is_available():
gpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cuda')
print(f"Temps d'inférence GPU : {gpu_time:.2f} ms/image")
6.3 Analyse de l'utilisation de la mémoire
Exemple
def analyze_memory(model, input_size):
"""
Analyser l'utilisation de la mémoire du modèle
"""
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# Créer une entrée
x = torch.randn(input_size).to(device)
# Vider le cache
if torch.cuda.is_available():
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
# Propagation avant
with torch.no_grad():
output = model(x)
# Obtenir les statistiques de mémoire
if torch.cuda.is_available():
allocated = torch.cuda.memory_allocated() / 1024**2 # MB
reserved = torch.cuda.memory_reserved() / 1024**2
max_allocated = torch.cuda.max_memory_allocated() / 1024**2
print(f"Mémoire actuellement allouée : {allocated:.2f} MB")
print(f"Mémoire réservée : {reserved:.2f} MB")
print(f"Utilisation maximale : {max_allocated:.2f} MB")
else:
print("Support CUDA requis")
return output
# Exemple d'utilisation
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
)
analyze_memory(model, (8, 3, 224, 224))
7. Problèmes courants et conseils de débogage
7.1 Référence rapide pour les problèmes d'entraînement
| Symptôme | Cause possible | Solution |
|---|---|---|
| La perte ne diminue pas | Taux d'apprentissage trop petit/grand, problèmes de gradient | Ajuster le taux d'apprentissage, vérifier les gradients |
| Oscillation de la perte | Taux d'apprentissage trop grand, taille de lot trop petite | Diminuer le taux d'apprentissage, augmenter la taille du lot |
| NaN apparaît | Division par zéro, log(0), explosion du gradient | Ajouter epsilon, écrêtage des gradients |
| Surapprentissage | Modèle complexe, données insuffisantes | Ajouter plus de données, ajouter de la régularisation |
| Sous-apprentissage | Modèle trop simple, entraînement insuffisant | Augmenter la taille du modèle, entraîner plus longtemps |
| Mémoire GPU insuffisante | Taille de lot importante, modèle volumineux | Réduire la taille du lot, accumulation de gradient |
7.2 Recueil d'astuces de débogage
Exemple
import random
import numpy as np
def set_seed(seed=42):
"""Définir la graine aléatoire pour garantir des résultats reproductibles"""
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def debug_forward(model, x):
"""Déboguer la propagation avant et vérifier les sorties de chaque couche"""
print("=" * 50)
print("Débogage de la propagation avant")
print("=" * 50)
for name, layer in model.named_children():
x = couche(x)
if hasattr(x, 'shape'):
print(f"{name}: forme={x.shape}, ", end='')
if hasattr(x, 'mean'):
print(f"moyenne={x.mean().item():.4f}, écart-type={x.std().item():.4f}")
if torch.isnan(x).any():
print(f" ⚠️ NaN détecté !")
if torch.isinf(x).any():
print(f" ⚠️ Inf détecté !")
print("=" * 50)
def debug_backward(model):
"""Déboguer la rétropropagation et vérifier les gradients"""
print("=" * 50)
print("Débogage de la rétropropagation")
print("=" * 50)
for name, param in model.named_parameters():
if param.grad is not None:
grad_norm = param.grad.norm().item()
if torch.isnan(param.grad).any():
print(f"{name}: ⚠️ Gradient NaN!")
elif torch.isinf(param.grad).any():
print(f"{name}: ⚠️ Gradient Inf!")
elif grad_norm > 10:
print(f"{name}: ⚠️ Explosion du gradient! norm={grad_norm:.2f}")
elif grad_norm < 1e-7:
print(f"{name}: ⚠️ Disparition du gradient! norm={grad_norm:.2e}")
else:
print(f"{name}: normal norm={grad_norm:.4f}")
print("=" * 50)
# Exemple d'utilisation
set_seed(42)
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 20),
nn.ReLU(),
nn.Linear(20, 5)
)
x = torch.randn(2, 10)
y = model(x)
debug_forward(model, x)
loss = y.sum()
loss.backward()
debug_backward(model)
8. Utilisation de PyTorch Profiler
PyTorch Profiler est l'outil officiel d'analyse de performance qui peut analyser la consommation de temps et l'utilisation de la mémoire de chaque partie du modèle.
8.1 Utilisation de base du profileur
Exemple
import torch.nn as nn
from torch.profiler import profile, ProfilerActivity, schedule
# Modèle simple
model = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(64, 10)
).cuda()
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()
# Utiliser le profileur
with profile(
activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
schedule=schedule(wait=1, warmup=1, active=3, repeat=1),
on_trace_ready=torch.profiler.tensorboard_trace_handler('./logs'),
record_shapes=True,
profile_memory=True,
with_stack=True
) as prof:
for step in range(5):
inputs = torch.randn(8, 3, 224, 224).cuda()
labels = torch.randint(0, 10, (8,)).cuda()
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
prof.step()
# Afficher les résultats
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
8.2 Visualisation des résultats du profileur
Exemple
# Le répertoire ./logs généré peut être ouvert et consulté dans le navigateur Chrome
# Ou afficher directement diverses métriques
print("=" * 80)
print("CPU Time Top 10:")
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
print("\n" + "=" * 80)
print("Top 10 des temps CUDA:")
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
print("\n" + "=" * 80)
print("Utilisation mémoire Top 10:")
print(prof.key_averages().table(sort_by="self_cuda_memory_usage", row_limit=10))