CSC 8607 – Introduction au deep learning

• un GPU : --gres=gpu:1
• 2 CPUs pour la tâche : --cpus-per-task=2
• 8 Go de RAM : --mem=8G
• 1 heure : --time=1:00:00
• un pseudo-terminal bash : --pty bash

1. Réservez une allocation pendant 20 minutes avec 1 GPU, 2 CPUs et 8 Go de RAM :
   salloc --time=0:20:00 --gres=gpu:1 --cpus-per-task=2 --mem=8G
2. À l’intérieur de cette allocation, lancez un shell interactif :
   srun --pty bash
   Vérifiez le GPU avec nvidia-smi, puis quittez le shell (exit).
3. Toujours dans la même allocation, lancez une autre commande courte (ex. hostname ou python -c "print('ok')") avec srun.
4. Terminez l’allocation en tapant exit (ou scancel sur l’ID de l’allocation).

• Où la sortie standard et les erreurs ont-elles été écrites ?
• Quel est le nom exact des fichiers de log créés (indice : %x-%j) ?
• Affichez leur contenu et vérifiez la présence du message Bonjour et/ou de la sortie nvidia-smi.

1. Lancez un job interactif court (ou soumettez un petit job avec sbatch, cf. question suivante).
2. Pendant l’exécution, affichez les détails :
   scontrol show job MON_JOB_ID | less
   Repérez le nœud d’exécution et les ressources allouées.
3. Une fois le job terminé, consultez l’historique :
   sacct -j MON_JOB_ID --format=JobID,State,Elapsed,MaxRSS,ReqMem,ReqCPUS,AllocTRES
   Question : quelle RAM réelle (MaxRSS) a été consommée par rapport à la mémoire demandée (--mem) ?

Depuis votre machine → vers le cluster (ex. copier mnist.zip dans ~/data/) :

Depuis le cluster → vers votre machine (ex. récupérer des résultats) :

Synchroniser un dossier (pratique pour des lots de fichiers) :

• Observation/gestion : squeue -u $USER, scancel JOBID, scontrol show job JOBID, sacct -j JOBID --format=JobID,State,Elapsed,MaxRSS,ReqMem,ReqCPUS,AllocTRES
• Interactif : srun --time=HH:MM:SS --gres=gpu:K --cpus-per-task=N --mem=XXG --pty bash
• Allocation : salloc ... puis enchaîner des srun à l’intérieur
• Batch : sbatch script.sh avec en-tête #SBATCH (--gres, --cpus-per-task, --mem, -t, -J, -o, -e)
• Diagnostics rapides : nvidia-smi (GPU), htop (CPU/mémoire)
• Transferts : scp ... tsp-client:~/..., rsync -avhP ...
• Éthique d’usage : n’accaparez pas les ressources (--cpus-per-task, --mem) ; libérez vos jobs inutiles ; consignez vos résultats dans des logs.

Exécutez :

Répondez yes lorsqu’une question vous demande une confirmation. Déconnectez-vous de SSH puis reconnectez-vous.

Vous devriez maintenant pouvoir exécuter mamba. Si ce n’est pas le cas, ajoutez à ~/.bash_profile :

En cas de besoin extrême : source ~/miniforge3/etc/profile.d/conda.sh && conda activate.

Créez un environnement dédié au cours (ici avec Python 3.10) :

mamba create -n deeplearning python=3.10

Activez l’environnement nouvellement créé :

mamba activate deeplearning

Vous devrez toujours activer cet environnement avant de travailler sur le TP.

Deux méthodes possibles. Choisissez-en une (méthode A recommandée si vous utilisez Mamba). Dans les deux cas, il n’est pas nécessaire d’installer manuellement le toolkit CUDA système : la distribution fournie par PyTorch embarque ce qu’il faut, à condition de choisir la bonne variante GPU.

Demandez d’abord un GPU via Slurm (srun --gres=gpu:1 --cpus-per-task=2 --mem=8G --time=0:30:00 --pty bash), puis activez l’environnement et lancez Python :

Si torch.cuda.is_available() est True, votre installation est prête à utiliser un GPU.

Exportez la “recette” minimale de votre environnement :

Affichez environment.yml, vérifiez que vous avez bien trois channels (conda-forge, pytorch, nvidia), puis recréez (en test) un environnement à partir de ce fichier (facultatif) :

Quelle commande affiche la version de TensorBoard installée ?

Dessinez un perceptron multicouche (MLP) avec :

• Une couche d’entrée avec 3 neurones
• Une couche cachée avec 4 neurones
• Une couche de sortie avec 2 neurones

Combien de paramètres possède ce modèle sans prendre en compte les biais ?

Même question en incluant les biais. Combien de paramètres au total ?

Écrivez les équations du forward pass en notation matricielle pour notre exemple. On utilise ReLU comme activation cachée. Donnez les dimensions de X, W1, b1, W2, b2, et de la sortie Y.

Écrivez les équations du forward pass pour un batch d’exemples X de taille N×3. Indiquez soigneusement les dimensions et comment les biais se diffusent (broadcast).

Quelle est la principale différence entre un perceptron simple et un perceptron multicouche ?

Pourquoi utilisons-nous la règle de la chaîne pour calculer les gradients dans la rétropropagation ?

Écrivez le graphe de calcul pour la fonction f(x, y, z) = x / y + z. Identifiez les nœuds intermédiaires et les gradients locaux. Que se passe-t-il si y = 0 ?

Effectuez le forward pass dans ce graphe de calcul avec x = 2, y = 4, z = 0.

Effectuez maintenant la backpropagation pour calculer les gradients de f en ces points.

Effectuez une étape de descente de gradient avec un learning rate η = 1. Quelles sont les nouvelles valeurs de x, y, et z ? La sortie a-t-elle diminué ?

Quelles sont les principales raisons d'utiliser des batchs plutôt que l’ensemble des données ou un seul exemple à la fois ?

(Mini preuve) Soient deux exemples (x₁,y₁) et (x₂,y₂). Montrez que le gradient sur le mini-batch de taille 2 est la moyenne des gradients individuels. Pourquoi cela réduit-il la variance du gradient ?

Associez sortie et fonction de perte usuelles :

• Classification binaire
• Classification multi-classes
• Régression

Tracez les courbes des fonctions d’activation suivantes et de leurs dérivées :

• ReLU
• Sigmoid
• Tanh

Indiquez les zones de saturation et la valeur de la dérivée dans ces zones.

(Pour les plus avancés en maths) Soit une couche linéaire ŷ = W·a + b et la perte L = (1/2)‖y − ŷ‖². Exprimez ∂L/∂W, ∂L/∂b et ∂L/∂a (formes vectorisées).

(Vérification numérique) Vérifiez numériquement ∂f/∂x pour f(x,y,z)=x/y+z en utilisant les différences finies : (f(x+ε,y,z) − f(x,y,z))/ε avec ε petit (ex. 1e-5). Que trouvez-vous ?

Téléchargez et chargez le dataset CIFAR-10 avec une normalisation canonique :

import os
import torch
import torchvision
from torchvision import transforms, datasets

# Normalisation "classique" pour CIFAR-10
CIFAR10_MEAN = (0.4914, 0.4822, 0.4465)
CIFAR10_STD  = (0.2023, 0.1994, 0.2010)

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(CIFAR10_MEAN, CIFAR10_STD),
])

trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
testset  = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

# Ne pas monopoliser les CPUs : on borne num_workers
def get_num_workers(default=2, cap=4):
    try:
        n = int(os.getenv("SLURM_CPUS_PER_TASK", default))
    except Exception:
        n = default
    return max(0, min(cap, n))

num_workers = get_num_workers()

trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=32, shuffle=True, num_workers=num_workers, pin_memory=True
)
testloader = torch.utils.data.DataLoader(
    testset, batch_size=32, shuffle=False, num_workers=num_workers, pin_memory=True
)

Configurez l’entraînement, avec un suivi de la perte et d’une accuracy d’époque. Ajoutez des graines (seeds) pour un minimum de reproductibilité.

import random
torch.manual_seed(0)
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(0)
random.seed(0)

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")
if device == "cpu":
    print("Astuce: pour le GPU, demandez une alloc Slurm (ex: srun --gres=gpu:1 ...)")

model = MLP().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# BONUS facultatif (AMP) : précision mixte pour accélérer/économiser de la mémoire sur GPU
use_amp = (device == "cuda")
scaler = torch.amp.GradScaler('cuda', enabled=use_amp)

EPOCHS = 10
for epoch in range(EPOCHS):
    model.train()
    running_loss = 0.0
    running_correct = 0
    running_total = 0

    for inputs, labels in trainloader:
        # Transferts accélérés si pin_memory=True
        inputs = inputs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        optimizer.zero_grad(set_to_none=True)

        if use_amp:
            with torch.cuda.amp.autocast():
                outputs = model(inputs)
                loss = criterion(outputs, labels)
        else:
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        if use_amp:
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
        else:
            loss.backward()
            optimizer.step()

        running_loss += loss.item() * inputs.size(0)
        preds = outputs.argmax(dim=1)
        running_correct += (preds == labels).sum().item()
        running_total   += labels.size(0)

    epoch_loss = running_loss / running_total
    epoch_acc  = running_correct / running_total
    print(f"Epoch {epoch+1:02d} | loss={epoch_loss:.4f} | acc={epoch_acc:.4f}")

Sanity check (diagnostic rapide) : essayez de sur-ajuster (overfit) un petit sous-ensemble (p.ex. 512 images). La perte doit chuter et l’accuracy approcher 100% si le pipeline est correct.

from torch.utils.data import Subset
small_idx = list(range(512))
small_train = Subset(trainset, small_idx)
small_loader = torch.utils.data.DataLoader(
    small_train, batch_size=32, shuffle=True, num_workers=num_workers, pin_memory=True
)
# Ré-entraînez 3-5 epochs sur small_loader et observez loss/acc.

Évaluez le modèle (accuracy globale), puis optionnel : accuracy par classe.

model.eval()
classes = trainset.classes  # noms des classes CIFAR-10

total = 0
correct = 0
per_class_total = [0]*len(classes)
per_class_correct = [0]*len(classes)

with torch.no_grad():
    for images, labels in testloader:
        images = images.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        total   += labels.size(0)
        correct += (predicted == labels).sum().item()

        for c in range(len(classes)):
            idx = (labels == c)
            per_class_total[c]  += idx.sum().item()
            per_class_correct[c]+= (predicted[idx] == c).sum().item()

acc = correct / total
print(f"Test accuracy: {acc:.3f}")

# Option : accuracy par classe
for c, name in enumerate(classes):
    if per_class_total[c] > 0:
        print(f"{name:>10s} : {per_class_correct[c]/per_class_total[c]:.3f}")

Sauvegardez le modèle après l’entraînement, puis rechargez-le (y compris sur CPU si besoin) :

# Sauvegarde des poids
torch.save(model.state_dict(), "mlp_model.pth")

# Recréation du modèle et chargement (sur CPU, par ex.)
model2 = MLP().to("cpu")
state = torch.load("mlp_model.pth", map_location="cpu")
model2.load_state_dict(state)
model2.eval()  # avant l'inférence

Créez un dossier de run lisible (timestamp + hyperparamètres clés). Cela facilite la comparaison de plusieurs expériences :

import os, random, datetime, torch

# Hyperparamètres (exemple) — adaptez aux vôtres
hparams = dict(model="MLP", batch_size=32, lr=1e-2, seed=0, weight_decay=0.0)

run_name = f"{hparams['model'].lower()}/bs{hparams['batch_size']}_lr{hparams['lr']}_wd{hparams['weight_decay']}_{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
logdir = os.path.join("runs", run_name)
print("Logdir:", logdir)

Créez un split validation et définissez une fonction qui calcule des moyennes par époque (perte/accuracy) — pas la perte du dernier batch.

from torch.utils.data import random_split, DataLoader

# On part du trainset de l'exercice précédent (déjà normalisé)
N = len(trainset)
val_size = int(0.1 * N)
train_size = N - val_size
train_subset, val_subset = random_split(trainset, [train_size, val_size], generator=torch.Generator().manual_seed(0))

def get_num_workers(default=2, cap=4):
    import os
    try:
        n = int(os.getenv("SLURM_CPUS_PER_TASK", default))
    except Exception:
        n = default
    return max(0, min(cap, n))

num_workers = get_num_workers()

trainloader = DataLoader(train_subset, batch_size=hparams["batch_size"], shuffle=True,
                         num_workers=num_workers, pin_memory=True)
valloader   = DataLoader(val_subset,   batch_size=hparams["batch_size"], shuffle=False,
                         num_workers=num_workers, pin_memory=True)

device = "cuda" if torch.cuda.is_available() else "cpu"
model = MLP().to(device)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=hparams["lr"], momentum=0.9, weight_decay=hparams["weight_decay"])

# Reproductibilité minimale
torch.manual_seed(hparams["seed"])
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(hparams["seed"])
random.seed(hparams["seed"])

# ---> Moyennes par époque (perte et accuracy) 

Initialisez SummaryWriter, loggez au batch (pas trop souvent) et à l’époque, et ajoutez le graphe du modèle une seule fois.

from torch.utils.tensorboard import SummaryWriter
from torchvision.utils import make_grid

writer = SummaryWriter(log_dir=logdir)

# Facultatif : graphe du modèle (peut être lourd)
try:
    sample_input = torch.randn(1, 3, 32, 32, device=device)
    writer.add_graph(model, sample_input)
except Exception as e:
    print("add_graph a été ignoré :", e)

EPOCHS = 10
global_step = 0

for epoch in range(1, EPOCHS + 1):
    model.train()
    running_loss_sum, running_total = 0.0, 0

    for b, (x, y) in enumerate(trainloader):
        x = x.to(device, non_blocking=True); y = y.to(device, non_blocking=True)
        optimizer.zero_grad(set_to_none=True)
        logits = model(x)
        loss = criterion(logits, y)
        loss.backward()

        # Logging batch (toutes les ~10 itérations)
        if b % 10 == 0:
            writer.add_scalar("Loss/train_step", loss.item(), global_step)

        optimizer.step()

        running_loss_sum += loss.item() * y.size(0)
        running_total    += y.size(0)
        global_step += 1

    # Fin d'époque : métriques train/val avec moyennes
    train_loss = running_loss_sum / running_total
    val_loss, val_acc = epoch_metrics(valloader)

    writer.add_scalar("Loss/train", train_loss, epoch)
    writer.add_scalar("Loss/val",   val_loss,   epoch)
    writer.add_scalar("Accuracy/val", val_acc,  epoch)

    # Histogrammes 1×/5 époques pour limiter l'IO
    if epoch % 5 == 0:
        for name, p in model.named_parameters():
            writer.add_histogram(f"weights/{name}", p.data, epoch)
            if p.grad is not None:
                writer.add_histogram(f"grads/{name}", p.grad, epoch)

    # Enregistrer les hyperparamètres + métriques d'époque (option : à la dernière époque seulement)
    if epoch == EPOCHS:
        writer.add_hparams(hparams, {"final_val_accuracy": float(val_acc), "final_val_loss": float(val_loss)})

    writer.flush()
    print(f"Epoch {epoch:02d} | train_loss={train_loss:.4f} | val_loss={val_loss:.4f} | val_acc={val_acc:.3f}")

Installez Matplotlib dans votre environnement pour les figures :

# Avec mamba (recommandé) :
mamba install -c conda-forge matplotlib

# Ou avec pip :
pip install matplotlib

Après chaque époque, ajoutez quelques images mal classées (dé-normalisées) et une matrice de confusion (validation) :

import matplotlib.pyplot as plt
import numpy as np

CIFAR10_MEAN = (0.4914, 0.4822, 0.4465)
CIFAR10_STD  = (0.2023, 0.1994, 0.2010)
classes = trainset.classes

def denorm(imgs, mean=CIFAR10_MEAN, std=CIFAR10_STD):
    m = torch.tensor(mean, device=imgs.device).view(1, -1, 1, 1)
    s = torch.tensor(std,  device=imgs.device).view(1, -1, 1, 1)
    return (imgs * s + m).clamp(0, 1)

@torch.no_grad()
def misclassified_batch(loader, max_images=32):
    model.eval()
    wrong_x, wrong_y, wrong_p = [], [], []
    for x, y in loader:
        x = x.to(device, non_blocking=True); y = y.to(device, non_blocking=True)
        pred = model(x).argmax(1)
        mask = (pred != y)
        if mask.any():
            idx = torch.nonzero(mask).squeeze(1)
            for i in idx:
                wrong_x.append(x[i].cpu()); wrong_y.append(int(y[i].cpu())); wrong_p.append(int(pred[i].cpu()))
                if len(wrong_x) >= max_images: break
        if len(wrong_x) >= max_images: break
    if not wrong_x: return None, None, None
    return torch.stack(wrong_x), wrong_y, wrong_p

@torch.no_grad()
def confusion_matrix_torch(loader, num_classes=10):
    model.eval()
    cm = torch.zeros(num_classes, num_classes, dtype=torch.int64)
    for x, y in loader:
        x = x.to(device, non_blocking=True); y = y.to(device, non_blocking=True)
        pred = model(x).argmax(1)
        for t, p in zip(y.view(-1), pred.view(-1)):
            cm[int(t), int(p)] += 1
    return cm

# À placer en fin d'époque (après les scalaires) :
wrong = misclassified_batch(valloader, max_images=32)
if wrong[0] is not None:
    imgs = denorm(wrong[0])
    grid = make_grid(imgs, nrow=8)
    writer.add_image("Val/Misclassified", grid, epoch)
    writer.add_text("Val/Misclassified_labels",
                    "true|pred : " + ", ".join(f"{classes[t]}|{classes[p]}" for t,p in list(zip(wrong[1], wrong[2]))[:16]),
                    epoch)

cm = confusion_matrix_torch(valloader, num_classes=len(classes)).numpy()
fig = plt.figure(figsize=(5,5))
plt.imshow(cm, interpolation="nearest", cmap="Blues")
plt.title("Confusion Matrix (val)")
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45, ha="right")
plt.yticks(tick_marks, classes)
plt.xlabel("Pred"); plt.ylabel("True")
plt.tight_layout()
writer.add_figure("Val/ConfusionMatrix", fig, epoch)
plt.close(fig)

Évaluez une seule fois sur l’ensemble de test, puis enregistrez hyperparamètres et résultats finaux.

test_loss, test_acc = epoch_metrics(testloader)
writer.add_scalar("Loss/test", test_loss, EPOCHS)
writer.add_scalar("Accuracy/test", test_acc, EPOCHS)
writer.add_hparams(hparams, {"final_test_accuracy": float(test_acc), "final_test_loss": float(test_loss)})
writer.flush(); writer.close()
print(f"TEST — loss={test_loss:.4f} acc={test_acc:.3f}")

Transférez les logs depuis le serveur vers votre machine (via votre configuration ~/.ssh/config) :

scp -r tsp-client:~/runs ./runs

Installez TensorBoard sur votre machine (pip install tensorboard) puis lancez :

tensorboard --logdir=runs

Ouvrez l’URL indiquée (généralement http://localhost:6006) et vérifiez vos graphes.

(Option) Lancer TensorBoard sur le serveur et y accéder par tunnel SSH :

# Sur le serveur :
tensorboard --logdir=~/runs --port 6006 --bind_all

# En local (grâce à votre ~/.ssh/config) :
ssh -L 6006:localhost:6006 tsp-client
# Puis ouvrez http://localhost:6006

Où trouver les hyperparamètres (HParams) ? Ouvrez TensorBoard, identifiez l’onglet HParams. Que voyez-vous si vous avez bien appelé writer.add_hparams(...) ?

Scalars : où ajuste-t-on l’axe X (Step / Relative / Wall) et la smoothing ? Testez plusieurs valeurs.

Pourquoi observe-t-on autant de bruit sur Loss/train_step ? Et pourquoi Loss/train (par époque) est-elle plus lisse ?

Comparaison de runs : dans Scalars, sélectionnez plusieurs runs (cases à cocher à gauche). Que permet le filtre par expression régulière (champ Filter) ?

Images, Histogrammes, Graph, Projector : où retrouve-t-on les images mal classées, les histogrammes de poids/gradients, le graphe du modèle et les embeddings ?

Lancez au moins 3 runs avec des hyperparamètres différents (modifiez hparams avant chaque entraînement) :

• LR ∈ {1e-1, 1e-2, 1e-3}
• batch_size ∈ {32, 128}
• weight_decay ∈ {0.0, 5e-4}

Comparez Loss/val et Accuracy/val dans TensorBoard. Lequel gagne ?

Détectez un sur-apprentissage dans TensorBoard : quels motifs observez-vous sur Loss/train vs Loss/val et sur Accuracy/val ?

Si vous constatez beaucoup de bruit sur Loss/train_step, citez 3 façons de le réduire sans tricher sur l’évaluation.