Calcul & Optimisation
“Des dérivées à la descente de gradient — le moteur qui entraîne chaque réseau de neurones”
Dérivées, dérivées partielles, règle de la chaîne (= rétropropagation) et descente de gradient. Puis Adam, momentum, scheduling — comment les réseaux apprennent vraiment.
Prérequis
Concepts Couverts
∑Formules Clés
Gradient
Vecteur des dérivées partielles — pointe dans la direction de la montée la plus raide
Règle de la Chaîne
La colonne vertébrale de la rétropropagation — composer les dérivées à travers les couches
Descente de Gradient
Se déplacer itérativement dans le sens opposé au gradient pour minimiser la perte L
Mise à Jour Adam
Descente de gradient avec taux d'apprentissage adaptatifs par paramètre (moments 1 et 2 corrigés du biais)
▶Simulation Interactive
L'Optimisation Fait Apprendre les Modèles
Entraîner un modèle ML est un problème d'optimisation : trouver les paramètres θ qui minimisent la fonction de perte L(θ). La descente de gradient est l'algorithme de base qui résout cela pour des problèmes avec des millions de paramètres où les solutions en forme fermée n'existent pas. La règle de la chaîne permet de calculer les gradients à travers des compositions arbitrairement profondes de fonctions — c'est la rétropropagation.
Un modèle GPT a ~175 milliards de paramètres. La descente de gradient met à jour TOUS simultanément en une seule passe arrière grâce à la règle de la chaîne.
Le Gradient comme Direction dans l'Espace des Paramètres
Imaginez la fonction de perte comme un paysage vallonné et vos paramètres comme votre position. Le gradient ∇L(θ) est une flèche pointant vers le haut. Aller dans la direction OPPOSÉE (−η∇L) descend — vers une perte plus faible. Le taux d'apprentissage η contrôle la taille du pas : trop grand et vous rebondissez (divergence), trop petit et l'entraînement prend une éternité. Adam résout cela en maintenant un taux d'apprentissage séparé pour chaque paramètre basé sur son historique de gradients.
Intuition pour la règle de la chaîne : si le changement de température affecte la pression, et que la pression affecte le volume, comment la température affecte-t-elle le volume ? Multipliez les sensibilités individuelles.
Optimiseur Adam — Étape par Étape
Initialiser : θ, m₀=0 (1er moment), v₀=0 (2e moment), t=0, β₁=0.9, β₂=0.999, ε=1e-8
Calculer le gradient : g_t = ∇_θ L(θ_{t-1})
Mettre à jour le 1er moment biaisé (momentum) : m_t = β₁·m_{t-1} + (1-β₁)·g_t
Mettre à jour le 2e moment biaisé (échelle adaptative) : v_t = β₂·v_{t-1} + (1-β₂)·g_t²
Correction du biais : m̂_t = m_t/(1-β₁ᵗ), v̂_t = v_t/(1-β₂ᵗ)
Mise à jour des paramètres : θ_t = θ_{t-1} - η·m̂_t / (√v̂_t + ε)
Intuition : m̂_t est une moyenne mobile des gradients (momentum). √v̂_t normalise par la magnitude — les variables à grands gradients reçoivent des taux d'apprentissage plus petits.
Descente de Gradient de Zéro
import numpy as np import matplotlib.pyplot as plt class="tok-comment"># ── Dérivées numériques (éducatif) ──────────────────────────────────────────── def gradient_numerique(f, x, h=class="tok-num">1e-5): class="tok-str">"""Approximation par différence centrale : (f(x+h) - f(x-h)) / 2h""" grad = np.zeros_like(x, dtype=float) for i in range(len(x)): x_plus = x.copy(); x_plus[i] += h x_minus = x.copy(); x_minus[i] -= h grad[i] = (f(x_plus) - f(x_minus)) / (class="tok-num">2 * h) return grad class="tok-comment"># ── class="tok-num">1. Descente de gradient sur une quadratique simple ──────────────────────── def perte(theta): return (theta[class="tok-num">0] - class="tok-num">3)**class="tok-num">2 + (theta[class="tok-num">1] + class="tok-num">1)**class="tok-num">2 class="tok-comment"># minimum en (class="tok-num">3,-class="tok-num">1) def grad_perte(theta): return np.array([class="tok-num">2*(theta[class="tok-num">0]-class="tok-num">3), class="tok-num">2*(theta[class="tok-num">1]+class="tok-num">1)]) theta = np.array([class="tok-num">0., class="tok-num">0.]) lr = class="tok-num">0.1 historique = [theta.copy()] for etape in range(class="tok-num">50): g = grad_perte(theta) theta -= lr * g historique.append(theta.copy()) if np.linalg.norm(g) < class="tok-num">1e-6: print(fclass="tok-str">"Convergé à l'étape {etape}") break print(fclass="tok-str">"θ final : {theta.round(class="tok-num">4)}") class="tok-comment"># ≈ [class="tok-num">3, -class="tok-num">1] class="tok-comment"># ── class="tok-num">2. Optimiseur Adam ──────────────────────────────────────────────────────── def adam(fn_grad, theta_init, lr=class="tok-num">0.01, n_etapes=class="tok-num">100, b1=class="tok-num">0.9, b2=class="tok-num">0.999, eps=class="tok-num">1e-8): theta = theta_init.copy().astype(float) m, v = np.zeros_like(theta), np.zeros_like(theta) historique = [theta.copy()] for t in range(class="tok-num">1, n_etapes+class="tok-num">1): g = fn_grad(theta) m = b1*m + (class="tok-num">1-b1)*g v = b2*v + (class="tok-num">1-b2)*g**class="tok-num">2 m_hat = m / (class="tok-num">1 - b1**t) v_hat = v / (class="tok-num">1 - b2**t) theta -= lr * m_hat / (np.sqrt(v_hat) + eps) historique.append(theta.copy()) return theta, historique theta_adam, hist_adam = adam(grad_perte, np.array([class="tok-num">0., class="tok-num">0.]), lr=class="tok-num">0.1) print(fclass="tok-str">"θ Adam : {theta_adam.round(class="tok-num">4)}") class="tok-comment"># ── class="tok-num">3. Règle de la chaîne en action (rétropropagation manuelle) ─────────────── class="tok-comment"># f(x) = (2x + class="tok-num">1)^class="tok-num">2. df/dx = class="tok-num">2 * (2x+class="tok-num">1) * class="tok-num">2 = class="tok-num">4*(2x+class="tok-num">1) x = class="tok-num">3.0 class="tok-comment"># Passe avant u = class="tok-num">2*x + class="tok-num">1 class="tok-comment"># u = class="tok-num">7 f = u**class="tok-num">2 class="tok-comment"># f = class="tok-num">49 class="tok-comment"># Passe arrière (règle de la chaîne) df_du = class="tok-num">2*u class="tok-comment"># = class="tok-num">14 du_dx = class="tok-num">2 class="tok-comment"># constante df_dx = df_du * du_dx class="tok-comment"># = class="tok-num">28 print(fclass="tok-str">"df/dx en x=class="tok-num">3 : {df_dx}") class="tok-comment"># analytique : class="tok-num">4*(class="tok-num">2*class="tok-num">3+class="tok-num">1) = class="tok-num">28 ✓ class="tok-comment"># ── class="tok-num">4. Sensibilité au taux d'apprentissage ──────────────────────────────────── fig, axes = plt.subplots(class="tok-num">1, class="tok-num">3, figsize=(class="tok-num">12,class="tok-num">3)) for ax, lr_val in zip(axes, [class="tok-num">0.01, class="tok-num">0.1, class="tok-num">0.9]): theta = np.array([class="tok-num">0.]) pertes = [] for _ in range(class="tok-num">100): g = class="tok-num">2*(theta[class="tok-num">0] - class="tok-num">5) theta[class="tok-num">0] -= lr_val * g pertes.append((theta[class="tok-num">0]-class="tok-num">5)**class="tok-num">2) ax.semilogy(pertes) ax.set_title(fclass="tok-str">"lr = {lr_val}") ax.set_xlabel(class="tok-str">"Étapes") ax.set_ylabel(class="tok-str">"Perte") plt.tight_layout() plt.show() class="tok-comment"># lr=class="tok-num">0.01 : lent, lr=class="tok-num">0.1 : parfait, lr=class="tok-num">0.9 : oscille
Minima Locaux vs Points Selles — Ce qui Ralentit Vraiment l'Entraînement
Dans les paysages de perte de haute dimension (les réseaux modernes ont des millions de paramètres), les vrais minima locaux sont rares — la plupart des points 'bloqués' sont des points selles. La descente de gradient avec bruit (SGD) échappe naturellement aux points selles. Les problèmes pratiques plus importants sont : (1) Gradients explosifs dans les réseaux profonds — utilisez le clipping. (2) Gradients évanescents dans les RNN — utilisez LSTM/GRU. (3) Mauvais conditionnement — utilisez la normalisation par lots ou l'initialisation des poids.
Pour les problèmes convexes (régression linéaire, régression logistique, SVM), la descente de gradient est garantie de trouver le minimum global. Pour les réseaux de neurones, elle trouve un 'bon' bassin.
?Vérification des Connaissances
La progression est sauvegardée dans votre navigateur — aucun compte requis.
Besoin d'un ingénieur IA ou data scientist ?
Je conçois des modèles ML sur mesure, des agents IA, de la vision par ordinateur et de l'automatisation — de l'idée à la production.