🔥 PyTorch – Le Framework Deep Learning "Pythonic"

PyTorch (PT) et TensorFlow (TF) sont les deux leaders. Le choix dépend souvent de la préférence et de l'objectif.

L'installation de PyTorch (surtout avec GPU) nécessite une commande pip spécifique, liée à votre version de CUDA.

Règle N°1 : Toujours utiliser le "Wizard" (assistant) sur le site pytorch.org.

# 1. (Recommandé) Créer un environnement virtuel
python -m venv torch_env
source torch_env/bin/activate

# 2. Installer PyTorch (avec support CUDA 12.1)
# (Cette commande inclut PyTorch, TorchVision (images)
# et TorchAudio (audio)
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# (Exemple pour CPU uniquement)
# pip3 install torch torchvision torchaudio

# Lancer 'python'
import torch

# 1. Vérifier la version
print(torch.__version__)

# 2. VÉRIFICATION GPU (LA PLUS IMPORTANTE)
# (Doit retourner True si CUDA est OK)
is_cuda = torch.cuda.is_available()
print(f"CUDA disponible: {is_cuda}")

if is_cuda:
    # (Nom de votre carte GPU)
    print(f"Nom GPU: {torch.cuda.get_device_name(0)}")

Le **Tensor** (torch.Tensor) est l'unité de donnée centrale de PyTorch. C'est un tableau multi-dimensionnel, très similaire à un ndarray de NumPy.

import torch
import numpy as np

# 1. Création
# (Directe)
t1 = torch.tensor([[1, 2], [3, 4]]) # (Type: int64)
t2 = torch.tensor([[1., 2.], [3., 4.]]) # (Type: float32)

# (Aléatoire)
t_rand = torch.rand(3, 3) # (Shape 3x3, 0 à 1)
t_zeros = torch.zeros(2, 2)

# 2. NumPy <-> PyTorch (Interopérabilité)
# (Partagent la même mémoire, très rapide)
np_arr = np.array([1, 2])
t_from_np = torch.from_numpy(np_arr)

t_tensor = torch.tensor([3, 4])
np_from_t = t_tensor.numpy()

# 3. Attributs
print(t1.shape) # torch.Size([2, 2])
print(t1.dtype) # torch.int64
print(t1.device) # 'cpu' (par défaut)

L'API des opérations est conçue pour ressembler à NumPy.

a = torch.tensor([[1, 2], [3, 4]])
b = torch.tensor([[5, 6], [7, 8]])

# 1. Addition (Element-wise)
c1 = a + b 
c2 = torch.add(a, b)

# 2. Multiplication (Element-wise)
d = a * b

# 3. Multiplication de Matrices (Dot product)
e1 = a @ b
e2 = torch.matmul(a, b)

# 4. Broadcasting
# (Le scalaire 2 est "étiré")
f = a * 2 
# [[2, 4], [6, 8]]

torch.autograd est le moteur de PyTorch pour la différenciation automatique (le calcul des gradients).

Si un Tensor (ex: les poids d'un modèle) a requires_grad=True, PyTorch va **enregistrer** (tracker) toutes les opérations effectuées dessus pour construire un graphe de calcul dynamique.

# x = Poids (Paramètre)
# On veut calculer le gradient de 'y' par rapport à 'x'
x = torch.tensor(3.0, requires_grad=True)

# y = Donnée (Input)
# (Pas besoin de gradient pour les inputs)
y = torch.tensor(2.0, requires_grad=False)

# z = x^2 * y
z = (x * x) * y

# (PyTorch a construit un graphe: z -> * -> y
#                                   -> * -> x
#                                      -> x)
print(z.requires_grad) # True (car 'x' l'a demandé)

Une fois la sortie (loss) calculée, on appelle .backward() sur cette sortie. Autograd remonte alors le graphe (backpropagation) et accumule les gradients dans l'attribut .grad de chaque tensor qui avait requires_grad=True.

Exemple (suite de 2.2)

x = torch.tensor(3.0, requires_grad=True)
y = torch.tensor(2.0, requires_grad=False)
z = (x * x) * y # z = 18

# 1. Lancer la backpropagation (calculer les gradients)
z.backward()

# 2. Inspecter le gradient
# (dz/dx = 2*x*y = 2*3*2 = 12)
print(x.grad) # tensor(12.)

# (y n'avait pas requires_grad)
print(y.grad) # None

Important : Les gradients s'accumulent. C'est pourquoi on doit appeler optimizer.zero_grad() avant chaque .backward() dans la boucle d'entraînement.

Pour utiliser le GPU (CUDA), il faut explicitement déplacer les **tensors** ET le **modèle** sur le "device" (périphérique) GPU.

# 1. Définir le device (Bonne pratique)
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Utilisation de: {device}")

# 2. Déplacer un Tensor
x_cpu = torch.tensor([1, 2])
x_gpu = x_cpu.to(device)

print(x_cpu.device) # cpu
print(x_gpu.device) # cuda:0 (si GPU disponible)

# 3. Déplacer un Modèle
# (Ceci déplace tous les poids/paramètres du modèle)
model = MyModel()
model.to(device)

# 4. (Dans la boucle d'entraînement)
# (Les données DOIVENT être sur le même device que le modèle)
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)

torch.nn.Module est la classe de base pour **tous** les modèles de réseaux de neurones. On crée une classe Python qui hérite de nn.Module.

Deux méthodes sont cruciales :

• __init__(self) : On définit les couches (nn.Linear, nn.Conv2d...). Ce sont les couches qui ont des poids (requires_grad=True).
• forward(self, x) : On définit la logique du "forward pass" (comment les données x traversent les couches). (PyTorch gère le backward automatiquement).

Exemple (MLP simple)

import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
    
    # 1. Définir les couches (avec poids)
    def __init__(self):
        super(SimpleNet, self).__init__()
        # (Couche 1: 784 (input) -> 128 (hidden))
        self.fc1 = nn.Linear(784, 128)
        # (Couche 2: 128 (hidden) -> 10 (output))
        self.fc2 = nn.Linear(128, 10)
        
    # 2. Définir le "forward pass"
    def forward(self, x):
        # x shape: [batch_size, 784]
        
        # (Couche 1 + Activation ReLU)
        x = self.fc1(x)
        x = F.relu(x) # (ReLU n'a pas de poids, F.* est OK)
        
        # (Couche 2)
        x = self.fc2(x)
        
        # (Pas de Softmax ici, car CrossEntropyLoss
        # l'inclut pour la stabilité numérique)
        return x

# Instancier le modèle
model = SimpleNet()
print(model)

Pour les modèles qui sont une simple pile linéaire (comme dans l'exemple 3.1), PyTorch fournit nn.Sequential (similaire à Keras Sequential) pour éviter d'écrire une classe.

Exemple (MLP simple, équivalent 3.1)

import torch.nn as nn

# (Input: 784)
model = nn.Sequential(
    # (Couche 1: 784 -> 128)
    nn.Linear(784, 128),
    # (Activation)
    nn.ReLU(),
    
    # (Couche 2: 128 -> 10)
    nn.Linear(128, 10)
    
    # (Pas de Softmax, géré par CrossEntropyLoss)
)

print(model)

torch.nn (Modules) : Couches qui ont des poids (nn.Linear). Doivent être définies dans __init__.
torch.nn.functional (Fonctions) : Opérations qui n'ont pas de poids (F.relu). Peuvent être appelées dans forward.

La fonction de perte (ou "critère") mesure l'erreur entre la prédiction (outputs) et la vérité terrain (labels). C'est ce scalaire (loss) que l'on minimise.

# (Pour une classification à 10 classes)
criterion = nn.CrossEntropyLoss()

# (Dans la boucle d'entraînement)
outputs = model(inputs) # (Sorties 'logits', SANS softmax)
loss = criterion(outputs, labels) # (Calcule l'erreur)

# (Puis on appelle la backpropagation)
loss.backward()

L'optimiseur implémente l'algorithme de descente de gradient (ex: Adam, SGD). Son rôle est de mettre à jour les poids (model.parameters()) en utilisant les gradients (calculés par .backward()).

Exemple (Adam)

import torch.optim as optim

model = SimpleNet()
learning_rate = 0.001

# 1. Définir l'optimiseur
# (On lui passe les poids que l'on veut entraîner,
# et le 'learning rate')
optimizer = optim.Adam(
    model.parameters(),
    lr=learning_rate
)

# 2. Utilisation (dans la boucle d'entraînement)
# (Après loss.backward() ...)
optimizer.step()

# (Avant le prochain .backward() ...)
optimizer.zero_grad()

C'est la différence majeure avec Keras (.fit()). PyTorch demande d'écrire la boucle d'entraînement manuellement. C'est plus verbeux, mais 100% flexible.

Les 5 Étapes (par batch)

# (Objets déjà définis : model, dataloader, criterion, optimizer, device)

# Mettre le modèle en mode "entraînement" (active Dropout, etc.)
model.train()

for epoch in range(NUM_EPOCHS):
    running_loss = 0.0
    
    # (Boucle sur les 'batch' de données)
    for inputs, labels in dataloader:
        
        # (Déplacer les données sur GPU/CPU)
        inputs = inputs.to(device)
        labels = labels.to(device)
        
        # --- 1. Zéro: RAZ des gradients ---
        optimizer.zero_grad()
        
        # --- 2. Forward Pass: Prédire ---
        outputs = model(inputs)
        
        # --- 3. Loss: Calculer l'erreur ---
        loss = criterion(outputs, labels)
        
        # --- 4. Backward Pass: Calculer les gradients ---
        loss.backward()
        
        # --- 5. Step: Mettre à jour les poids ---
        optimizer.step()
        
        running_loss += loss.item()
        
    print(f"Epoch {epoch+1}, Loss: {running_loss / len(dataloader)}")

L'API torch.utils.data gère le chargement des données.

from torch.utils.data import Dataset

class MonDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets
        
    def __len__(self):
        return len(self.data)
        
    def __getitem__(self, idx):
        # (Retourne 1 échantillon)
        x = self.data[idx]
        y = self.targets[idx]
        return x, y

from torch.utils.data import DataLoader

# (Instancier le Dataset)
train_dataset = MonDataset(x_train, y_train)

# (Instancier le DataLoader)
train_loader = DataLoader(
    dataset=train_dataset,
    batch_size=32,
    shuffle=True, # (Mélanger à chaque epoch)
    num_workers=4 # (4 process pour charger)
)

# (Utilisation dans la boucle)
# for inputs, labels in train_loader:
#    ...

La bonne pratique PyTorch est de ne sauvegarder que le state_dict (un dictionnaire Python des poids/paramètres), et non le modèle entier. (Cela rend le code de chargement indépendant des fichiers d'origine).

# (Après l'entraînement...)
PATH = "mon_modele.pth"

# (Sauvegarde le dictionnaire de Poids)
torch.save(model.state_dict(), PATH)

PATH = "mon_modele.pth"

# 1. Ré-instancier l'architecture
# (Doit être la *même* classe qu'à l'entraînement)
model = SimpleNet() 

# 2. Charger les poids
model.load_state_dict(torch.load(PATH))

# 3. Mode ÉVALUATION (TRÈS IMPORTANT)
# (Désactive Dropout, BatchNorm, etc.)
model.eval()

# 4. Inférence (sans gradients)
with torch.no_grad():
    input_test = torch.rand(1, 784)
    prediction = model(input_test)

PyTorch comble son retard sur TensorFlow en matière de déploiement "end-to-end".

PyTorch domine le monde de la **Recherche & Développement** et est la base des modèles "state-of-the-art" (SOTA), notamment en NLP.

Ressources pour apprendre et travailler avec PyTorch.