Réseaux de neurones : comment l'optimisation converge réellement

L’explication la plus populaire de l’apprentissage automatique montre une bille qui descend dans un bol.

La hauteur représente la perte.

La position représente les paramètres.

Le gradient indique la pente.

La bille roule jusqu’au fond.

Cette image explique une idée locale utile, mais elle devient trompeuse si on la prend au pied de la lettre.

Un réseau moderne peut contenir des millions ou des milliards de paramètres.

Sa fonction de perte vit dans un espace dont personne ne peut visualiser directement la géométrie.

Il existe des directions presque plates, des symétries qui produisent la même fonction, des cols, des couloirs, des vallées connectées et des changements de courbure.

L’algorithme n’observe souvent qu’un mini-lot de données.

Le gradient est donc bruité.

Les paramètres sont stockés avec une précision finie.

Le calcul est distribué sur de nombreux accélérateurs.

Malgré tout, l’entraînement fonctionne.

La vraie question n’est donc pas seulement :

« Comment descend-on une pente? »

Elle est :

« Pourquoi une suite de décisions locales et imparfaites trouve-t-elle des fonctions utiles dans un espace aussi immense? »

Le mot convergence possède plusieurs sens.

Convergence de la perte

La perte d’entraînement cesse de diminuer rapidement.

Convergence du gradient

La norme du gradient devient petite.

Convergence des paramètres

Les poids se rapprochent d’une limite.

Convergence de la fonction

Les prédictions changent de moins en moins, même si les paramètres bougent encore.

Convergence statistique

La distribution des mises à jour ou la moyenne des paramètres devient stable.

Convergence de généralisation

La performance sur des données nouvelles se stabilise.

Ces notions peuvent diverger.

Deux réseaux aux paramètres différents peuvent représenter presque la même fonction.

Une permutation de neurones cachés peut changer le vecteur de poids sans changer la sortie.

Avec batch normalization ou d’autres symétries d’échelle, de nombreux points représentent des fonctions équivalentes.

Le paramètre n’est donc pas toujours l’objet scientifique le plus pertinent.

Un réseau peut s’écrire :

$f_{\theta}$(x)

où :

• x est l’entrée;
• theta contient tous les paramètres;
• $f_{\theta}$ est la fonction calculée.

Pour un exemple ($x_{i}$, $y_{i}$), une perte élémentaire est :

$\ell(f_\theta(x_i),y_i)$

Le risque empirique moyen est :

$L(\theta)=\frac{1}{N}\sum_i\ell(f_\theta(x_i),y_i)$

L’entraînement cherche un theta dont L est faible.

Mais plusieurs complications apparaissent.

La fonction n’est généralement pas convexe en theta.

Le jeu d’entraînement n’est qu’un échantillon.

Une faible perte empirique ne garantit pas une faible erreur future.

Les paramètres peuvent être fortement redondants.

Le gradient est :

∇_theta L

Chaque composante indique comment une petite variation d’un paramètre modifie la perte au premier ordre.

La mise à jour de descente de gradient est :

$\theta_{t+1}=\theta_t-\eta\nabla L(\theta_t)$

où eta est le taux d’apprentissage.

La rétropropagation calcule efficacement ce gradient par application répétée de la règle de chaîne.

Elle ne constitue pas l’optimiseur.

Elle fournit au contraire l’information utilisée par l’optimiseur.

Cette distinction est importante :

• backprop calcule le gradient;
• SGD, AdamW ou Muon déterminent la mise à jour.

Considérons :

$L(\theta)=\frac12\theta^T H\theta$

avec H symétrique positive.

Le gradient est :

$\nabla L(\theta)=H\theta$

La mise à jour devient :

$\theta_{t+1}=(I-\eta H)\theta_t$

Dans la base des vecteurs propres de H, chaque direction évolue séparément :

$z_{t+1,i}=(1-\eta\lambda_i)z_{t,i}$

où $\lambda_{i}$ est une valeur propre.

La convergence exige :

$|1-\eta\lambda_i|<1$

pour toutes les directions.

Ainsi :

$0<\eta<\frac2{\lambda_{\max}}$

Cette formule simple montre pourquoi la plus grande courbure limite le pas.

La Hessienne est la matrice :

$H(\theta)=\nabla^2 L(\theta)$

Elle décrit la variation locale du gradient.

Pour une direction v :

v^T H v

mesure la courbure directionnelle.

Valeur propre positive : courbure locale vers le haut.

Valeur propre négative : direction de descente depuis un col.

Valeur propre proche de zéro : direction plate.

Dans un réseau, la Hessienne est énorme.

On ne la construit généralement pas explicitement.

On utilise :

• produits Hessienne-vecteur;
• méthode de puissance;
• Lanczos;
• approximations diagonales;
• Fisher empirique;
• matrices par blocs.

La Hessienne locale ne décrit pas toute la géométrie globale.

Supposons une vallée étroite.

La courbure est forte transversalement et faible longitudinalement.

Le gradient pointe surtout vers les parois.

La descente traverse la vallée, puis revient.

Elle avance lentement dans la direction utile.

Le conditionnement peut être mesuré par :

$\kappa=\frac{\lambda_{\max}}{\lambda_{\min}}$

pour une quadratique positive définie.

Un grand kappa produit une forte anisotropie.

Un seul taux d’apprentissage doit respecter la direction la plus raide.

Il devient alors trop petit pour les directions plates.

C’est une raison d’utiliser momentum, préconditionnement ou normalisation.

Avec un pas trop petit :

• la perte diminue;
• l’entraînement est stable;
• le coût en calcul devient élevé.

Avec un pas modéré :

• la descente est rapide;
• des oscillations contrôlées peuvent apparaître.

Avec un pas trop grand :

• la perte oscille fortement;
• les paramètres peuvent diverger;
• les valeurs numériques peuvent exploser.

Dans un réseau réel, la limite locale change pendant l’entraînement.

La courbure elle-même évolue.

Un schedule adapte donc eta au temps.

Le taux d’apprentissage est souvent l’hyperparamètre le plus déterminant.

Le momentum de Polyak introduit une vitesse :

$v_{t+1}=\mu v_t+g_t$

$\theta_{t+1}=\theta_t-\eta v_{t+1}$

où :

• mu est le coefficient de momentum;
• $g_{t}$ est le gradient ou son estimation.

Le momentum accumule les directions persistantes.

Dans une vallée :

• les oscillations transversales peuvent s’annuler;
• la direction longitudinale s’accumule.

La dynamique devient de second ordre.

Pour une quadratique, chaque direction suit une récurrence :

$z_{t+1}=(1+\mu-\eta\lambda)z_t-\mu z_{t-1}$

Le polynôme caractéristique peut avoir des racines complexes.

Dans une projection 2D, la trajectoire peut alors tourner en convergeant.

Voilà l’une des origines réelles d’une spirale d’optimisation.

Mais si mu ou eta sont mal choisis, la même inertie amplifie les oscillations.

Le momentum de Nesterov évalue le gradient à un point anticipé.

Une écriture courante est :

$v_{t+1}=\mu v_t-\eta\nabla L(\theta_t+\mu v_t)$

$\theta_{t+1}=\theta_t+v_{t+1}$

L’idée n’est pas de prédire réellement le futur.

Elle corrige la trajectoire à partir d’une position extrapolée.

Dans les problèmes convexes, Nesterov obtient des taux d’accélération théoriques importants.

Dans les réseaux profonds, son comportement dépend du bruit, des schedules et de la paramétrisation.

Le gradient complet est :

$g(\theta)=\frac1N\sum_i\nabla\ell_i(\theta)$

SGD utilise un mini-lot B :

$g_B(\theta)=\frac{1}{|B|}\sum_{i\in B}\nabla\ell_i(\theta)$

On peut écrire :

$g_B=g+\xi$

où xi est le bruit d’échantillonnage.

Ce bruit n’est pas nécessairement isotrope ni gaussien.

Sa covariance dépend :

• des exemples;
• du modèle;
• de la position;
• de la taille du lot.

Le bruit peut :

• aider à quitter certaines régions;
• empêcher une convergence ponctuelle;
• explorer une vallée;
• agir comme régularisation implicite;
• dégrader la stabilité.

SGD est donc à la fois un optimiseur et un système dynamique stochastique.

Un petit batch donne :

• gradients plus bruités;
• plus de mises à jour par époque;
• moins de parallélisme;
• parfois meilleure généralisation;
• variabilité accrue.

Un grand batch donne :

• estimation plus précise;
• meilleur usage du matériel;
• moins de mises à jour;
• besoin d’ajuster le taux;
• rendement décroissant au-delà d’une échelle critique.

La règle d’échelle linéaire propose souvent :

eta ∝ B

dans un certain régime.

Elle n’est pas universelle.

Le warmup devient souvent nécessaire lorsque le taux initial est grand.

Au-delà d’un batch critique, ajouter des exemples au lot réduit peu le nombre d’étapes et peut gaspiller du calcul.

La taille critique dépend du modèle, de la phase d’entraînement et de la statistique du gradient.

RMSProp conserve une moyenne des carrés du gradient. ^[1]

Adam combine :

• moyenne exponentielle du gradient;
• moyenne exponentielle de son carré;
• correction de biais.

Formules :

$m_t=\beta_1 m_{t-1}+(1-\beta_1)g_t$

$v_t=\beta_2 v_{t-1}+(1-\beta_2)g_t^2$

$\hat m_t=\frac{m_t}{1-\beta_1^t}$

$\hat v_t=\frac{v_t}{1-\beta_2^t}$

$\theta_{t+1}=\theta_t-\eta\frac{\hat m_t}{\sqrt{\hat v_t}+\epsilon}$

Chaque coordonnée reçoit un pas effectif différent.

Adam est donc un préconditionneur diagonal adaptatif avec momentum.

Il est particulièrement populaire pour les transformeurs et grands modèles de langage.

Dans SGD simple, une pénalité L2 et un weight decay peuvent coïncider sous certaines écritures. ^[2]

Dans un optimiseur adaptatif, mélanger le terme de régularisation au gradient le fait aussi passer par le préconditionneur.

AdamW découple la décroissance :

$\theta\leftarrow\theta-\eta\operatorname{update}_{\mathrm{Adam}}-\eta\lambda\theta$

Le weight decay agit directement sur les poids.

Cette distinction facilite le réglage et a amélioré les pratiques d’entraînement.

Mais AdamW n’est pas seulement « Adam plus régularisation ».

Son biais implicite et sa géométrie de mise à jour diffèrent de SGD.

L’article original d’Adam fournit des garanties sous certaines hypothèses.

Des travaux ultérieurs ont construit des exemples où les taux adaptatifs causent une non-convergence.

Le problème vient notamment de l’accumulation et de la variation du préconditionneur.

AMSGrad impose une seconde-moment maximale non décroissante :

$\hat v_t=\max(\hat v_{t-1},v_t)$

Cette modification rétablit certaines garanties.

Dans la pratique, Adam fonctionne très souvent.

Mais il faut distinguer :

• succès empirique;
• garantie théorique universelle.

Une surface de perte 2D est généralement créée en choisissant deux directions d_1 et d_2 :

$L(\alpha,\beta)=L(\theta_0+\alpha d_1+\beta d_2)$

Cette coupe dépend entièrement des directions.

Des directions aléatoires peuvent montrer un bol lisse.

Des directions alignées avec l’optimisation peuvent montrer une vallée.

La normalisation par filtre réduit certains effets d’échelle.

Mais aucune coupe 2D ne résume des milliards de dimensions.

La bonne pratique est d’afficher :

• point de référence;
• directions choisies;
• normalisation;
• échelle;
• trajectoire projetée;
• avertissement de projection.

Dans une haute dimension, un point critique avec quelques directions négatives est un col.

Les cols sont beaucoup plus nombreux que les minima stricts dans certains modèles aléatoires.

Les réseaux possèdent aussi des symétries.

Par exemple, permuter deux neurones d’une couche et permuter les poids correspondants de la suivante conserve la fonction.

Avec ReLU, certaines rescalings entre couches conservent également la sortie.

Ces symétries créent :

• familles de solutions équivalentes;
• directions plates;
• Hessienne singulière;
• vallées connectées.

Le « minimum » est souvent un ensemble.

Un réseau est surparamétré lorsqu’il possède plus de liberté que nécessaire pour interpoler les données.

Cela semble rendre le problème plus difficile.

Mais la surparamétrisation peut aussi :

• ouvrir de nombreux chemins vers une faible perte;
• éliminer certaines barrières;
• créer des variétés de solutions;
• rendre le gradient plus favorable.

Des travaux montrent que des solutions obtenues indépendamment peuvent parfois être reliées par des chemins de basse perte.

La perte n’est donc pas toujours une collection de bassins isolés.

Elle peut ressembler à un réseau de vallées.

Dans le régime d’interpolation, le réseau ajuste tous les exemples d’entraînement.

Cela ne signifie pas automatiquement qu’il apprend uniquement par cœur.

La structure de l’architecture, du gradient, des données et de l’initialisation favorise certaines solutions.

Le problème moderne devient :

parmi toutes les solutions qui interpolent, laquelle l’optimiseur choisit-il?

Cette question mène au biais implicite.

Un algorithme peut préférer certaines solutions sans régularisation explicite.

Pour une régression linéaire sous-déterminée, la descente de gradient depuis zéro converge vers la solution de norme euclidienne minimale.

Pour une classification linéaire séparable avec perte logistique, la norme des poids peut diverger tandis que leur direction converge vers le séparateur à marge maximale.

Dans les réseaux homogènes, des résultats apparentés relient gradient flow, marge et complexité.

Le choix de :

• optimiseur;
• paramétrisation;
• initialisation;
• batch;
• schedule;

influence donc la solution finale.

L’optimisation est aussi une forme de sélection de modèle.

Supposons des données séparables.

La perte logistique peut continuer à diminuer en augmentant la norme des poids.

Il n’existe pas nécessairement de minimiseur fini.

Pourtant, la direction :

w/||w||

peut converger.

C’est un exemple important où :

• les paramètres ne convergent pas;
• la fonction de décision converge;
• la marge augmente.

L’article doit utiliser cet exemple pour montrer que « convergence des poids » n’est pas toujours la bonne question.

Une intuition ancienne affirme que les minima plats généralisent mieux.

Une région plate tolère de petites perturbations de paramètres.

On mesure parfois la sharpness par :

$\lambda_{\mathrm{max}}$(H)

ou par l’augmentation maximale de perte dans une boule.

Cette idée est utile, mais délicate.

Une reparamétrisation peut changer la sharpness sans changer la fonction.

La taille de la perturbation, la norme et l’échelle comptent.

Il faut donc parler de mesures normalisées ou fonctionnelles.

Avec des réseaux ReLU, on peut multiplier les poids d’une couche par c et diviser la suivante par c sans changer la fonction.

La Hessienne en coordonnées de poids change pourtant.

On peut rendre un minimum arbitrairement plus « aigu » selon certaines métriques.

Cela ne détruit pas toute valeur de la sharpness.

Cela impose de préciser :

• paramétrisation;
• normalisation;
• voisinage;
• métrique;
• invariance.

Une notion géométrique sans choix de métrique est incomplète.

Sharpness-Aware Minimization cherche à minimiser la pire perte dans un voisinage :

$\min_\theta\max_{\lVert\epsilon\rVert\le\rho}L(\theta+\epsilon)$

L’algorithme pratique approxime la perturbation adversariale dans la direction du gradient.

Puis il met à jour les paramètres avec le gradient au point perturbé.

SAM favorise des régions où la perte reste faible autour du point.

Il peut améliorer la généralisation sur plusieurs tâches.

Mais il coûte environ une évaluation de gradient supplémentaire et son effet dépend du modèle, du rayon, de la normalisation et du protocole.

La théorie quadratique suggère qu’un taux stable doit satisfaire :

$\eta\lambda_{\max}<2$

Des expériences sur réseaux montrent un régime surprenant.

La plus grande valeur propre de la Hessienne monte près de :

2/eta

La perte peut osciller à court terme.

Pourtant, sa tendance à long terme continue à descendre.

Ce régime est appelé edge of stability.

Il indique que l’entraînement réel fonctionne souvent près d’une frontière dynamique.

Le réseau et la courbure coévoluent.

Les hypothèses d’une quadratique fixe ne suffisent plus.

La stabilité devient une propriété du système couplé :

paramètres + courbure + données + optimiseur.

Le taux d’apprentissage est rarement constant.

Warmup

Le taux augmente progressivement au début.

Cela aide lorsque :

• les activations et statistiques se stabilisent;
• le batch est grand;
• Adam possède des moments encore mal estimés;
• la précision numérique est fragile.

Décroissance en cosinus

Une formule typique est :

$\eta_t=\eta_{\min}+\frac12(\eta_{\max}-\eta_{\min})\left[1+\cos\left(\frac{\pi t}{T}\right)\right]$

Elle diminue doucement jusqu’à $\eta_{\mathrm{min}}$.

Restarts

Les warm restarts remontent périodiquement le taux.

Ils peuvent explorer de nouvelles régions.

Un schedule modifie à la fois :

• vitesse;
• bruit effectif;
• stabilité;
• solution sélectionnée.

Gradient clipping

Par norme :

g ← g min( 1, tau/||g|| )

Il limite les explosions.

Il est fréquent dans les réseaux récurrents et les grands transformeurs.

Il change néanmoins la direction statistique lorsque le seuil est atteint.

Mixed precision

Les calculs utilisent FP16 ou BF16 avec accumulation partielle en FP32.

FP16 possède une plage dynamique limitée.

Le loss scaling multiplie la perte avant backprop, puis redimensionne le gradient.

BF16 offre plus d’exposant mais moins de mantisse.

La stabilité numérique fait partie de l’optimisation réelle.

À grande échelle, plusieurs appareils calculent des gradients.

En data parallelism :

• chaque appareil traite un mini-lot;
• les gradients sont agrégés;
• les poids sont synchronisés.

Les défis incluent :

• communication;
• latence;
• batch global;
• précision;
• pannes;
• stragglers;
• sharding des états Adam;
• accumulation de gradient.

Adam stocke deux moments par paramètre.

Pour un modèle immense, les états optimiseur peuvent dépasser la taille des poids.

ZeRO et le sharding distribuent :

• paramètres;
• gradients;
• états.

L’optimisation devient alors aussi un problème d’architecture système.

Adam traite principalement chaque coordonnée selon ses moments diagonaux.

Muon considère certaines matrices de poids comme des objets structurés.

Une version pratique :

• calcule un momentum matriciel;
• applique une orthogonalisation approximative par itérations Newton–Schulz;
• normalise l’échelle de mise à jour;
• ajoute souvent un weight decay.

L’objectif est de produire une mise à jour mieux conditionnée au niveau matriciel.

Des travaux de 2025 ont rapporté des gains d’efficacité pour certains entraînements de transformeurs et de grands modèles.

Des analyses théoriques récentes étudient ses taux de convergence, sa taille critique de batch et son biais implicite.

Mais Muon reste récent.

Les résultats dépendent :

• de l’architecture;
• des dimensions matricielles;
• de l’échelle;
• du protocole;
• de la comparaison compute-equivalent;
• du traitement des paramètres non matriciels.

L’article doit le présenter comme une direction émergente, pas comme une conclusion définitive.

Une visualisation honnête doit distinguer quatre niveaux.

Niveau 1 : fonction jouet exacte

Une quadratique 2D dont toute la géométrie est connue.

Niveau 2 : coupe de surface

Deux directions dans l’espace des poids.

Niveau 3 : trajectoire projetée

PCA ou directions d’optimisation.

Niveau 4 : statistiques haute dimension

• perte;
• norme du gradient;
• courbure maximale;
• norme de mise à jour;
• cosinus gradient–update;
• bruit.

Une spirale visible au niveau 1 peut être exacte.

Au niveau 3, elle peut être un artefact de projection.

Chaque figure doit indiquer son niveau.

Le laboratoire comporte cinq modules.

Module 1 : vallée quadratique

Contrôles :

• $\lambda_{1}$;
• $\lambda_{2}$;
• rotation des axes;
• eta;
• point initial.

Comparer :

• gradient descent;
• momentum;
• Nesterov.

Afficher :

• trajectoire;
• perte;
• valeurs propres de la mise à jour;
• régime monotone, oscillatoire, spiralé ou divergent.

Module 2 : bruit SGD

Contrôles :

• batch;
• covariance du bruit;
• seed;
• learning rate.

Afficher :

• trajectoires multiples;
• moyenne;
• distribution finale;
• courbe de perte.

Module 3 : optimiseur

Comparer :

• SGD;
• momentum;
• RMSProp;
• Adam;
• AdamW;
• SAM simplifié;
• Muon jouet.

Afficher :

• nombre d’étapes;
• coût en gradients;
• conditionnement;
• trajectoire.

Module 4 : edge of stability

Utiliser une fonction non quadratique simple.

Afficher :

• perte;
• $\lambda_{\mathrm{max}}$;
• seuil 2/eta;
• oscillations;
• tendance moyenne.

Module 5 : vraie petite classification

Réseau minimal sur un jeu synthétique.

Afficher :

• frontière;
• train loss;
• validation loss;
• marge;
• norme;
• trajectoire PCA.

Les données doivent être clairement étiquetées comme synthétiques.

La spirale peut être réelle dans un modèle local de second ordre.

Elle peut apparaître lorsque les racines de la dynamique sont complexes et de module inférieur à 1.

Elle peut aussi apparaître dans une projection choisie.

Mais un entraînement profond complet ne « descend » pas universellement en spirale.

Le lien le plus solide avec le projet est plus large :

• itération;
• mémoire;
• oscillation;
• convergence;
• perte d’énergie effective;
• trajectoire dans un espace abstrait.

La rigueur consiste à montrer la spirale lorsqu’elle est mathématiquement présente et à refuser de l’imposer lorsqu’elle ne l’est pas.

L’optimisation des réseaux de neurones fonctionne parce que plusieurs structures se combinent.

Le gradient fournit une information locale.

Le momentum conserve une mémoire.

Le bruit explore.

Les préconditionneurs redimensionnent les directions.

La surparamétrisation ouvre des chemins.

Les schedules modifient le régime.

L’architecture et les données imposent un biais.

La précision numérique et le calcul distribué déterminent ce qui est réellement exécutable.

L’entraînement ne converge pas toujours vers un point isolé.

Il peut converger vers :

• une fonction;
• une direction;
• une vallée;
• une distribution;
• une région stable;
• un régime au bord de la stabilité.

La spirale n’est qu’une forme possible de cette dynamique.

La question la plus intéressante n’est pas « où est le minimum? »

Elle est :

« Quelle solution cette dynamique choisit-elle, et pourquoi cette solution fonctionne-t-elle sur des données qu’elle n’a jamais vues? »