É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 matplotlib.pyplot as plt
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 matplotlib.pyplot as plt
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
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 torch
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

import numpy as np

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

from sklearn.metrics import classification_report

# 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
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

< h2 class="example">Exemple
import torch
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
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
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

< h2 class="example">Exemple
import torch
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

import torch

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 torch
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" &#x26a0;&#xfe0f; NaN détecté !")
            if torch.isinf(x).any():
                print(f" &#x26a0;&#xfe0f; 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}: &#x26a0;&#xfe0f; Gradient NaN!")
            elif torch.isinf(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; Gradient Inf!")
            elif grad_norm > 10:
                print(f"{name}: &#x26a0;&#xfe0f; Explosion du gradient! norm={grad_norm:.2f}")
            elif grad_norm < 1e-7:
                print(f"{name}: &#x26a0;&#xfe0f; 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
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

# Exporter le fichier de trace Chrome
# 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))
Autres extensions