Module L14 · Partie H · Intelligence artificielle

Réseaux de neurones : les construire en NumPy.

Un réseau de neurones est une composition de fonctions simples — produit matriciel, non-linéarité — dont on ajuste les paramètres par descente de gradient. Rien de plus. Ce module le construit couche par couche, dérive la rétropropagation à la main, vérifie chaque gradient numériquement, et entraîne un classifieur de chiffres manuscrits dans la page. Quand vous utiliserez PyTorch, vous saurez exactement ce qu’il fait.

Durée : 4 séances · Prérequis : L12 (gradient, autodiff), L13. Objectifs : neurone, couche, activation, perceptron multicouche ; théorème d’approximation universelle (intuition) ; rétropropagation matricielle ; initialisation, SGD, momentum, Adam ; régularisation (dropout, arrêt anticipé) ; vérification numérique des gradients ; mini-MNIST ; convolution.

Ce que vous saurez faire à la fin

Écrire un perceptron multicouche complet en NumPy avec passe avant, arrière et optimiseur.
Dériver et vérifier les gradients de chaque couche.
Entraîner un réseau à >95 % sur des chiffres 8×8 et lire ses courbes d’apprentissage.
Expliquer ce que fait une convolution et pourquoi elle est adaptée aux images.

Références : Neural Networks and Deep Learning (Nielsen, gratuit), cours CS231n (Stanford), série « Neural networks » de 3Blue1Brown, Deep Learning (Goodfellow) chapitres 6-8, « micrograd » et « makemore » (Karpathy).

Fiche de cours · Définitions

Réseaux de neurones : définitions

Définition (neurone, couche, réseau). Un neurone calcule a = φ(wᵀx + b) : combinaison linéaire puis activation non linéaire φ. Une couche dense applique a = φ(Wx + b) à un vecteur. Un perceptron multicouche (MLP) enchaîne L couches : h_ℓ = φ(W_ℓh_ℓ−1 + b_ℓ), h₀ = x. Les paramètres θ = (W_ℓ, b_ℓ) sont appris ; l’architecture (tailles, activations) est fixée.

Définition (activations). Sigmoïde σ(z) = 1/(1 + e^−z) ∈ ]0, 1[ ; tanh ∈ ]−1, 1[ ; ReLU(z) = max(0, z) ; softmax(z)_k = e^z_k/Σ_j e^z_j (sortie multi-classes, somme 1).

Définition (perte, gradient, rétropropagation). On minimise L(θ) = (1/n)Σ ℓ(f_θ(x_i), y_i). Le gradient ∇_θL est calculé par la rétropropagation : application de la règle de dérivation en chaîne de la sortie vers l’entrée, en réutilisant les valeurs du passage avant. Coût : ≈ 2× le passage avant.

Définition (descente de gradient stochastique, époque, mini-lot). À chaque pas, le gradient est estimé sur un mini-lot de m exemples : θ ← θ − α·ĝ. Une époque = un passage sur toutes les données. Variantes : momentum (v ← βv + g, θ ← θ − αv), Adam (moments d’ordre 1 et 2 normalisés).

Définition (régularisation des réseaux). Weight decay (L2), dropout (mettre à zéro aléatoirement une fraction p des activations à l’entraînement, tout garder à l’inférence en multipliant par 1 − p), arrêt précoce (early stopping sur la validation), augmentation de données, normalisation par lots (batch norm).

Définition (convolution). Une couche de convolution applique le même petit noyau K (3×3, 5×5) à toutes les positions de l’image : (I ∗ K)(i, j) = Σ_u,v I(i+u, j+v)K(u, v). Partage des poids ⇒ peu de paramètres, invariance par translation. Pooling : réduction de résolution (max sur 2×2).

Fiche de cours · Formules

Formules à connaître

Passage avant : z_ℓ = W_ℓh_ℓ−1 + b_ℓ, h_ℓ = φ(z_ℓ)

Rétropropagation : δ_L = ∂ℓ/∂z_L ; δ_ℓ = (W_ℓ+1ᵀ δ_ℓ+1) ⊙ φ′(z_ℓ) ; ∂L/∂W_ℓ = δ_ℓ h_ℓ−1ᵀ ; ∂L/∂b_ℓ = δ_ℓ

Softmax + entropie croisée : ∂ℓ/∂z = p − y (y one-hot) le gradient de sortie est « prédiction moins cible », comme en régression logistique

Activation	φ(z)	φ′(z)	Remarque
Sigmoïde	1/(1 + e^−z)	σ(1 − σ) ≤ 1/4	Gradient qui s’évanouit en profondeur
tanh	(e^z − e^−z)/(e^z + e^−z)	1 − tanh² ≤ 1	Centrée en 0
ReLU	max(0, z)	1_z>0	Pas de saturation ; « neurones morts » si z < 0 toujours
GELU / SiLU	z·Φ(z) / z·σ(z)	lisse	Transformers

Nombre de paramètres d’une couche dense n_in → n_out : n_in·n_out + n_out ; d’une convolution C_in → C_out, noyau k×k : k²·C_in·C_out + C_out

Taille de sortie d’une convolution : ⌊(n + 2p − k)/s⌋ + 1 (n entrée, p padding, k noyau, s stride)

Initialisation : Var(W) = 2/n_in (He, ReLU) ou 1/n_in (Xavier, tanh) pour conserver la variance des activations

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire (1/2)

Théorème 1 (rétropropagation). Pour un MLP, les gradients de la perte par rapport aux paramètres de chaque couche se calculent par les formules ci-dessus, en un passage arrière de coût comparable au passage avant.

Notons δ_ℓ = ∂ℓ/∂z_ℓ (vecteur de la taille de la couche ℓ). Comme z_ℓ+1 = W_ℓ+1φ(z_ℓ) + b_ℓ+1, la règle de la chaîne donne ∂ℓ/∂z_ℓ,i = Σ_j (∂ℓ/∂z_ℓ+1,j)(∂z_ℓ+1,j/∂z_ℓ,i) = Σ_j δ_ℓ+1,j W_ℓ+1,ji φ′(z_ℓ,i), soit δ_ℓ = (W_ℓ+1ᵀδ_ℓ+1) ⊙ φ′(z_ℓ). Puis, z_ℓ = W_ℓh_ℓ−1 + b_ℓ étant linéaire en W_ℓ : ∂ℓ/∂W_ℓ,ij = δ_ℓ,ih_ℓ−1,j, c’est-à-dire δ_ℓh_ℓ−1ᵀ, et ∂ℓ/∂b_ℓ = δ_ℓ. Chaque couche demande un produit matrice-vecteur (comme à l’aller) et un produit extérieur : même ordre de coût. L’autodiff (PyTorch) généralise cela à tout graphe de calcul : chaque opération connaît sa dérivée locale, et le graphe est parcouru en sens inverse.

Théorème 2 (gradient de softmax + entropie croisée). Pour p = softmax(z) et ℓ = −log p_c (c la classe vraie), ∂ℓ/∂z_k = p_k − 1_k=c.

ℓ = −z_c + log Σ_j e^z_j. ∂ℓ/∂z_k = −1_k=c + e^z_k/Σ_j e^z_j = p_k − 1_k=c. Remarque numérique : calculer log Σ e^z_j comme m + log Σ e^{z_j − m} avec m = max z (log-sum-exp) évite le débordement.

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire (2/2)

Théorème 3 (évanouissement du gradient). Dans un réseau de L couches à activation sigmoïde et poids de norme ≤ 1, ‖δ₁‖ ≤ (1/4)^L−1‖δ_L‖ : le gradient des premières couches décroît exponentiellement avec la profondeur.

δ_ℓ = (W_ℓ+1ᵀδ_ℓ+1) ⊙ σ′(z_ℓ) avec σ′ ≤ 1/4 partout ; donc ‖δ_ℓ‖ ≤ ‖W_ℓ+1‖·‖δ_ℓ+1‖/4 ≤ ‖δ_ℓ+1‖/4. Par récurrence sur L − ℓ. Avec des poids plus grands, c’est l’explosion (facteur ‖W‖/4 > 1). Remèdes, tous vérifiables par cette inégalité : ReLU (φ′ = 1 sur la partie active), initialisation qui garde ‖W‖ ≈ 1 (He/Xavier), normalisation par lots, et surtout les connexions résiduelles h_ℓ+1 = h_ℓ + F(h_ℓ) dont le jacobien est I + ∂F : le gradient a un chemin direct de norme 1.

Théorème 4 (initialisation de He). Si les entrées d’une couche ReLU ont une variance v et les poids sont i.i.d. centrés de variance 2/n_in, les sorties ont (approximativement) la variance v.

z = Σ_j w_jx_j : Var(z) = n_in·Var(w)·E[x²] (termes indépendants centrés). Pour x = ReLU(z_précédent) avec z_précédent symétrique de variance v : E[x²] = ½E[z_précédent²] = v/2 (la moitié négative est mise à 0). Donc Var(z) = n_in·(2/n_in)·(v/2) = v. Sans ce facteur 2 (variance 1/n_in), la variance est divisée par 2 à chaque couche : après 20 couches, 10⁻⁶ — les activations et gradients s’effondrent.

Théorème 5 (approximation universelle — énoncé). Toute fonction continue sur un compact de ℝⁿ peut être approchée uniformément, à ε près, par un MLP à une couche cachée (assez large) d’activation non polynomiale (Cybenko 1989, Hornik 1991).

(Admis ; idée en dimension 1 avec ReLU : une combinaison de ReLU est une fonction affine par morceaux, et toute fonction continue sur [a, b] est limite uniforme de fonctions affines par morceaux — il suffit d’un « coude » ReLU par nœud d’interpolation.) Le théorème ne dit rien de la taille nécessaire (exponentielle en général pour une couche) ni de la possibilité de trouver les poids par descente de gradient : la profondeur rend certaines fonctions exponentiellement plus économes à représenter, et l’optimisation est un sujet à part.

Fiche de cours · Méthodes

Méthodes et pièges

Méthode — entraîner un réseau, dans l’ordre. (1) Vérifier le gradient par différences finies sur un petit réseau (erreur relative < 10⁻⁵). (2) Sur-apprendre volontairement un mini-lot de 8 exemples : la perte doit tomber à ~0 — sinon bug. (3) Baseline simple (régression logistique). (4) Choisir le pas par balayage log (10⁻⁴ … 10⁻¹) sur quelques centaines de pas : le plus grand qui ne diverge pas. (5) Suivre perte train et val par époque ; arrêt précoce. (6) Ajouter régularisation si écart train/val ; capacité si les deux stagnent. (7) Fixer la graine, journaliser tout.

Méthode — lire une courbe de perte. Explose → pas trop grand ou gradients non normalisés. Plateau dès le début → pas trop petit, mauvaise initialisation, ReLU mortes, données non standardisées. Oscille sans descendre → pas trop grand ou mini-lot trop petit. Train ↓ val ↑ → sur-apprentissage.

Méthode — dimensionner. Paramètres ≈ données/10 comme point de départ pour un MLP ; images → convolutions ; séquences → transformer (L15). Compter les FLOPs (≈ 2 × paramètres par exemple par passage avant) pour prévoir le temps.

Pièges : oublier model.eval()/dropout à l’inférence ; standardiser le test avec ses propres statistiques ; softmax suivi d’une entropie croisée qui refait un log (instable, et PyTorch attend des logits) ; mélanger les données temporelles ; comparer deux architectures avec des budgets de pas différents ; croire qu’une perte train de 0 est une réussite.

Fiche de cours · Exercices corrigés

Exercices corrigés

Exercice 1. Réseau à une couche cachée de 2 neurones ReLU, entrée x ∈ ℝ², sortie scalaire linéaire, perte quadratique. W₁ = [[1, −1], [0, 1]], b₁ = (0, 0), W₂ = [1, 1], b₂ = 0. Pour x = (1, 2), y = 1 : calculer le passage avant, la perte, et le gradient par rapport à W₂ et W₁.

Correction. z₁ = W₁x + b₁ = (1 − 2, 0 + 2) = (−1, 2) ; h₁ = ReLU(z₁) = (0, 2) ; ŷ = W₂h₁ = 2 ; ℓ = (ŷ − y)² = 1. Arrière : δ₂ = ∂ℓ/∂ŷ = 2(ŷ − y) = 2 ; ∂ℓ/∂W₂ = δ₂h₁ᵀ = (0, 4) ; ∂ℓ/∂b₂ = 2. δ₁ = (W₂ᵀδ₂) ⊙ ReLU′(z₁) = (2, 2) ⊙ (0, 1) = (0, 2) ; ∂ℓ/∂W₁ = δ₁xᵀ = [[0, 0], [2, 4]] ; ∂ℓ/∂b₁ = (0, 2). Le premier neurone (z = −1 < 0) ne reçoit aucun gradient : c’est le phénomène du neurone inactif.

Exercice 2. Un CNN prend des images 32×32×3. Couches : conv 3×3, 16 filtres, padding 1 ; maxpool 2 ; conv 3×3, 32 filtres, padding 1 ; maxpool 2 ; dense → 10. Donner les tailles intermédiaires et le nombre total de paramètres.

Correction. Conv1 : sortie 32×32×16 (padding 1 conserve la taille), paramètres 3·3·3·16 + 16 = 448. Pool → 16×16×16. Conv2 : 16×16×32, paramètres 3·3·16·32 + 32 = 4 640. Pool → 8×8×32 = 2 048 valeurs. Dense 2 048 → 10 : 20 490. Total 25 578. Un MLP dense équivalent 3 072 → 512 → 10 aurait 1,58 million de paramètres : la convolution en économise 60× grâce au partage des poids.

Exercice 3. Expliquer pourquoi la descente de gradient stochastique avec mini-lots de taille m a un gradient dont la variance est divisée par m, et pourquoi on n’utilise pas m = n.

Correction. Le gradient d’un exemple g_i est une estimation sans biais du gradient complet g (E[g_i] = g si i est tiré uniformément). La moyenne de m tirages i.i.d. a la même espérance et une variance divisée par m (Théorème 2 de L11). Avec m = n on retrouve le gradient exact, mais chaque pas coûte n passages avant/arrière : pour un budget de calcul fixé, on fait n/m fois plus de pas avec des mini-lots, et un gradient un peu bruité suffit à progresser (et aide même à sortir des cols). Compromis : m de 32 à 512, limité par la mémoire du GPU ; augmenter m exige d’augmenter le pas (règle linéaire) pour garder la même dynamique.

01 / Le neurone

Un neurone = régression logistique ; une couche = plusieurs neurones ; un réseau = des couches

import numpy as np
rng = np.random.default_rng(0)

# Un neurone : sortie = activation(w·x + b). Une couche de m neurones : sortie = activation(W x + b), W (m × d).
def relu(z): return np.maximum(0, z)
def sigmoide(z): return 1 / (1 + np.exp(-z))

x = np.array([0.5, -1.2, 3.0])                     # une entrée de dimension 3
W1, b1 = rng.normal(0, 0.5, (4, 3)), np.zeros(4)   # couche cachée : 4 neurones
W2, b2 = rng.normal(0, 0.5, (1, 4)), np.zeros(1)   # couche de sortie : 1 neurone
h = relu(W1 @ x + b1)                              # activations cachées (4,)
y = sigmoide(W2 @ h + b2)                          # sortie (1,)
print("caché :", h.round(3), "\nsortie :", y.round(3))

# Pourquoi une non-linéarité ? Sans elle, deux couches = une seule (produit de matrices = matrice)
W_equiv = W2 @ W1
print("sans ReLU, W2 (W1 x) = (W2 W1) x :", np.allclose(W2 @ (W1 @ x), W_equiv @ x))

# Le XOR : impossible avec un neurone (frontière linéaire), facile avec une couche cachée
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]); y_xor = np.array([0, 1, 1, 0])
W1 = np.array([[1, 1], [1, 1.]]); b1 = np.array([0, -1.]); W2 = np.array([[1, -2.]]); b2 = np.array([0.])
h = relu(X @ W1.T + b1); print("XOR à la main :", (h @ W2.T + b2).ravel())

Le théorème d’approximation universelle

Un réseau à une couche cachée assez large peut approcher n’importe quelle fonction continue sur un compact, à la précision voulue (Cybenko 1989, Hornik 1991). Intuition avec ReLU : chaque neurone caché est une « rampe » ; en additionnant des rampes de pentes et positions différentes, on construit n’importe quelle fonction affine par morceaux, qui approche n’importe quelle fonction continue. Le théorème dit que c’est possible, pas que la descente de gradient trouvera les poids, ni combien de neurones il faut — la profondeur permet d’en utiliser exponentiellement moins pour certaines fonctions. C’est un sujet de recherche actif.

02 / Rétropropagation

Dériver la passe arrière d’une couche, et la vérifier

import numpy as np
rng = np.random.default_rng(1)

# Couche affine : Z = X W + b, avec X (n × d), W (d × m). Si L est la perte et dZ = ∂L/∂Z (n × m) :
#   ∂L/∂W = Xᵀ dZ      ∂L/∂b = Σ_lignes dZ      ∂L/∂X = dZ Wᵀ
# ReLU : ∂L/∂Z = dA · 1[Z > 0]
class Affine:
    def __init__(self, d, m): self.W = rng.normal(0, np.sqrt(2 / d), (d, m)); self.b = np.zeros(m)   # init He
    def avant(self, X): self.X = X; return X @ self.W + self.b
    def arriere(self, dZ):
        self.dW = self.X.T @ dZ; self.db = dZ.sum(0)
        return dZ @ self.W.T
class ReLU:
    def avant(self, Z): self.Z = Z; return np.maximum(0, Z)
    def arriere(self, dA): return dA * (self.Z > 0)

# Vérification numérique : dériver par différences finies et comparer (le test que tout le monde doit faire)
def verifier_gradient(couche, X, h=1e-5):
    dZ = rng.normal(0, 1, couche.avant(X).shape)          # une « perte » L = Σ dZ·Z, arbitraire
    couche.arriere(dZ)
    num = np.zeros_like(couche.W)
    for i in range(couche.W.shape[0]):
        for j in range(couche.W.shape[1]):
            couche.W[i, j] += h; Lp = (couche.avant(X) * dZ).sum()
            couche.W[i, j] -= 2 * h; Lm = (couche.avant(X) * dZ).sum()
            couche.W[i, j] += h; num[i, j] = (Lp - Lm) / (2 * h)
    return np.abs(num - couche.dW).max() / (np.abs(num).max() + 1e-12)
c = Affine(5, 3); X = rng.normal(0, 1, (7, 5))
print("erreur relative gradient W :", f"{verifier_gradient(c, X):.1e}", "(doit être < 1e-6)")

D’où viennent ces formules

Z = XW + b ⇒ Z[i,k] = Σ_j X[i,j] W[j,k] + b[k]. Par la règle de la chaîne, ∂L/∂W[j,k] = Σ_i ∂L/∂Z[i,k] · X[i,j] = (Xᵀ dZ)[j,k]. De même pour b (somme sur les exemples i) et pour X (dZ Wᵀ, qu’on transmet à la couche précédente). Le gradient passe de la sortie vers l’entrée, couche par couche, chaque couche multipliant par sa jacobienne locale : c’est la rétropropagation, la règle de la chaîne organisée en matrices. Le module L12 le faisait scalaire par scalaire ; ici, un produit matriciel traite tous les exemples et tous les neurones d’un coup — et c’est ce qui tourne sur GPU.

02 / Rétropropagation

Le réseau complet : perte, optimiseur, boucle d’entraînement

import numpy as np
rng = np.random.default_rng(2)

class SoftmaxEntropie:
    """Combine softmax et entropie croisée : le gradient est simplement (p − onehot) / n."""
    def avant(self, Z, y):
        Z = Z - Z.max(1, keepdims=True); e = np.exp(Z); self.p = e / e.sum(1, keepdims=True); self.y = y
        return -np.log(self.p[np.arange(len(y)), y] + 1e-12).mean()
    def arriere(self):
        d = self.p.copy(); d[np.arange(len(self.y)), self.y] -= 1; return d / len(self.y)

class Reseau:
    def __init__(self, tailles):
        self.couches = []
        for d, m in zip(tailles, tailles[1:]):
            self.couches += [Affine(d, m), ReLU()]
        self.couches.pop()                                    # pas de ReLU après la dernière couche
        self.perte = SoftmaxEntropie()
    def avant(self, X):
        for c in self.couches: X = c.avant(X)
        return X
    def arriere(self):
        d = self.perte.arriere()
        for c in reversed(self.couches): d = c.arriere(d)
    def parametres(self):
        return [(c, "W") for c in self.couches if hasattr(c, "W")] + [(c, "b") for c in self.couches if hasattr(c, "W")]
    def predire(self, X): return self.avant(X).argmax(1)

class SGD:
    def __init__(self, params, lr=0.1, momentum=0.9):
        self.params, self.lr, self.mu = params, lr, momentum
        self.v = [np.zeros_like(getattr(c, n)) for c, n in params]
    def pas(self):
        for (c, n), v in zip(self.params, self.v):
            g = getattr(c, "d" + n); v *= self.mu; v -= self.lr * g
            setattr(c, n, getattr(c, n) + v)

# Test sur des spirales 2D : 3 classes, non linéairement séparables
def spirales(n=300, K=3):
    X, y = [], []
    for k in range(K):
        r = np.linspace(0.1, 1, n); t = np.linspace(k * 4, (k + 1) * 4, n) + rng.normal(0, 0.2, n)
        X.append(np.column_stack([r * np.sin(t), r * np.cos(t)])); y += [k] * n
    return np.concatenate(X), np.array(y)
X, y = spirales()
net = Reseau([2, 32, 32, 3]); opt = SGD(net.parametres(), lr=0.05)
for epoch in range(400):
    L = net.perte.avant(net.avant(X), y); net.arriere(); opt.pas()
    if epoch % 100 == 0 or epoch == 399: print(f"epoch {epoch:3d}  perte {L:.3f}  exactitude {np.mean(net.predire(X) == y):.3f}")

Toute la « magie » tient en quatre lignes : avant, perte, arriere, pas. PyTorch : out = model(X); loss = F.cross_entropy(out, y); loss.backward(); optimizer.step(). Même structure, mêmes noms.

03 / Entraîner

Mini-MNIST : reconnaître des chiffres 8×8 dans la page

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(3)

# Jeu de données synthétique de chiffres 8×8 : gabarits + déformations aléatoires (pas de téléchargement nécessaire)
GABARITS = {
 0: ["..####..", ".#....#.", "#......#", "#......#", "#......#", "#......#", ".#....#.", "..####.."],
 1: ["...##...", "..###...", "...##...", "...##...", "...##...", "...##...", "...##...", ".######."],
 2: ["..####..", ".#....#.", "......#.", ".....#..", "....#...", "...#....", "..#.....", ".######."],
 3: ["..####..", ".#....#.", "......#.", "...###..", "......#.", "......#.", ".#....#.", "..####.."],
 4: ["....##..", "...#.#..", "..#..#..", ".#...#..", "#....#..", "########", ".....#..", ".....#.."],
 5: ["#######.", "#.......", "#.......", "######..", "......#.", "......#.", "#.....#.", ".#####.."],
 6: ["..####..", ".#......", "#.......", "######..", "#.....#.", "#.....#.", "#.....#.", ".#####.."],
 7: ["########", "......#.", ".....#..", "....#...", "...#....", "...#....", "...#....", "...#...."],
 8: [".#####..", "#.....#.", "#.....#.", ".#####..", "#.....#.", "#.....#.", "#.....#.", ".#####.."],
 9: [".#####..", "#.....#.", "#.....#.", ".######.", "......#.", "......#.", ".....#..", "..###..."]}
def generer(n_par_classe):
    X, y = [], []
    for k, g in GABARITS.items():
        base = np.array([[c == "#" for c in l] for l in g], float)
        for _ in range(n_par_classe):
            img = np.roll(base, (rng.integers(-1, 2), rng.integers(-1, 2)), axis=(0, 1))   # décalage
            img = img * rng.uniform(0.6, 1.0) + rng.normal(0, 0.15, (8, 8))                 # contraste + bruit
            img[rng.random((8, 8)) < 0.05] = rng.random()                                   # pixels morts
            X.append(img.ravel()); y.append(k)
    return np.array(X), np.array(y)
X_tr, y_tr = generer(120); X_te, y_te = generer(30)
mu, sd = X_tr.mean(), X_tr.std(); X_tr, X_te = (X_tr - mu) / sd, (X_te - mu) / sd
print("entraînement :", X_tr.shape, "| test :", X_te.shape)

fig, axes = plt.subplots(1, 10, figsize=(9, 1.2))
for ax, k in zip(axes, range(10)):
    ax.imshow(X_tr[y_tr == k][0].reshape(8, 8), cmap="gray"); ax.axis("off")
plt.show()

03 / Entraîner

Mini-lots, courbes d’apprentissage, arrêt anticipé

import numpy as np
import matplotlib.pyplot as plt

def entrainer(net, opt, X, y, X_val, y_val, epochs=30, lot=32):
    hist = {"train": [], "val": []}; meilleur = (0, None)
    for e in range(epochs):
        idx = rng.permutation(len(y))
        for i in range(0, len(y), lot):                                   # SGD par mini-lots
            b = idx[i:i + lot]
            net.perte.avant(net.avant(X[b]), y[b]); net.arriere(); opt.pas()
        acc_tr, acc_val = np.mean(net.predire(X) == y), np.mean(net.predire(X_val) == y_val)
        hist["train"].append(acc_tr); hist["val"].append(acc_val)
        if acc_val > meilleur[0]: meilleur = (acc_val, e)                # arrêt anticipé : garder le meilleur
    return hist, meilleur

net = Reseau([64, 64, 10]); opt = SGD(net.parametres(), lr=0.02)
hist, (best, e_best) = entrainer(net, opt, X_tr, y_tr, X_te, y_te)
print(f"exactitude test : {hist['val'][-1]:.3f} (meilleure {best:.3f} à l'epoch {e_best})")
plt.figure(figsize=(6, 3)); plt.plot(hist["train"], label="train"); plt.plot(hist["val"], label="test"); plt.legend(); plt.xlabel("epoch"); plt.show()

# Matrice de confusion : quelles paires de chiffres se ressemblent ?
conf = np.zeros((10, 10), int)
for a, p in zip(y_te, net.predire(X_te)): conf[a, p] += 1
print(conf)
# Regarder ce que le réseau a appris : les poids de la première couche sont des « détecteurs »
W = net.couches[0].W
fig, axes = plt.subplots(1, 8, figsize=(9, 1.3))
for ax, k in zip(axes, range(8)): ax.imshow(W[:, k].reshape(8, 8), cmap="RdBu"); ax.axis("off")
plt.show()

Lire les courbes

Train et test montent ensemble puis le train continue seul : c’est le début du sur-apprentissage, et le moment de s’arrêter (arrêt anticipé). Mini-lots : un gradient calculé sur 32 exemples est bruité mais 40 fois moins cher que sur 1200 ; le bruit aide même à généraliser. Un epoch = un passage sur les données = 1200/32 ≈ 38 pas. Ordres de grandeur réels : MNIST (60 000 images 28×28) → 98 % avec ce même code ; ImageNet (1,2 million d’images) → réseaux convolutifs sur GPU pendant des jours.

03 / Entraîner

Ce qui fait ou défait un entraînement : initialisation, Adam, dropout

import numpy as np

# 1) Initialisation : trop petite → les activations s'éteignent couche après couche ; trop grande → explosent
for nom, echelle in [("trop petite", 0.01), ("He (√(2/d))", np.sqrt(2 / 64)), ("trop grande", 1.0)]:
    h = rng.normal(0, 1, (100, 64))
    for _ in range(10): h = np.maximum(0, h @ rng.normal(0, echelle, (64, 64)))
    print(f"{nom:14s} écart-type après 10 couches : {h.std():.2e}")

# 2) Adam : un pas adapté par paramètre (moyennes mobiles du gradient et de son carré)
class Adam:
    def __init__(self, params, lr=1e-3, b1=0.9, b2=0.999, eps=1e-8):
        self.p, self.lr, self.b1, self.b2, self.eps, self.t = params, lr, b1, b2, eps, 0
        self.m = [np.zeros_like(getattr(c, n)) for c, n in params]; self.v = [np.zeros_like(getattr(c, n)) for c, n in params]
    def pas(self):
        self.t += 1
        for (c, n), m, v in zip(self.p, self.m, self.v):
            g = getattr(c, "d" + n)
            m *= self.b1; m += (1 - self.b1) * g; v *= self.b2; v += (1 - self.b2) * g * g
            mh, vh = m / (1 - self.b1**self.t), v / (1 - self.b2**self.t)      # correction de biais
            setattr(c, n, getattr(c, n) - self.lr * mh / (np.sqrt(vh) + self.eps))

# 3) Dropout : éteindre aléatoirement des neurones à l'entraînement → le réseau ne peut compter sur aucun en particulier
class Dropout:
    def __init__(self, p=0.3): self.p, self.train = p, True
    def avant(self, A):
        if not self.train: return A
        self.masque = (rng.random(A.shape) > self.p) / (1 - self.p); return A * self.masque
    def arriere(self, dA): return dA * self.masque

net2 = Reseau([64, 128, 10]); net2.couches.insert(2, Dropout(0.3))
opt2 = Adam(net2.parametres(), lr=2e-3)
hist2, (best2, e2) = entrainer(net2, opt2, X_tr, y_tr, X_te, y_te, epochs=30)
for c in net2.couches:
    if isinstance(c, Dropout): c.train = False                 # à l'inférence : pas de dropout
print(f"Adam + dropout : test {np.mean(net2.predire(X_te) == y_te):.3f} (meilleure {best2:.3f} à l'epoch {e2})")

Ordre de priorité quand ça n’apprend pas : 1) vérifier les gradients numériquement ; 2) sur-apprendre volontairement un tout petit lot (si le réseau n’arrive pas à mémoriser 10 exemples, il y a un bug) ; 3) baisser le pas d’apprentissage ; 4) vérifier l’initialisation et la normalisation des entrées ; 5) seulement ensuite, changer l’architecture.

04 / Convolutions

La convolution : un détecteur local partagé

import numpy as np
import matplotlib.pyplot as plt

def convolution2d(image, noyau):
    """Corrélation croisée (ce que les réseaux appellent convolution). Sortie plus petite de k−1."""
    H, W = image.shape; k = noyau.shape[0]
    out = np.zeros((H - k + 1, W - k + 1))
    for i in range(out.shape[0]):
        for j in range(out.shape[1]):
            out[i, j] = (image[i:i + k, j:j + k] * noyau).sum()
    return out

img = X_tr[y_tr == 7][0].reshape(8, 8)
noyaux = {"vertical": np.array([[-1, 0, 1]] * 3) / 3, "horizontal": np.array([[-1, 0, 1]] * 3).T / 3,
          "flou": np.ones((3, 3)) / 9, "laplacien": np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])}
fig, axes = plt.subplots(1, 5, figsize=(9, 1.8)); axes[0].imshow(img, cmap="gray"); axes[0].set_title("image"); axes[0].axis("off")
for ax, (nom, k) in zip(axes[1:], noyaux.items()):
    ax.imshow(convolution2d(img, k), cmap="RdBu"); ax.set_title(nom); ax.axis("off")
plt.show()

# Nombre de paramètres : une couche dense 64→64 a 4096 poids ; un noyau 3×3 en a 9, appliqué partout
# Un CNN apprend ses noyaux par rétropropagation : ce sont des détecteurs de bords, puis de motifs, puis d'objets
print("paramètres dense 64→64 :", 64 * 64, "| 16 noyaux 3×3 :", 16 * 9)
# Le gradient d'une convolution est… une convolution (avec le noyau retourné). Vérification rapide :
noyau = rng.normal(0, 1, (3, 3)); dOut = rng.normal(0, 1, (6, 6))
dNoyau = np.array([[(img[i:i + 6, j:j + 6] * dOut).sum() for j in range(3)] for i in range(3)])
h = 1e-5; nk = noyau.copy(); nk[1, 1] += h
num = ((convolution2d(img, nk) - convolution2d(img, noyau)) * dOut).sum() / h
print("∂L/∂noyau[1,1] : analytique", dNoyau[1, 1].round(4), "numérique", num.round(4))

Pourquoi ça marche sur les images

Deux biais inductifs : la localité (un pixel est lié à ses voisins) et l’invariance par translation (un bord est un bord où qu’il soit). Le noyau partagé encode les deux, avec 400 fois moins de paramètres qu’une couche dense — donc moins de données nécessaires et moins de sur-apprentissage. Un CNN empile convolution → ReLU → sous-échantillonnage (pooling) plusieurs fois, puis une couche dense. LeNet (1998) lisait les chèques ; AlexNet (2012) a lancé l’ère du deep learning en gagnant ImageNet ; ResNet (2015) a ajouté les connexions résiduelles pour aller à 150 couches. Module L15 pour la suite (attention, transformeurs).

Cours

Cours 1 — Le réseau comme composition de fonctions : notation et dimensions

Définition. Un perceptron multicouche à L couches calcule h₀ = x, puis pour l = 1..L : z_l = W_l h_l−1 + b_l, h_l = φ_l(z_l), et la sortie ŷ = h_L. En traitant un lot de n exemples, on empile les exemples en lignes : H_l est (n × d_l), W_l est (d_l−1 × d_l), et Z_l = H_l−1 W_l + b_l (b diffusé sur les lignes).

Objet	Forme	Nombre de paramètres
Entrée X	(n, d₀)	—
Couche l	W : (d_l−1, d_l), b : (d_l,)	d_l−1·d_l + d_l
Sortie (K classes)	(n, K) logits → softmax → probabilités	—
Total [64, 128, 10]		64·128 + 128 + 128·10 + 10 = 9 610

Règle des dimensions (à vérifier avant de lancer quoi que ce soit) : dans un produit A @ B, la dernière dimension de A égale la première de B ; le gradient de W a la même forme que W ; le gradient qui remonte a la forme de l’entrée de la couche. 90 % des bugs de réseaux sont des erreurs de forme ou de transposée ; assert X.shape == (n, d) partout, et la vérification numérique du gradient (§02) pour le reste.

Cours

Cours 2 — Rétropropagation : la règle de la chaîne écrite proprement

Notation. Pour une perte scalaire J, notons δ_l = ∂J/∂Z_l (même forme que Z_l). La rétropropagation calcule les δ de la sortie vers l’entrée, puis les gradients des paramètres.

Sortie : pour softmax + entropie croisée, δ_L = (P − Y)/n (P : probabilités, Y : one-hot). Pour MSE, δ_L = 2(Ŷ − Y)/n.
Traverser une activation : δ_l = (∂J/∂H_l) ⊙ φ′(Z_l) (produit terme à terme ; ReLU′ = 1[Z > 0]).
Traverser une couche affine : ∂J/∂W_l = H_l−1ᵀ δ_l ; ∂J/∂b_l = Σ_lignes δ_l ; ∂J/∂H_l−1 = δ_l W_lᵀ.
Répéter jusqu’à la première couche.

Preuve de la ligne 3 (une entrée, pour alléger) : z_k = Σ_j h_j W_jk + b_k. Donc ∂J/∂W_jk = Σ_k′ (∂J/∂z_k′)(∂z_k′/∂W_jk) = δ_k h_j, soit la matrice hᵀδ ; et ∂J/∂h_j = Σ_k δ_k W_jk = (δ Wᵀ)_j. Sur un lot, les contributions des exemples s’additionnent (d’où H_l−1ᵀ δ_l qui somme sur n). ∎

Coût. La passe arrière coûte environ deux fois la passe avant (deux produits matriciels par couche au lieu d’un) — quel que soit le nombre de paramètres. C’est ce qui rend l’entraînement de 10⁹ paramètres possible, et c’est la même idée que l’autodiff scalaire du module L12.

Cours

Cours 3 — Recette d’entraînement : les hyperparamètres et leur diagnostic

Symptôme	Diagnostic probable	Remède
La perte ne bouge pas (ou NaN)	Pas d’apprentissage trop grand, gradient faux, données non normalisées	Vérifier le gradient ; lr ÷ 10 ; standardiser ; écrêter le gradient
La perte descend très lentement	lr trop petit, initialisation trop petite, sigmoïdes saturées	lr × 3 ; init He ; ReLU ; Adam
Train ↓, validation ↑	Sur-apprentissage	Plus de données, augmentation, dropout, L2, arrêt anticipé, modèle plus petit
Train et validation hauts	Sous-apprentissage	Modèle plus grand, plus d’epochs, moins de régularisation, meilleures caractéristiques
Impossible de mémoriser 10 exemples	Bug	Le premier test à faire : un réseau doit toujours pouvoir sur-apprendre un lot minuscule
Résultats différents à chaque exécution	Variance des graines	Fixer les graines ; rapporter moyenne ± écart-type sur 5 graines (L24)

Ordre de réglage recommandé (Karpathy, « A Recipe for Training Neural Networks ») : 1) regarder les données ; 2) une baseline minuscule qui marche de bout en bout ; 3) sur-apprendre un petit lot ; 4) régulariser ; 5) chercher les hyperparamètres (lr en premier, sur une échelle log : 10⁻⁴ … 10⁻¹) ; 6) ensembles et moyennes de modèles pour les derniers pourcents.

TP guidé

TP — Le même réseau en NumPy et en PyTorch, jusqu’au vrai MNIST (sur PC, 3 h)

Installer. pip install torch torchvision matplotlib (CPU suffit ; GPU NVIDIA : suivre pytorch.org). Vérifier : python -c "import torch; print(torch.__version__, torch.cuda.is_available())".
Porter le module. Reprenez les classes Affine, ReLU, Reseau, SGD du cours dans numpy_net.py avec un test de gradient numérique sur le réseau complet (défi ★). Puis torch_net.py : le même réseau avec nn.Sequential(nn.Linear(64,128), nn.ReLU(), nn.Linear(128,10)), F.cross_entropy, torch.optim.SGD. Sur le mini-MNIST 8×8 (sklearn.datasets.load_digits), les deux doivent donner la même courbe de perte à graine égale (copiez les mêmes poids initiaux dans les deux : with torch.no_grad(): lin.weight.copy_(torch.tensor(W.T))).
Autograd. Comparez loss.backward() à vos gradients NumPy : lin.weight.grad vs couche.dW.T, écart < 1e-6. Vous venez de vérifier PyTorch avec votre code.
Vrai MNIST. torchvision.datasets.MNIST(download=True), DataLoader(batch_size=64, shuffle=True). MLP [784, 256, 10], Adam lr 1e-3, 5 epochs : ≥ 97,5 % test. Puis un CNN : Conv2d(1,16,3) → ReLU → MaxPool → Conv2d(16,32,3) → ReLU → MaxPool → Flatten → Linear : ≥ 99 %. Temps par epoch CPU vs GPU si disponible.
Diagnostic. Courbes train/val ; matrice de confusion ; les 20 images les plus mal classées (avec leur probabilité) ; balayage de lr sur une échelle log ; effet du dropout et de l’augmentation (rotations ±10°).
Livrable. Dépôt avec les deux implémentations, le test d’égalité NumPy/PyTorch, les courbes, un tableau (modèle, paramètres, temps, exactitude test ± écart-type sur 3 graines).

Exercices

Exercices auto-corrigés — couches et gradients

Exercice 1 — Une couche Tanh et une couche Sigmoïde avec passe arrière vérifiée

Sur le modèle de ReLU du cours, écrivez Tanh et Sigmoide (avant/arrière). La cellule vérifie numériquement les deux.

Correction

class Tanh:
    def avant(self, Z): self.A = np.tanh(Z); return self.A
    def arriere(self, dA): return dA * (1 - self.A**2)
class Sigmoide:
    def avant(self, Z): self.A = 1 / (1 + np.exp(-Z)); return self.A
    def arriere(self, dA): return dA * self.A * (1 - self.A)

Exercice 2 — Softmax numériquement stable et perte pondérée

a) log_softmax(Z) stable (soustraire le max, utiliser logsumexp) : doit fonctionner avec des logits de 1000 sans NaN. b) entropie_croisee_ponderee(Z, y, poids) où poids[k] pondère la classe k (pour les classes rares), et son gradient par rapport à Z ; vérifiez le gradient numériquement.

Correction

def log_softmax(Z):
    m = Z.max(1, keepdims=True); return Z - m - np.log(np.exp(Z - m).sum(1, keepdims=True))
def entropie_croisee_ponderee(Z, y, poids):
    ls = log_softmax(Z); n = len(y); wi = poids[y]
    L = -(wi * ls[np.arange(n), y]).sum() / wi.sum()
    P = np.exp(ls); dZ = P * wi[:, None]; dZ[np.arange(n), y] -= wi
    return L, dZ / wi.sum()

Exercices

Exercices auto-corrigés — entraîner et diagnostiquer

Exercice 3 — Sur-apprendre un lot minuscule (le test de santé)

Écrivez peut_memoriser(X, y, epochs) qui entraîne un MLP [d, 32, K] (Adam, lr 1e-2) sur les données fournies et renvoie l’exactitude d’entraînement finale. Sur 8 exemples aux étiquettes aléatoires, un réseau correct doit atteindre 100 % ; s’il n’y arrive pas, il y a un bug. Utilisez les classes du module (Affine, ReLU, SoftmaxEntropie, Adam) — elles sont dans l’espace de noms si vous avez exécuté les cellules du cours.

Correction

def peut_memoriser(X, y, epochs=300):
    net = Reseau([X.shape[1], 32, int(y.max()) + 1]); opt = Adam(net.parametres(), lr=1e-2)
    for _ in range(epochs):
        net.perte.avant(net.avant(X), y); net.arriere(); opt.pas()
    return float(np.mean(net.predire(X) == y))

Exercice 4 — Courbe d’apprentissage et décision

courbe_apprentissage(tailles) entraîne le MLP sur des sous-ensembles croissants du mini-MNIST (X_tr, y_tr du cours) et renvoie, pour chaque taille, (exactitude train, exactitude test). Puis complétez la variable diagnostic : « plus de données aideraient » si l’écart train−test reste grand à la plus grande taille, sinon « le modèle plafonne ».

Correction

def courbe_apprentissage(tailles, epochs=15):
    out = []
    for n in tailles:
        idx = rng.permutation(len(y_tr))[:n]
        net = Reseau([64, 64, 10]); opt = Adam(net.parametres(), lr=2e-3)
        for _ in range(epochs):
            for i in range(0, n, 32):
                b = idx[i:i + 32]; net.perte.avant(net.avant(X_tr[b]), y_tr[b]); net.arriere(); opt.pas()
        out.append((np.mean(net.predire(X_tr[idx]) == y_tr[idx]), np.mean(net.predire(X_te) == y_te)))
    return out
# puis, après avoir lu l'écart obtenu :
# diagnostic = "plus de données aideraient"   (écart train−test > 5 points à 1200 exemples) ou "le modèle plafonne"

05 / Défis

Défi ★ — Régression par réseau et vérification de gradient complète

Consigne

1) Ajoutez une perte ErreurQuadratique (avant : mean((Z − y)²), arrière : 2(Z − y)/n) et entraînez un réseau [1, 32, 32, 1] à approcher y = sin(3x) + 0,3x² sur [−2, 2]. Tracez la courbe apprise vs la vraie. 2) Vérifiez numériquement le gradient de tous les paramètres du réseau complet (pas seulement une couche), avec une erreur relative < 1e-5. 3) Combien de neurones cachés faut-il au minimum pour une erreur RMS < 0,05 ?

Correction (extrait)

class ErreurQuadratique:
    def avant(self, Z, y): self.d = Z - y; return (self.d**2).mean()
    def arriere(self): return 2 * self.d / self.d.size
net = Reseau([1, 32, 32, 1]); net.perte = ErreurQuadratique(); opt = Adam(net.parametres(), lr=5e-3)
for e in range(2000):
    net.perte.avant(net.avant(x), y); net.arriere(); opt.pas()
print("RMS :", np.sqrt(((net.avant(x) - y)**2).mean()).round(4))

def verifier_reseau(net, X, y, h=1e-5):
    net.perte.avant(net.avant(X), y); net.arriere(); pire = 0
    for c, n in net.parametres():
        P = getattr(c, n); G = getattr(c, "d" + n)
        for idx in rng.choice(P.size, min(20, P.size), replace=False):
            i = np.unravel_index(idx, P.shape)
            P[i] += h; Lp = net.perte.avant(net.avant(X), y); P[i] -= 2 * h; Lm = net.perte.avant(net.avant(X), y); P[i] += h
            pire = max(pire, abs((Lp - Lm) / (2 * h) - G[i]) / (abs(G[i]) + 1e-8))
    return pire
print("erreur relative max :", f"{verifier_reseau(net, x[:16], y[:16]):.1e}")

05 / Défis

Défi ★★ — Un CNN minimal et un autoencodeur

Consigne

1) Implémentez une couche Conv2D (K noyaux 3×3, passe avant et arrière — l’arrière du noyau est la corrélation entrée ⋆ dOut, celle de l’entrée est la convolution « pleine » de dOut par le noyau retourné), une couche Aplatir, et entraînez [Conv(8) → ReLU → Aplatir → Affine(10)] sur mini-MNIST. Comparez au MLP : exactitude, nombre de paramètres, robustesse à un décalage de 2 pixels des images de test. 2) Autoencodeur [64 → 16 → 2 → 16 → 64] avec erreur quadratique : tracez les 1200 images dans le plan des 2 neurones centraux, colorées par chiffre. Les classes se séparent-elles sans étiquettes ?

Correction (extrait : Conv2D)

class Conv2D:
    def __init__(self, K, k=3): self.W = rng.normal(0, np.sqrt(2 / (k * k)), (K, k, k)); self.b = np.zeros(K); self.k = k
    def avant(self, X):                                   # X : (n, 8, 8) → (n, K, 6, 6)
        self.X = X; n, H, W = X.shape; k = self.k; K = len(self.W)
        self.fen = np.lib.stride_tricks.sliding_window_view(X, (k, k), axis=(1, 2))   # (n, 6, 6, k, k)
        return np.einsum("nijab,kab->nkij", self.fen, self.W) + self.b[None, :, None, None]
    def arriere(self, dZ):                                # dZ : (n, K, 6, 6)
        self.dW = np.einsum("nijab,nkij->kab", self.fen, dZ); self.db = dZ.sum((0, 2, 3))
        dX = np.zeros_like(self.X); k = self.k
        for a in range(k):
            for b in range(k):
                dX[:, a:a + dZ.shape[2], b:b + dZ.shape[3]] += np.einsum("nkij,k->nij", dZ, self.W[:, a, b])
        return dX
class Aplatir:
    def avant(self, X): self.forme = X.shape; return X.reshape(len(X), -1)
    def arriere(self, d): return d.reshape(self.forme)

einsum et sliding_window_view évitent les boucles Python : c’est ainsi (avec en plus le « im2col ») que les bibliothèques transforment une convolution en produit matriciel. Pour l’autoencodeur : le plan des 2 neurones centraux est une réduction de dimension non linéaire apprise sans étiquettes — les chiffres forment des amas, préfiguration de l’apprentissage de représentations et des modèles génératifs (VAE).

05 / Défis

Défi ★★★ — Esprit prépa : normalisation par lots et le problème du gradient qui disparaît

Consigne

1) Entraînez des réseaux de profondeur 2, 6, 12, 20 (32 neurones par couche) avec des sigmoïdes au lieu de ReLU et une initialisation N(0, 0,1) : mesurez la norme du gradient de la première couche. Expliquez (dérivée de la sigmoïde ≤ 0,25, produit de 20 facteurs). 2) Refaites avec ReLU + He : que se passe-t-il ? 3) Implémentez la normalisation par lots (BatchNorm : centrer-réduire chaque activation sur le lot, puis γ·x̂ + β appris ; avant et arrière — la passe arrière est un exercice de dérivation à faire soigneusement, puis à vérifier numériquement). Montrez qu’elle permet d’entraîner le réseau sigmoïde de profondeur 20. 4) Lisez le résumé de l’article « Deep Residual Learning » (He et al., 2015) et expliquez en quoi les connexions résiduelles attaquent le même problème.

Correction (extrait : BatchNorm)

class BatchNorm:
    def __init__(self, m, eps=1e-5): self.W = np.ones(m); self.b = np.zeros(m); self.eps = eps   # W = γ, b = β
    def avant(self, X):
        self.mu = X.mean(0); self.var = X.var(0); self.std = np.sqrt(self.var + self.eps)
        self.xh = (X - self.mu) / self.std; return self.W * self.xh + self.b
    def arriere(self, dY):
        n = len(dY); self.dW = (dY * self.xh).sum(0); self.db = dY.sum(0)
        dxh = dY * self.W
        return (dxh - dxh.mean(0) - self.xh * (dxh * self.xh).mean(0)) / self.std

La formule de la passe arrière vient de ce que μ et σ dépendent de tout le lot : on dérive x̂ = (x − μ)/σ en tenant compte de ∂μ/∂x et ∂σ/∂x. La BatchNorm maintient les activations à une échelle constante à chaque couche, ce qui rend le conditionnement du problème indépendant de la profondeur ; les connexions résiduelles (y = x + f(x)) donnent au gradient un chemin direct (dérivée 1 + ∂f/∂x) qui ne s’atténue pas. Ensemble, elles ont permis de passer de 8 à 1000 couches. Le « pourquoi exactement ça marche » reste débattu (l’explication originale, la « covariate shift », est aujourd’hui contestée) : un bon exemple de question de recherche née de l’ingénierie.

06 / Vérification

On retire toutes les fonctions d’activation d’un réseau à 10 couches. Il devient :

Deux questions supplémentaires

1. Pourquoi vérifier les gradients numériquement ? Parce qu’une erreur de signe ou de transposée dans la passe arrière peut laisser le réseau « apprendre un peu » et passer inaperçue pendant des jours.

2. Que fait le dropout à l’inférence ? Rien : on l’éteint (et on a compensé l’échelle à l’entraînement en divisant par 1 − p).

Référence

Les mots à retenir

Mot	Définition
Neurone / couche	activation(w·x + b) / activation(Wx + b).
ReLU, sigmoïde, softmax	Non-linéarités ; softmax pour K classes.
Rétropropagation	Règle de la chaîne appliquée en arrière, en matrices.
Vérification de gradient	Comparer à des différences finies.
Mini-lot / epoch	Sous-échantillon par pas / passage complet sur les données.
Initialisation He / Xavier	Échelle des poids qui garde les activations stables.
Momentum / Adam	Optimiseurs avec inertie / pas adaptatif.
Dropout / arrêt anticipé	Régularisations.
Convolution	Noyau local partagé ; localité et invariance par translation.
BatchNorm / résiduel	Techniques qui permettent la grande profondeur.
Approximation universelle	Une couche cachée suffit en théorie ; la profondeur aide en pratique.

Pour continuer

Vous avez construit un réseau de neurones

Module suivant : le deep learning moderne — séquences, attention, transformeurs et grands modèles de langage : comment ils fonctionnent, implémentés en miniature.

À faire chez soi

Sur PC : pip install torch, réécrire ce module en PyTorch (nn.Linear, nn.ReLU, optim.Adam) et entraîner sur le vrai MNIST (torchvision.datasets.MNIST) : viser 98 %.
Suivre « micrograd » puis « makemore » (vidéos de Karpathy) en codant chaque ligne.
Lire le chapitre 6 de Nielsen sur les convolutions et l’article original de LeNet-5.

← L13 Sommaire L15 : Deep learning et transformeurs →