Descente de Gradient & Optimiseurs

Machine Learning

Data & IA

Explorer les algorithmes d’optimisation (SGD, Adam) pour trouver le minimum de la fonction de coût.

La descente de gradient est le mécanisme central de l’apprentissage : à chaque étape, on ajuste les paramètres dans le sens qui réduit l’erreur. Imaginez la fonction de perte comme un paysage montagneux — le but est d’atteindre le point le plus bas. On lâche une “boule” sur la pente, et elle roule vers le bas guidée par le gradient.

Deux réglages clés :

Le pas d’apprentissage (Learning Rate) : La taille des bonds. Trop petit → apprentissage lent. Trop grand → la boule rebondit sans jamais se stabiliser.
L’inertie (Momentum) : La boule garde un peu de son élan, ce qui lui permet de franchir les petits plateaux et de ne pas rester coincée dans une fausse vallée.

Les optimiseurs modernes automatisent ces réglages :

Adam : L’optimiseur par défaut aujourd’hui — il adapte automatiquement le pas pour chaque paramètre.
RMSprop : Stabilise les oscillations en ajustant le pas selon l’historique récent des gradients.
AdaGrad : Efficace quand certaines variables apparaissent rarement (données éparses).

Mécanisme des optimiseurs

La mise à jour des poids à chaque étape :

\[w \leftarrow w - \eta \cdot \nabla_w \mathcal{L}\]

\(\eta\) : le taux d’apprentissage (learning rate)
\(\nabla_w\) : le gradient de la perte par rapport aux poids

Adam adapte le pas pour chaque paramètre en maintenant deux moyennes mobiles — le gradient moyen (\(m_t\)) et le gradient carré moyen (\(v_t\)) :

\[\hat{w} = w - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}\]

\(\hat{m}_t, \hat{v}_t\) : moyennes mobiles corrigées du biais d’initialisation
\(\epsilon\) : constante de stabilité numérique (\(\approx 10^{-8}\))

Simulation de la Trajectoire d’Optimisation

Trajectoire d’Optimisation

L’inertie (Momentum) accumule les gradients passés pour accélérer dans les directions constantes et franchir les plateaux.

Inertie (β)

RMSprop adapte le taux d’apprentissage de chaque paramètre selon la moyenne mobile de la magnitude des gradients récents.

Décroissance (β)

AdaGrad adapte le pas selon l’historique accumulé des gradients depuis le début — efficace pour les caractéristiques éparses.

Taux (η)

Adam combine Momentum et RMSprop en maintenant à la fois une moyenne des gradients (1er moment) et de leurs carrés (2e moment).

Moment (β₁)

mutable optType = "momentum"

_optWatcher = {
  const w = createTabsetWatcher(
    ".opt-type-tabset",
    { "Momentum": "momentum", "RMSprop": "rmsprop", "AdaGrad": "adagrad", "Adam": "adam" },
    (val) => { mutable optType = val; }
  );
  invalidation.then(() => w.destroy());
  return null;
}

optParam = optType === "momentum" ? momentumParam
         : optType === "rmsprop"  ? rmspropParam
         : optType === "adagrad"  ? adagradParam
         : adamParam

_gradSim = {
  const { createGradientSurface } = await import("/assets/js/custom/gradient-surface.js");
  const sim = createGradientSurface("grad-graph", {
    lossF: (t1, t2) => t1 ** 4 / 4 - t1 ** 2 / 2 + t2 ** 2 / 2 + 0.1 * t1,
    gradF: (t1, t2) => [t1 ** 3 - t1 + 0.1, t2],
    startPos: [1.8, 1.5],
    domain: { t1: [-2.2, 2.2], t2: [-2, 2] },
    criticalPoints: [
      { pos: [-1.0467, 0], type: 'global' },
      { pos: [ 0.9456, 0], type: 'local'  },
      { pos: [ 0.1010, 0], type: 'saddle' }
    ]
  });
  await sim.init();
  invalidation.then(() => sim.destroy());
  return sim;
}

// Stop animation whenever optimizer / parameters / step count change
_gradStop = {
  const sim = _gradSim;
  optType; optParam;
  if (sim) sim.stop();
  return null;
}

_gradCtrl = {
  const sim = _gradSim;
  let ctrl;
  ctrl = aptitek.createSimulationControl("#grad-sim-ctrl", {
    onStart: () => {
      if (!sim) return;
      if (sim.isPaused) {
        sim.resume(200, () => ctrl.setState("idle"));
      } else {
        sim.play(optType, optParam, 200, () => ctrl.setState("idle"));
      }
    },
    onPause:   () => sim && sim.pause(),
    onStop:    () => sim && sim.stop(),
    onRestart: () => sim && sim.play(optType, optParam, 200, () => ctrl.setState("idle"))
  }, invalidation);
  return ctrl;
}