PyTorch : Construis ton premier réseau de neurones en 30 minutes

Tu veux faire du deep learning mais tu ne sais pas par où commencer ? Tu as entendu parler de TensorFlow, Keras, PyTorch et tu es perdu dans la jungle des frameworks ? Ce tutoriel est fait pour toi. On va prendre PyTorch — le framework le plus utilisé en recherche et dans l'industrie — et construire ensemble ton premier réseau de neurones, de A à Z, avec du code que tu peux copier-coller. Pas de jargon inutile, pas de maths intimidantes. Juste du concret.

Pourquoi PyTorch ?

PyTorch est aujourd'hui le standard de facto du deep learning. Développé par Meta (Facebook), il est utilisé par OpenAI, Tesla, DeepMind et des milliers de chercheurs. Ses trois forces :

• La syntaxe Python native : tu écris du Python, pas un DSL exotique
• Le calcul dynamique : tu peux débugger avec print() comme dans n'importe quel script
• L'écosystème : torchvision pour la vision, torchaudio pour l'audio, HuggingFace qui s'appuie dessus

Bref, si tu veux faire de l'IA sérieuse, PyTorch est ton allié.

Ce qu'on va construire

Aujourd'hui, on va créer un réseau de neurones capable de reconnaître des chiffres manuscrits (le célèbre dataset MNIST). À la fin de ce tutoriel, tu auras :

1. Compris ce qu'est un tensor (le bloc de base)
2. Utilisé autograd pour le calcul automatique des gradients
3. Construit un réseau de neurones à deux couches
4. Entraîné ton modèle sur des vraies données
5. Obtenu plus de 95 % de précision

Étape 1 : Installation

D'abord, on crée un environnement propre et on installe PyTorch.

# Créer un dossier de projet
mkdir mon-premier-pytorch && cd mon-premier-pytorch

# Créer un environnement virtuel
python3 -m venv venv
source venv/bin/activate

# Installer PyTorch (CPU = pas besoin de carte graphique)
pip install torch torchvision

💡 Ce que tu dois voir : pip télécharge PyTorch et ses dépendances (~150 Mo). L'installation prend 1 à 2 minutes. Aucune erreur ne doit apparaître en rouge.

Vérifie que tout fonctionne :

import torch
print(f"PyTorch version : {torch.__version__}")
print(f"GPU dispo : {torch.cuda.is_available()}")

Si la première ligne affiche une version (ex: 2.x.x), tout est bon. Le GPU n'est pas nécessaire pour ce tutoriel — le CPU suffit.

Étape 2 : Les tensors, le bloc de base

Un tensor, c'est l'équivalent d'un tableau NumPy... mais avec un super-pouvoir : il peut être envoyé sur une carte graphique (GPU) et il garde une trace de toutes les opérations pour le calcul des gradients.

import torch

# Créer un tensor à partir d'une liste Python
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
print(x)          # tensor([1., 2., 3., 4.])
print(x.shape)    # torch.Size([4])
print(x.dtype)    # torch.float32

# Créer des tensors de zéros, de uns, ou aléatoires
zeros = torch.zeros(3, 4)      # 3 lignes, 4 colonnes
ones = torch.ones(2, 5)        # 2 lignes, 5 colonnes
random = torch.randn(3, 3)     # distribution normale

# Opérations mathématiques
a = torch.tensor([1.0, 2.0])
b = torch.tensor([3.0, 4.0])
print(a + b)       # tensor([4., 6.])
print(a * b)       # tensor([3., 8.]) — multiplication élément par élément
print(a @ b)       # tensor(11.) — produit scalaire

💡 Ce que tu dois voir : Chaque print() affiche le résultat attendu. Pas d'erreur.

Le concept clé : tout dans PyTorch passe par les tensors. Une image = un tensor de forme (hauteur, largeur, canaux). Un batch de données = un tensor de forme (taille_batch, caractéristiques).

Étape 3 : Autograd — la magie de la dérivation automatique

Le deep learning repose sur la descente de gradient : on calcule la dérivée (le gradient) de l'erreur par rapport à chaque paramètre, puis on ajuste les paramètres dans la direction qui réduit l'erreur.

PyTorch fait ça tout seul avec autograd. Regarde :

# Un tensor qui demande le suivi des gradients
w = torch.tensor([2.0], requires_grad=True)

# On définit une fonction : f(w) = w² + 3w + 1
f = w**2 + 3*w + 1

# On calcule le gradient df/dw automatiquement
f.backward()

print(f"f(w) = {f.item()}")        # f(w) = 11.0
print(f"df/dw = {w.grad.item()}")  # df/dw = 7.0  (car 2w + 3 = 2*2 + 3 = 7)

💡 Ce que tu dois voir : La valeur du gradient calculé automatiquement correspond au calcul manuel. C'est cette magie qui permet d'entraîner des réseaux de neurones avec des millions de paramètres.

Étape 4 : Charger les données MNIST

MNIST, c'est 70 000 images de chiffres manuscrits (28×28 pixels en noir et blanc). PyTorch les télécharge pour nous :

import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# Pipeline de transformation : image → tensor → normalisation
transform = transforms.Compose([
    transforms.ToTensor(),                          # Convertit l'image en tensor (0 à 1)
    transforms.Normalize((0.1307,), (0.3081,))      # Normalise avec moyenne et écart-type MNIST
])

# Télécharger et charger les données
train_data = datasets.MNIST(
    root="./data",        # Stockage local
    train=True,           # Le dataset d'entraînement
    download=True,        # Télécharge si pas déjà fait
    transform=transform   # Applique la transformation
)

test_data = datasets.MNIST(
    root="./data",
    train=False,          # Le dataset de test
    transform=transform
)

# DataLoader : distribue les données par batch et les mélange
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000, shuffle=False)

print(f"Images d'entraînement : {len(train_data)}")
print(f"Images de test       : {len(test_data)}")

💡 Ce que tu dois voir : Le téléchargement prend ~10 secondes. Tu vois 60000 images d'entraînement et 10000 de test.

Étape 5 : Construire le réseau de neurones

On va créer un réseau super simple, mais efficace : une couche d'entrée de 784 neurones (28×28 pixels), une couche cachée de 128 neurones, et une couche de sortie de 10 neurones (1 par chiffre).

import torch.nn as nn

class MonPremierReseau(nn.Module):
    def __init__(self):
        super().__init__()
        self.couche_cachee = nn.Linear(28*28, 128)   # Entrée (784 pixels) → 128 neurones cachés
        self.couche_sortie = nn.Linear(128, 10)        # 128 neurones cachés → 10 classes (0 à 9)
        self.relu = nn.ReLU()                           # Fonction d'activation (introduit la non-linéarité)
    
    def forward(self, x):
        # x a la forme (batch_size, 1, 28, 28) — on l'aplatit
        x = x.view(-1, 28*28)          # (batch_size, 784)
        x = self.relu(self.couche_cachee(x))   # (batch_size, 128) avec ReLU
        x = self.couche_sortie(x)               # (batch_size, 10)
        return x

# Instancier le modèle
modele = MonPremierReseau()
print(modele)

💡 Ce que tu dois voir : Le print(modele) affiche l'architecture complète du réseau. Chaque couche Linear montre le nombre de paramètres.

Pourquoi cette architecture ? 784 pixels → on les compresse en 128 caractéristiques intermédiaires → on les projette en 10 scores (un par chiffre). La fonction ReLU remplace les valeurs négatives par zéro — c'est ce qui permet au réseau d'apprendre des relations non-linéaires.

Étape 6 : La boucle d'entraînement

C'est le cœur du deep learning. On répète 5 fois (5 époques) le cycle : prédire → mesurer l'erreur → corriger les paramètres.