Module L31 · Partie K · Ingénierie de l’IA

Les familles de réseaux : ce qui les distingue vraiment.

MLP, CNN, RNN/LSTM, transformers, GNN, autoencodeurs, GAN, modèles de diffusion, modèles à état (SSM), mixtures d’experts : chaque famille est un biais inductif — une hypothèse sur la structure des données codée dans l’architecture — avec un coût, une façon de s’entraîner et un domaine où elle gagne. Ce chapitre les met côte à côte, mathématiquement (invariances, équivariances, complexité, objectifs) et pratiquement (quand choisir laquelle), avec des implémentations minimales et les articles fondateurs.

Durée : 3 séances · Prérequis : L14, L15, L25. Objectifs : formuler le biais inductif de chaque famille ; connaître leurs complexités et leurs objectifs d’entraînement ; implémenter une convolution, une cellule GRU, une couche de graphe, une étape de diffusion ; choisir une architecture pour un problème donné ; lire les articles fondateurs.

Ce que vous saurez faire à la fin

Expliquer équivariance par translation (CNN), permutation (GNN, attention), et ce que cela implique en données.
Comparer RNN, transformer et SSM en coût par token et en portée de la mémoire.
Décrire les objectifs : supervision, reconstruction (AE), adversarial (GAN), débruitage (diffusion), contraste (CLIP).
Choisir, avec arguments, entre un CNN et un ViT, un LSTM et un transformer, un modèle discriminatif et génératif.

Fiche de cours · Définitions

Définitions

Définition (biais inductif). Ensemble d’hypothèses qu’un modèle fait sur la fonction à apprendre, indépendamment des données : localité et invariance par translation (CNN), traitement séquentiel avec état (RNN), interactions tout-à-tout sans ordre (attention), structure de graphe (GNN). Un bon biais réduit les données nécessaires ; un mauvais plafonne la performance.

Définition (invariance, équivariance). f est invariante par une transformation g si f(g·x) = f(x) (classification : l’étiquette ne change pas si l’image est translatée) ; équivariante si f(g·x) = g·f(x) (segmentation : la carte de sortie se translate avec l’entrée). Une convolution est équivariante par translation ; un pooling global rend invariant.

Définition (familles). MLP : couches denses. CNN : convolutions + pooling (images, signaux 1D, séries). RNN/LSTM/GRU : état h_t = f(h_t−1, x_t) (séquences, streaming). Transformer : attention (séquences, ensembles, images en patchs). GNN : passage de messages entre nœuds voisins. Autoencodeur (VAE) : compresser puis reconstruire ; latent probabiliste. GAN : générateur contre discriminateur. Diffusion : apprendre à débruiter, générer en inversant le bruit. SSM (Mamba) : récurrence linéaire à paramètres dépendant de l’entrée, calculable en parallèle. MoE : plusieurs sous-réseaux experts, un routeur en active quelques-uns par token.

Définition (discriminatif, génératif). Discriminatif : modélise p(y | x) (classifier, régresser). Génératif : modélise p(x) ou p(x | y) et peut échantillonner (images, texte, audio). Un LLM est génératif ; un classifieur d’images est discriminatif ; un VAE est les deux (encodeur discriminatif, décodeur génératif).

Définition (champ réceptif). Ensemble des entrées qui influencent une sortie. CNN : croît linéairement avec la profondeur (k par couche) ; RNN : tout le passé (en théorie) ; attention : tout le contexte en une couche.

Définition (apprentissage auto-supervisé, contrastif). Créer des étiquettes à partir des données elles-mêmes : prédire le token masqué (BERT), le suivant (GPT), reconstruire des patchs (MAE), rapprocher deux vues d’une même image et éloigner les autres (SimCLR, CLIP pour image-texte).

Fiche de cours · Formules

Le tableau comparatif à connaître

Famille	Opération clé	Coût par couche (n éléments, d dims)	Biais inductif	Mémoire / portée	Parallélisme
MLP	h = φ(Wx + b)	O(d²)	Aucun	—	Total
CNN	(x ∗ K)(i) = Σ_u x(i+u)K(u)	O(n·k·C_in·C_out)	Localité, équivariance translation, partage de poids	Champ réceptif ∝ profondeur	Total
RNN (GRU/LSTM)	h_t = f(h_t−1, x_t)	O(n·d²)	Ordre, causalité, état borné	Théoriquement infinie, pratiquement ~100 pas	Séquentiel en t
Transformer	softmax(QKᵀ/√d)V	O(n²·d + n·d²)	Aucun sur l’ordre (ajouté) ; tout-à-tout	Contexte entier, exact	Total (entraînement)
GNN (message passing)	h_v ← φ(h_v, ⊕_u∈N(v) ψ(h_u, e_uv))	O(\|A\|·d + \|S\|·d²)	Équivariance par permutation, localité de graphe	k sauts après k couches	Par couche
SSM (Mamba)	h_t = A_th_t−1 + B_tx_t, y_t = C_th_t	O(n·d·N)	Récurrence linéaire sélective	État compressé de taille N	Scan parallèle
MoE	y = Σ_i∈top-k g_i(x)·E_i(x)	k experts actifs sur E	Spécialisation	—	Total ; routage

Convolution 2D : (I ∗ K)(i, j) = Σ_u,v I(i+u, j+v)·K(u, v) ; paramètres k²C_inC_out ; champ réceptif après L couches k×k : 1 + L(k − 1)

GRU : z = σ(W_z[h, x]), r = σ(W_r[h, x]), h̃ = tanh(W[r⊙h, x]), h′ = (1 − z)⊙h + z⊙h̃

VAE : L = E_q(z|x)[log p(x|z)] − KL(q(z|x) ‖ p(z)) (ELBO) ; reparamétrisation z = μ + σ⊙ε

GAN : min_G max_D E_x[log D(x)] + E_z[log(1 − D(G(z)))]

Diffusion (DDPM) : x_t = √ᾱ_t x₀ + √(1 − ᾱ_t) ε ; perte E‖ε − ε_θ(x_t, t)‖² ; échantillonnage en inversant pas à pas

Contrastif (InfoNCE / CLIP) : L = −log [e^s(x,y⁺)/τ / Σ_j e^s(x,y_j)/τ] symétrisé image↔texte

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

Démonstrations à savoir refaire

Théorème 1 (équivariance de la convolution). Pour une translation T_a(x)(i) = x(i − a), on a (T_ax) ∗ K = T_a(x ∗ K). Réciproquement, toute application linéaire équivariante par translation (sur ℤ, avec bord périodique) est une convolution.

((T_ax) ∗ K)(i) = Σ_u x(i + u − a)K(u) = (x ∗ K)(i − a) = T_a(x ∗ K)(i). Réciproque : soit L linéaire équivariante, δ l’impulsion en 0 ; posons K = L(δ). Tout x s’écrit x = Σ_j x(j)T_jδ, donc L(x) = Σ_j x(j)L(T_jδ) = Σ_j x(j)T_jK : c’est une convolution par K. Ainsi, imposer l’équivariance par translation force l’architecture convolutive — le CNN n’est pas un choix arbitraire mais la seule couche linéaire compatible avec l’hypothèse « la même détection partout ». Le partage des poids divise les paramètres par la taille de l’image et rend l’apprentissage possible avec peu de données (L14, exercice CNN vs MLP).

Théorème 2 (le gradient d’un RNN s’évanouit ou explose exponentiellement). Pour h_t = tanh(Wh_t−1 + Ux_t), ‖∂h_t/∂h₀‖ ≤ (‖W‖·max|tanh′|)^t ≤ ‖W‖^t ; les dépendances longues sont inapprenables si ‖W‖ < 1, instables si > 1.

Règle de la chaîne : ∂h_t/∂h₀ = Π_s=1^t diag(tanh′(z_s))·W, produit de t jacobiens ; la norme d’un produit est ≤ produit des normes, chacune ≤ ‖W‖ (tanh′ ≤ 1). Contrairement au MLP profond (L14, Théorème 3), on ne peut pas choisir des W différents par pas : la même matrice est appliquée t fois — d’où le comportement exponentiel systématique. LSTM/GRU ajoutent un chemin additif (cellule c_t = f_t⊙c_t−1 + i_t⊙c̃_t) dont le jacobien est diag(f_t) ≈ I quand la porte d’oubli est ouverte : le gradient traverse sans se multiplier par W (même idée que les connexions résiduelles). Le transformer contourne le problème en reliant directement toute paire de positions (chemin de longueur 1). Les SSM utilisent une récurrence linéaire avec des valeurs propres contrôlées (proches de 1, stables) : le produit reste borné par construction.

Théorème 3 (les GNN par passage de messages sont bornés par le test de Weisfeiler-Lehman). Deux graphes que le test WL 1-dimensionnel ne distingue pas reçoivent les mêmes représentations par tout GNN à agrégation de voisinage ; un GNN avec agrégation injective (GIN) atteint cette borne.

(Idée, Xu et al. 2019.) Le test WL raffine itérativement l’étiquette de chaque nœud par le multi-ensemble des étiquettes de ses voisins ; un GNN fait exactement cela avec des fonctions continues à la place des hachages. Par récurrence sur les couches, si deux nœuds ont la même étiquette WL après k itérations, ils ont la même représentation après k couches (les fonctions sont déterministes et appliquées aux mêmes multi-ensembles). Réciproquement, avec une agrégation injective sur les multi-ensembles (somme de MLP), le GNN sépare tout ce que WL sépare. Conséquence : un GNN ne distingue pas deux hexagones d’un cycle de 12 (mêmes degrés partout) ; remèdes : traits structurels (comptage de cycles), sous-graphes, ou positional encodings de graphe.

Théorème 4 (la perte de diffusion est une borne variationnelle). Apprendre ε_θ(x_t, t) à prédire le bruit ajouté revient (à pondération près) à maximiser une borne inférieure de log p_θ(x₀), comme le VAE.

(Idée, Ho et al. 2020.) Le processus avant q(x_t | x_t−1) ajoute du bruit gaussien ; le modèle apprend le processus inverse p_θ(x_t−1 | x_t). L’ELBO se décompose en somme de KL entre q(x_t−1 | x_t, x₀) (gaussienne calculable en fermé, de moyenne fonction de x_t et ε) et p_θ(x_t−1 | x_t) (gaussienne de moyenne μ_θ). La KL entre gaussiennes de même variance est proportionnelle à ‖μ_q − μ_θ‖², et en paramétrant μ_θ par une prédiction de ε, chaque terme devient c_t‖ε − ε_θ(x_t, t)‖². Ignorer les poids c_t (perte « simple ») marche mieux en pratique. Chaque pas est une régression stable — contrairement au GAN dont le jeu min-max n’a pas de fonction objectif monotone à suivre, d’où la domination de la diffusion en génération d’images depuis 2021.

01 / Implémenter

Convolution, GRU, couche de graphe : trois biais inductifs en quelques lignes

import numpy as np
rng = np.random.default_rng(0)
# 1) Convolution 2D "valid" et équivariance (Théorème 1)
def conv2d(I, K):
    H, W = I.shape; k = K.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] = (I[i:i + k, j:j + k] * K).sum()
    return out
I = rng.normal(0, 1, (12, 12)); K = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
a = conv2d(np.roll(I, 3, axis=1), K); b = np.roll(conv2d(I, K), 3, axis=1)
print("équivariance (translation de 3 colonnes, hors bords) :", np.allclose(a[:, 4:], b[:, 4:]))
# 2) Une cellule GRU et l'évanouissement du gradient (Théorème 2) : norme du jacobien produit après t pas, RNN simple vs GRU
def tanh_rnn_jac(W, t, x):
    h = np.zeros(len(W)); J = np.eye(len(W))
    for _ in range(t): z = W @ h + x; h = np.tanh(z); J = np.diag(1 - h ** 2) @ W @ J
    return np.linalg.norm(J, 2)
d = 16; x = rng.normal(0, 0.5, d)
for s in (0.5, 1.0, 1.5):
    W = rng.normal(0, s / np.sqrt(d), (d, d)); print(f"RNN tanh, ‖W‖≈{s:.1f} : ‖∂h_50/∂h_0‖ = {tanh_rnn_jac(W, 50, x):.2e}")
def gru_jac(t, oubli=0.95):                            # GRU avec porte z ≈ 1 − oubli : jacobien ≈ diag(1 − z) → 0,95^t (décroissance lente, contrôlée)
    return oubli ** t
print(f"GRU avec porte de mise à jour à 0,05 : ‖∂h_50/∂h_0‖ ≈ {gru_jac(50):.2f} — la mémoire survit 50 pas")
# 3) Une couche GNN (moyenne des voisins + MLP) et son invariance par permutation (renuméroter les nœuds ne change pas les sorties, à permutation près)
A = np.array([[0,1,1,0,0],[1,0,1,0,0],[1,1,0,1,0],[0,0,1,0,1],[0,0,0,1,0]], float); X = rng.normal(0, 1, (5, 3)); Wg = rng.normal(0, 1, (6, 4))
def gnn(A, X): D = A.sum(1, keepdims=True); agg = (A @ X) / np.maximum(D, 1); return np.maximum(0, np.hstack([X, agg]) @ Wg)
P = np.eye(5)[rng.permutation(5)]
print("équivariance par permutation :", np.allclose(gnn(P @ A @ P.T, P @ X), P @ gnn(A, X)))
print("sortie du graphe (somme des nœuds) invariante :", np.allclose(gnn(P @ A @ P.T, P @ X).sum(0), gnn(A, X).sum(0)))

01 / Implémenter

Génératif en 1D : VAE, GAN, diffusion sur la même loi — pour voir ce qui change

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(2)
# Données : mélange de deux gaussiennes en 1D. Trois méthodes génératives minimalistes (paramétrisations analytiques pour rester lisibles).
def donnees(n): return np.where(rng.random(n) < 0.6, rng.normal(-2, 0.5, n), rng.normal(2.5, 0.8, n))
X = donnees(4000)
# --- Diffusion (DDPM) 1D avec un "réseau" = régression sur des traits fixes ; illustre bruitage / débruitage ---
T = 50; beta = np.linspace(1e-3, 0.2, T); alpha = 1 - beta; abar = np.cumprod(alpha)
feats = lambda x, t: np.stack([np.ones_like(x), x, x**2, x**3, np.tanh(x), np.tanh(2*x - 1), np.tanh(2*x + 1), np.full_like(x, t / T), x * t / T], 1)
Xf = []; Yf = []
for t in range(T):
    eps = rng.normal(0, 1, len(X)); xt = np.sqrt(abar[t]) * X + np.sqrt(1 - abar[t]) * eps; Xf.append(feats(xt, t)); Yf.append(eps)
Xf, Yf = np.vstack(Xf), np.concatenate(Yf); w = np.linalg.lstsq(Xf, Yf, rcond=None)[0]                  # ε_θ(x_t, t) ≈ f(x_t, t)·w (moindres carrés)
def echantillonner_diffusion(n):
    x = rng.normal(0, 1, n)
    for t in range(T - 1, -1, -1):
        eps_hat = feats(x, t) @ w; x = (x - beta[t] / np.sqrt(1 - abar[t]) * eps_hat) / np.sqrt(alpha[t])
        if t > 0: x = x + np.sqrt(beta[t]) * rng.normal(0, 1, n)
    return x
# --- VAE 1D : encodeur q(z|x) = N(a x + b, s²), décodeur p(x|z) = N(c z + d, r²) ; ELBO maximisée par descente de gradient sur (a,b,s,c,d,r)
def elbo(p, x, n_eps=1):
    a, b, ls, c, d, lr = p; s, r = np.exp(ls), np.exp(lr); mu = a * x + b; z = mu + s * rng.normal(0, 1, (n_eps, len(x)))
    rec = -0.5 * ((x - (c * z + d)) ** 2 / r**2 + 2 * lr + np.log(2 * np.pi)); kl = 0.5 * (s**2 + mu**2 - 1 - 2 * ls)
    return (rec.mean(0) - kl).mean()
p = np.array([0.5, 0.0, 0.0, 1.0, 0.0, 0.0]); lr_ = 0.02
for it in range(300):                                                                            # gradient par différences finies (petit modèle)
    g = np.array([(elbo(p + e, X[:512]) - elbo(p - e, X[:512])) / 2e-4 for e in np.eye(6) * 1e-4]); p += lr_ * g
def echantillonner_vae(n): a, b, ls, c, d, lr = p; z = rng.normal(0, 1, n); return c * z + d + np.exp(lr) * rng.normal(0, 1, n)
fig, ax = plt.subplots(1, 3, figsize=(13, 3.2)); bins = np.linspace(-5, 6, 60)
ax[0].hist(X, bins, density=True, alpha=0.6, label="données"); ax[0].hist(echantillonner_diffusion(4000), bins, density=True, alpha=0.6, label="diffusion"); ax[0].legend(); ax[0].set_title("diffusion : deux modes reproduits")
ax[1].hist(X, bins, density=True, alpha=0.6, label="données"); ax[1].hist(echantillonner_vae(4000), bins, density=True, alpha=0.6, label="VAE linéaire"); ax[1].legend(); ax[1].set_title("VAE gaussien linéaire : une seule bosse floue")
xs = np.linspace(-5, 6, 200); ax[2].plot(xs, feats(xs, 25) @ w); ax[2].set_title("ε̂(x, t=25) : le champ de débruitage pousse vers les modes"); ax[2].axhline(0, color="gray", lw=0.5)
plt.tight_layout(); plt.show()
print("Le VAE à décodeur linéaire ne peut produire qu'une gaussienne (limite du modèle, pas de l'objectif) ; la diffusion apprend un champ de vecteurs qui ramène vers les données.")

02 / Choisir

Quelle famille pour quel problème : la grille de décision

Données	Tâche	Premier choix	Alternative	Pourquoi
Tableau (colonnes hétérogènes)	Classification / régression	Gradient boosting (XGBoost, LightGBM)	MLP avec embeddings de catégories	Sans structure spatiale, les arbres gagnent jusqu’à ~10⁵ lignes (Grinsztajn 2022)
Images	Classification, détection, segmentation	CNN pré-entraîné (ResNet, ConvNeXt) affiné	ViT/DINOv2 si beaucoup de données ou pré-entraînement fort	Équivariance = efficacité en données ; ViT dépasse avec ≥ 10⁶ images ou auto-supervision
Séries temporelles (capteurs)	Prévision, détection d’anomalie	CNN 1D / GRU ; modèles linéaires (DLinear) souvent compétitifs	Transformer temporel (PatchTST) si longues séquences	Peu de données par série ; les transformers sur-apprennent
Texte	Classification, extraction	Encodeur transformer affiné (BERT-like)	LLM zero/few-shot si peu de données	Pré-entraînement massif disponible
Texte	Génération, dialogue	LLM décodeur (L27)	—	—
Audio	ASR, classification	Whisper / wav2vec 2.0 (L30)	CNN sur log-mel pour des tâches fermées	—
Graphes (molécules, réseaux, scènes)	Propriétés de nœuds/graphes	GNN (GIN, GAT)	Transformer de graphe	Équivariance par permutation
Images/audio	Génération	Diffusion (latente)	GAN pour la vitesse, VAE pour la compression	Stabilité et qualité ; coût d’échantillonnage
Séquences très longues (10⁵–10⁶)	Tout	SSM / hybrides	Transformer avec attention creuse	Coût linéaire
Robotique : perception + commande	Politique	CNN/ViT + MLP ; diffusion policy	Transformer de trajectoires	L16, L21 ; les politiques par diffusion gèrent la multimodalité des actions

Règle d’ingénierie : commencer par le modèle le plus simple qui incorpore le bon biais (linéaire → arbres → CNN/pré-entraîné), mesurer, et n’augmenter la complexité que si la courbe d’apprentissage (L13) le justifie.

03 / Articles

Les articles fondateurs, par famille

Famille	Article	À retenir
CNN	LeCun et al., Gradient-based learning applied to document recognition, Proc. IEEE 1998 ; Krizhevsky et al., AlexNet, NeurIPS 2012 ; He et al., ResNet, CVPR 2016 — 1512.03385	Convolution + partage de poids ; GPU + données ; connexions résiduelles pour la profondeur
RNN	Hochreiter & Schmidhuber, LSTM, Neural Computation 1997 ; Cho et al., GRU, 2014 — 1406.1078	Portes = chemin additif pour le gradient (Théorème 2)
Transformer	Vaswani 2017 (L25) ; Dosovitskiy, ViT, 2021 — 2010.11929	Sans biais spatial : exige des données ou un pré-entraînement
GNN	Kipf & Welling, GCN, ICLR 2017 — 1609.02907 ; Xu et al., How Powerful are GNNs? (GIN), ICLR 2019 — 1810.00826	Théorème 3 (borne WL)
VAE	Kingma & Welling, Auto-Encoding Variational Bayes, ICLR 2014 — 1312.6114	ELBO + reparamétrisation
GAN	Goodfellow et al., Generative Adversarial Nets, NeurIPS 2014 — 1406.2661 ; Karras et al., StyleGAN, 2019	Jeu min-max ; instabilité et effondrement des modes
Diffusion	Ho et al., DDPM, NeurIPS 2020 — 2006.11239 ; Rombach et al., Latent Diffusion (Stable Diffusion), CVPR 2022 — 2112.10752	Théorème 4 ; diffuser dans un espace latent compressé
Contrastif	Chen et al., SimCLR, ICML 2020 — 2002.05709 ; Radford et al., CLIP, 2021 — 2103.00020	Représentations sans étiquettes ; alignement image-texte
SSM	Gu et al., S4, ICLR 2022 — 2111.00396 ; Gu & Dao, Mamba, 2023 — 2312.00752	Récurrence linéaire stable + sélectivité
MoE	Shazeer et al., Outrageously Large Neural Networks, ICLR 2017 — 1701.06538 ; Fedus et al., Switch Transformer, 2021 — 2101.03961	Paramètres ≫ calcul par token ; équilibrage du routage
Tableaux	Grinsztajn et al., Why do tree-based models still outperform deep learning on tabular data?, NeurIPS 2022 — 2207.08815	Le biais inductif des arbres convient aux données hétérogènes

TP guidé

TP — Même tâche, quatre familles (5 h)

Données. Un jeu d’images petit (CIFAR-10 ou vos photos de robot, 10 classes, 5 000 images) et un jeu de séries temporelles (accéléromètre du robot, 6 activités).
Images. PyTorch : MLP, petit CNN, ResNet-18 pré-entraîné affiné, ViT-small pré-entraîné (timm) affiné. Même budget de temps, 3 graines : exactitude, paramètres, temps, et exactitude en fonction de la fraction de données (10 %, 30 %, 100 %) — la courbe montre l’effet du biais inductif et du pré-entraînement.
Séries. GRU, CNN 1D, transformer léger, modèle linéaire : même protocole. Ajouter une évaluation sur des séquences 2× plus longues que celles d’entraînement (généralisation en longueur).
Génératif. Entraîner un petit DDPM sur MNIST (30 min GPU) et un VAE ; comparer visuellement et par FID (pytorch-fid) ; mesurer le coût d’échantillonnage.
Graphe. PyTorch Geometric : GCN vs GIN sur un jeu de molécules (MUTAG) ; construire deux graphes WL-équivalents et vérifier que les représentations coïncident (Théorème 3).
Livrable. Tableaux et courbes, une page « biais inductif observé » par famille, et une recommandation par type de données.

Exercices

Exercices auto-corrigés

Exercice 1 — Champ réceptif et paramètres

Écrivez champ_receptif(couches) pour une liste de (noyau k, stride s) : taille du champ réceptif de la dernière sortie (formule r_ℓ = r_ℓ−1 + (k_ℓ − 1)·Π_i<ℓ s_i), et parametres_cnn(canaux, k) pour une pile de convolutions k×k avec la liste des canaux (biais inclus).

Correction

def champ_receptif(couches):
    r, saut = 1, 1
    for k, s in couches: r += (k - 1) * saut; saut *= s
    return r
def parametres_cnn(canaux, k): return sum(k * k * ci * co + co for ci, co in zip(canaux, canaux[1:]))

Exercice 2 — Cellule GRU et mémoire

Implémentez gru_pas(h, x, P) (formules de la fiche, P = dict de matrices W_z, W_r, W agissant sur [h, x]) et vérifiez : avec z forcée près de 0 (biais très négatif sur W_z), l’état est conservé sur 100 pas ; avec z ≈ 1, l’état est réécrit à chaque pas.

Correction

def gru_pas(h, x, P):
    sig = lambda v: 1 / (1 + np.exp(-v)); hx = np.concatenate([h, x, [1.0]])
    z = sig(P["Wz"] @ hx); r = sig(P["Wr"] @ hx)
    h_tilde = np.tanh(P["W"] @ np.concatenate([r * h, x, [1.0]]))
    return (1 - z) * h + z * h_tilde

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Test de Weisfeiler-Lehman

Implémentez wl_couleurs(adj, k) : k raffinements des couleurs des nœuds (couleur initiale = degré ; nouvelle couleur = hachage de (couleur, multi-ensemble trié des couleurs des voisins)), renvoyant l’histogramme final des couleurs. Vérifiez que deux hexagones disjoints et un cycle de 12 sont indistinguables (même histogramme) alors qu’un cycle de 6 et un chemin de 6 le sont.

Correction

def wl_couleurs(adj, k=3):
    col = {v: ("d", len(adj[v])) for v in adj}
    for _ in range(k):
        col = {v: (col[v], tuple(sorted(col[u] for u in adj[v]))) for v in adj}
    return Counter(col.values())

Exercice 4 — Bruitage de diffusion

Écrivez abar(betas) (produit cumulé des 1 − β_t) et bruiter(x0, t, betas, eps) = √ᾱ_t x₀ + √(1 − ᾱ_t) ε ; vérifiez que la variance de x_t pour x₀ de variance 1 reste 1 (conservation) et que le rapport signal/bruit décroît vers 0.

Correction

def abar(betas): return np.cumprod(1 - betas)
def bruiter(x0, t, betas, eps): a = abar(betas)[t]; return np.sqrt(a) * x0 + np.sqrt(1 - a) * eps

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Pour classer 2 000 photos de pièces mécaniques en 5 classes, un stagiaire propose un ViT entraîné from scratch. Argumenter.

Correction. Un ViT n’a aucun biais spatial (Théorème 1 en négatif) : il doit apprendre la localité et l’invariance par translation à partir des données, ce qui demande ~10⁶ images (Dosovitskiy 2021) ; avec 2 000 images, il sur-apprendra. Options par ordre de préférence : (1) CNN pré-entraîné (ResNet-50, ConvNeXt) affiné avec augmentation — le biais convolutif + le pré-entraînement ImageNet donnent typiquement 90 %+ avec 400 images par classe ; (2) plongements d’un modèle auto-supervisé (DINOv2, un ViT pré-entraîné) + régression logistique — souvent aussi bon et 10× plus rapide à entraîner ; (3) ViT pré-entraîné affiné si (1) plafonne. « From scratch » est exclu par la courbe d’apprentissage attendue (L13) ; le prouver en 30 minutes : entraîner (1) et le ViT from scratch sur 10 %, 50 %, 100 % des données.

Exercice 2. Un flux de capteurs à 1 kHz doit être analysé en continu sur un microcontrôleur pour détecter une anomalie, avec une mémoire de 100 Ko. Transformer, GRU ou CNN 1D ?

Correction. Contraintes : streaming (une décision par échantillon ou par bloc), mémoire minuscule, calcul borné (L18). Transformer : coût O(n²) et cache KV croissant avec la fenêtre — inadapté. GRU : état de taille d fixe (quelques Ko), O(d²) par pas, causal par construction, latence nulle — le candidat naturel ; risque : mémoire pratique ~100 pas, suffisante pour des anomalies courtes. CNN 1D causal (dilaté, type WaveNet/TCN) : champ réceptif fixe (exercice 1), calcul parallèle sur un bloc, poids partagés (peu de paramètres), quantifiable en int8 — très bon aussi, et souvent plus stable à entraîner. Choix : TCN causal léger si les motifs ont une durée bornée connue ; GRU si la dépendance est de longueur variable. Dans les deux cas : quantification int8, virgule fixe, et validation du WCET.

Exercice 3. Pourquoi les modèles de diffusion ont-ils supplanté les GAN pour la génération d’images malgré un coût d’échantillonnage 10–50× supérieur ?

Correction. Le GAN optimise un jeu min-max sans objectif scalaire monotone : instabilités, effondrement des modes (le générateur ne couvre qu’une partie de la distribution), réglages fragiles ; la diffusion optimise une régression (Théorème 4), stable, avec une perte qui suit l’entraînement et couvre tous les modes (elle maximise une borne de la vraisemblance). Elle est aussi facilement conditionnable (texte, via attention croisée) et modulaire (guidance sans classifieur). Le coût d’échantillonnage a été réduit par la diffusion latente (Stable Diffusion : diffuser en 64×64×4 au lieu de 512×512×3), les solveurs à peu de pas (DDIM, DPM-Solver : 20 pas), la distillation (1–4 pas) — jusqu’à rejoindre le GAN en vitesse. Le GAN garde une niche : génération en un passage, très basse latence (super-résolution temps réel).

Vérification

Pourquoi un CNN apprend-il des images avec 100× moins de données qu’un MLP ?

Deux questions supplémentaires

1. Que borne le test WL pour les GNN ? Le pouvoir de distinction : deux graphes WL-équivalents ont les mêmes représentations quel que soit le GNN par passage de messages.

2. Pourquoi les LSTM ont-ils des portes ? Pour créer un chemin additif où le gradient n’est pas multiplié par W à chaque pas (Théorème 2).

Référence

Les mots à retenir

Mot	Définition
Biais inductif	Hypothèse structurelle codée dans l’architecture ; économise des données.
Équivariance	f(g·x) = g·f(x) ; convolution ↔ translation, GNN ↔ permutation.
Champ réceptif	Portée des entrées influençant une sortie.
Portes (LSTM/GRU)	Chemin additif contre l’évanouissement du gradient.
Passage de messages	Agrégation des voisins ; borné par Weisfeiler-Lehman.
ELBO	Borne variationnelle ; VAE et diffusion.
Diffusion	Apprendre à débruiter ; régression stable ; génération par inversion.
SSM / MoE	Récurrence linéaire sélective / experts routés.

Suite

Tout modèle se juge. Le chapitre le plus long de la partie : les métriques.

Classification, régression, classement, génération de texte, RAG, prompts, agents, calibration, robustesse, équité, coût : comment mesurer, comment se tromper, comment lire un classement public.

← L30 Sommaire L32 : métriques →