2 🧠 Réseaux de Neurones Profonds

// ==========================================
// _ojs_bridge.qmd — OJS Global Namespace Bridge
//
// Include ONCE at the top of each chapter index.qmd:
//   {{< include ../../assets/_ojs_bridge.qmd >}}
//
// window.aptitek is set by an async `<script type="module">` in the page
// header (_quarto.yml include-in-header). That import may resolve AFTER
// OJS starts executing, causing `aptitek` to be undefined.
//
// Fix: return a Promise from this cell. OJS suspends all downstream cells
// until the promise resolves — the built-in, idiomatic solution for async
// dependencies in Observable JS.
//
// ✅ Zero-maintenance: adding a new export to index.js barrel is
//    instantly available — no edits to this file ever needed.
// ✅ Race-condition-safe: downstream cells never see undefined.
// ✅ Anti-double-definition: only ONE OJS name (`aptitek`) is defined.
// ==========================================
aptitek = {
  if (window.aptitek) return window.aptitek;
  return new Promise(resolve => {
    const check = () =>
      window.aptitek
        ? resolve(window.aptitek)
        : requestAnimationFrame(check);
    check();
  });
}

2.1 Morphologie générale du réseau

Un réseau de neurones artificiels fonctionne comme une ligne d’assemblage en usine : les données d’entrée passent d’une couche de travailleurs (les couches cachées) à une autre, chacun affinant et transformant la pièce jusqu’à ce que la couche de sortie délivre le produit fini.

L’apprentissage profond s’appuie sur une révolution architecturale où la topologie même du réseau définit sa capacité à capturer et traiter la complexité du monde réel. Le fonctionnement global de ce système peut être visualisé comme une vaste toile d’araignée multicouche organisée de manière très rigoureuse (IBM 2026; Rivals et al. 1995; Djeffal 2026a).

La structure globale en “toile d’araignée” :
Cette architecture s’inspire initialement de l’efficacité et du traitement massivement parallèle du cerveau humain.
Néanmoins, le réseau artificiel s’en démarque en étant une structure mathématique où le flux d’informations est strictement dirigé à travers des couches discrètes.
Cette topologie est cruciale car elle permet de fragmenter un problème global complexe en une succession de sous-problèmes résolubles localement (Blent.ai 2026; Wikipédia 2026c; Vergé 2009).
La couche d’entrée (Input Layer) :
Elle constitue le point de contact direct avec le monde extérieur en réceptionnant les vecteurs de caractéristiques bruts.
À titre d’exemple, si le réseau analyse une image, cette couche va réceptionner l’information visuelle (comme des pixels) pour la transformer en un signal numérique initial (MonCoachData 2026; SITAMS 2026; MathWorks 2026).
Les couches cachées (Hidden Layers) :
Ces strates intermédiaires représentent le cœur du traitement de l’information et apportent la fameuse “profondeur” au réseau.
Le consensus académique considère d’ailleurs que l’on entre dans le domaine du Deep Learning lorsqu’un réseau possède au moins quatre de ces couches (IBM 2026; Serge 2020; Mezghani 2022).
Sans entrer dans le détail de leurs composants, leur rôle global est d’opérer un apprentissage hiérarchique : les premières strates détectent des éléments très simples (comme des textures ou des bords), tandis que les strates suivantes synthétisent ces éléments pour identifier des concepts de plus en plus abstraits (Bodin and Recher 2026a; Elements of AI 2026; YouTube 2026a).
La couche de sortie (Output Layer) :
C’est l’ultime étape du réseau, celle qui est chargée de produire la réponse brute ou l’inférence finale.
Dans des scénarios de classification, elle utilise des mécanismes (comme la fonction Softmax) pour transformer les signaux reçus en une distribution de probabilités dont la somme est égale à 1, garantissant ainsi un résultat clair où les catégories sont mutuellement exclusives (Ultralytics 2026b; DataFranca 2026).

🕸️ Simulateur de Flux d’Information — Réseau Multicouche (RMN)

Lancer
Pause
Reset

Réseau au repos — En attente d’informations.

// Rendu réactif du graphe de réseau multicouche
renderMorphologyNetwork = {
  // États de la propagation avant de l'information
  const states = [
    { phase: "idle",          description: "Réseau au repos — En attente d'informations." },
    { phase: "input",         description: "Étape 1 : Les données d'entrée (x₁, x₂) entrent dans la couche d'entrée." },
    { phase: "hidden_prop",   description: "Étape 2 : Transmission des signaux pondérés vers la couche cachée." },
    { phase: "hidden_active",  description: "Étape 3 : Activation des neurones de la couche cachée." },
    { phase: "output_prop",   description: "Étape 4 : Transmission des signaux activés vers la couche de sortie." },
    { phase: "output_active",  description: "Étape 5 : Le neurone de sortie produit la prédiction finale." }
  ];

  // Initialisation de l'état global
  if (!window.morphologySimState) {
    window.morphologySimState = states[0];
  }

  // Machine à états de contrôle de la simulation
  const sm = new aptitek.StateMachine({
    states: states,
    interval: 1500,
    loop: true,
    onStateChange: (state, index) => {
      window.morphologySimState = state;

      // Refresh graph
      if (graph && typeof graph.refresh === "function") {
        graph.refresh();
      }
    }
  });

  const controller = new aptitek.SimulationController(sm, {
    play: "#btn-morphology-play",
    pause: "#btn-morphology-pause",
    reset: "#btn-morphology-reset",
    description: ".morphology-simulator .description-box"
  });

  // force graph nodes positions & connections
  const nodes = [
    { id: "x1", label: "Entrée x₁", fx: -160, fy: -50, shape: "pill",
      status: () => (window.morphologySimState?.phase !== "idle") ? "activeInput" : "default" },
    { id: "x2", label: "Entrée x₂", fx: -160, fy: 50, shape: "pill",
      status: () => (window.morphologySimState?.phase !== "idle") ? "activeInput" : "default" },
    { id: "h1", label: "Caché h₁",  fx: 0,    fy: -80, shape: "circle",
      status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_active" || phase === "output_prop" || phase === "output_active") ? "activeHidden" : "default";
      }
    },
    { id: "h2", label: "Caché h₂",  fx: 0,    fy: 0,   shape: "circle",
      status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_active" || phase === "output_prop" || phase === "output_active") ? "activeHidden" : "default";
      }
    },
    { id: "h3", label: "Caché h₃",  fx: 0,    fy: 80,  shape: "circle",
      status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_active" || phase === "output_prop" || phase === "output_active") ? "activeHidden" : "default";
      }
    },
    { id: "y",  label: "Sortie y",  fx: 160,  fy: 0,   shape: "diamond",
      status: () => (window.morphologySimState?.phase === "output_active") ? "activeOutput" : "default" }
  ];

  const links = [
    { source: "x1", target: "h1", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "x1", target: "h2", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "x1", target: "h3", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "x2", target: "h1", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "x2", target: "h2", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "x2", target: "h3", status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "hidden_prop" || phase === "hidden_active") ? "activeFlow" : "default";
      }
    },
    { source: "h1", target: "y",  status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "output_prop" || phase === "output_active") ? "activeFlow" : "default";
      }
    },
    { source: "h2", target: "y",  status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "output_prop" || phase === "output_active") ? "activeFlow" : "default";
      }
    },
    { source: "h3", target: "y",  status: () => {
        const phase = window.morphologySimState?.phase;
        return (phase === "output_prop" || phase === "output_active") ? "activeFlow" : "default";
      }
    }
  ];

  const graph = aptitek.createGraph("#plot-morphology-network", { nodes, links }, {
    nodeRadius: 22, fontSize: 9, height: 320,
    enableZoom: false, enablePan: false, enableDrag: false,
    zoomToFit: true, zoomToFitPadding: 45,
    cooldownTicks: Infinity,
    styles: {
      activeInput:  { nodeBg: "rgba(var(--sol-blue-rgb), 0.15)",    nodeBorder: "var(--sol-blue)",    nodeText: "var(--sol-blue)" },
      activeHidden: { nodeBg: "rgba(var(--sol-yellow-rgb), 0.15)",  nodeBorder: "var(--sol-yellow)",  nodeText: "var(--sol-yellow)" },
      activeOutput: { nodeBg: "rgba(var(--sol-green-rgb), 0.15)",   nodeBorder: "var(--sol-green)",   nodeText: "var(--sol-green)" },
      activeFlow:   { linkStroke: "var(--sol-cyan)", particles: 3, particleColor: "var(--sol-cyan)", particleSpeed: 0.025 }
    }
  });

  invalidation.then(() => {
    controller.destroy();
    if (graph && typeof graph.destroy === "function") {
      graph.destroy();
    }
  });

  return graph;
}

2.2 Anatomie du neurone artificiel

Un neurone artificiel est une petite calculatrice qui prend plusieurs informations en entrée, leur donne plus ou moins d’importance (les poids), ajoute une tendance de base (le biais), puis fait la somme de tout cela pour décider s’il transmet le signal.

Le neurone artificiel constitue l’atome de calcul fondamental de tout réseau de neurones (Wikipédia 2026b; Djeffal 2026a). Sa force réside dans l’application des concepts de poids (w) et de biais (b) — déjà introduits au chapitre 1 dans le cadre de l’optimisation générale — à l’échelle d’une unité de calcul unique. Pour en comprendre le fonctionnement de manière intuitive, on peut l’imaginer comme un magasin connecté situé au cœur d’une métropole complexe.

L’analogie du magasin connecté à la ville : Dans cette métropole, notre neurone est une enseigne commerciale dont les flux d’entrée proviennent de différents quartiers (les entrées x_i). Le but est de centraliser ces flux pour générer un indicateur global.
Les Poids (Weights) — Voies d’accès et trafic : Les poids (w_i) modulent l’importance de chaque entrée (EITCA Academy 2026; Djeffal 2026b; SITAMS 2026). Ils représentent l’état et la capacité des routes menant au magasin. Une route large et fluide possède un poids élevé ; une route fermée ou dégradée possède un poids proche de zéro, neutralisant l’influence du signal.
Le Biais (Bias) — Chiffre d’affaires de base : Le biais (b) s’apparente au revenu minimal garanti du magasin (EITCA Academy 2026; Inconnu 2026a). Il décale l’activation pour définir le niveau d’excitation minimal requis pour que le neurone transmette un signal, même lorsque les entrées sont nulles.
La Sommation Pondérée — Synthèse de l’unité de calcul : Le neurone combine ces éléments en effectuant la sommation pondérée de l’ensemble de ces signaux routiers pour obtenir la pré-activation (le résultat intermédiaire avant filtrage non linéaire) (Bodin and Recher 2026a; Buzer 2022).

🔢 Formule de la pré-activation

Le calcul de la sommation pondérée s’écrit :

h = \sum_{i} w_i x_i + b (voir le Glossaire)

h : la valeur de pré-activation (la somme pondérée brute accumulée par le neurone avant d’appliquer la fonction d’activation).
\sum_{i} : le symbole de sommation, indiquant que l’on additionne les contributions de toutes les entrées indexées par i.
x_i : le signal de la i-ème entrée.
w_i : le poids synaptique associé à la i-ème entrée.
b : le biais (valeur de décalage).

🧠 Simulateur — Anatomie du Neurone Artificiel

viewof n_x1 = Inputs.range([-2, 2], { value: 1.0, step: 0.1, label: "x₁" })
viewof n_x2 = Inputs.range([-2, 2], { value: 0.5, step: 0.1, label: "x₂" })
viewof n_x3 = Inputs.range([-2, 2], { value: -0.5, step: 0.1, label: "x₃" })

viewof n_w1 = Inputs.range([-2, 2], { value: 0.8, step: 0.1, label: "w₁" })
viewof n_w2 = Inputs.range([-2, 2], { value: -0.5, step: 0.1, label: "w₂" })
viewof n_w3 = Inputs.range([-2, 2], { value: 1.2, step: 0.1, label: "w₃" })
viewof n_bias = Inputs.range([-2, 2], { value: 0.3, step: 0.1, label: "Biais b" })
viewof n_fn = Inputs.select(["relu", "sigmoid"], { value: "relu", label: "Activation" })

import { updateNeuronDiagram } from "../../assets/js/simulations/neuron.js"

_neuron = {
  updateNeuronDiagram(document.getElementById("neuron-diagram-container"), {
    x1: n_x1, x2: n_x2, x3: n_x3,
    w1: n_w1, w2: n_w2, w3: n_w3,
    bias: n_bias, activationFn: n_fn
  });
}

2.3 Propagation avant (Forward Propagation)

La propagation avant est le voyage aller des données à travers le réseau : elles entrent sous forme brute d’un côté (comme les pixels d’une image), sont transformées à chaque étape par les calculs des neurones, et ressortent de l’autre côté sous forme de prédiction (comme le nom de l’objet sur l’image).

La propagation avant constitue le flux tensorial unidirectionnel qui transforme une entrée brute en une prédiction (Innovatiana 2026). C’est la phase d’inférence pure, où le réseau déploie sa structure et sa compréhension acquise pour interpréter de nouvelles activations.

Le processus de sommation pondérée : À chaque couche, les neurones reçoivent les activations de la couche précédente. Le réseau calcule systématiquement les produits scalaires entre les poids et ces activations pour obtenir la combinaison linéaire avant l’étape de filtrage (Bodin and Recher 2026b) : h = \sum_{i} w_i x_i + b.

2.3.1 Formalisme vectoriel et vectorisation

Pour tirer parti de l’accélération matérielle des GPU, on reformule ces calculs individuels sous forme matricielle. L’ensemble d’une couche se calcule en une seule opération, ce qui permet aux GPU d’effectuer des milliers de calculs en parallèle et rend l’entraînement de réseaux profonds faisable (Nielsen 2019).

🔢 Formule matricielle de la propagation avant

Le calcul vectorisé pour une couche l s’écrit :

\mathbf{a}^l = \sigma\!\left(\mathbf{W}^l \mathbf{a}^{l-1} + \mathbf{b}^l\right) (voir le Glossaire)

Lettres grasses (ex: \mathbf{a}, \mathbf{W}, \mathbf{b}) : désignent des tenseurs (vecteurs ou matrices) plutôt que des nombres isolés (scalaires).
L’exposant l (ex: \mathbf{a}^l) : indique la couche du réseau de neurones à laquelle la variable appartient.
\mathbf{a}^l : le vecteur d’activations de la couche l.
\mathbf{W}^l \in \mathbb{R}^{n_l \times n_{l-1}} : la matrice des poids de la couche l.
- Le symbole \in signifie “appartient à”.
- \mathbb{R}^{n_l \times n_{l-1}} représente l’espace des matrices de nombres réels à n_l lignes (nombre de neurones de la couche l) et n_{l-1} colonnes (nombre de neurones de la couche précédente l-1).
\mathbf{a}^{l-1} : le vecteur d’activations de la couche précédente l-1 (la couche \mathbf{a}^0 correspondant à l’entrée \mathbf{x}).
\mathbf{b}^l : le vecteur des biais de la couche l.
\sigma (lettre grecque sigma) : la fonction d’activation, appliquée élément par élément sur le vecteur de pré-activation.

L’impératif de la non-linéarité : Appliquer une fonction d’activation non linéaire empêche le réseau de s’effondrer mathématiquement en une simple régression linéaire (YouTube 2026d; Inconnu 2026a). Cette non-linéarité lui permet de modéliser les motifs complexes et les ruptures de la réalité.
La transformation progressive des données : À travers ce chaînage alterné d’opérations, les données transitent d’un état brut (ex: pixels) à des représentations abstraites de plus en plus sémantiques jusqu’à la sortie finale (Cloudflare 2026).

⚡ Simulateur — Propagation Avant couche par couche

viewof fp_x1 = Inputs.range([-2, 2], { value: 1.0, step: 0.1, label: "Entrée x₁" })
viewof fp_x2 = Inputs.range([-2, 2], { value: -0.5, step: 0.1, label: "Entrée x₂" })

import { updateForwardPassViz } from "../../assets/js/simulations/neuron.js"

_forwardPass = {
  updateForwardPassViz(document.getElementById("forward-pass-container"), { x1: fp_x1, x2: fp_x2 });
}

2.4 Rétropropagation (Backpropagation)

La rétropropagation est le voyage retour de l’erreur : une fois la prédiction faite, le réseau calcule l’écart avec la bonne réponse et remonte à l’envers à travers toutes ses couches pour distribuer la responsabilité de l’erreur à chaque neurone (grâce à la règle de la chaîne).

La rétropropagation est véritablement le moteur algorithmique de l’apprentissage. Si la propagation avant définit la vision ou la prédiction actuelle du réseau, la rétropropagation (ou passage arrière) est le mécanisme par lequel le système évalue ses propres lacunes pour s’améliorer. Historiquement, bien que ce concept ait été popularisé en 1986 par Rumelhart, Hinton et Williams, sa genèse remonte à 1970 grâce aux travaux de Seppo Linnainmaa (Wikipédia 2026d; Espinasse 2008). Ce mécanisme permet au réseau d’ajuster ses paramètres internes en fonction de l’erreur qu’il vient de commettre.

Le calcul de l’erreur (Loss Function) : La fonction de coût (ex: l’erreur quadratique moyenne ou MSE) quantifie l’écart entre la prédiction du réseau et la vérité terrain (Momotoculteur 2026b; Liora 2026; Moi aussi je peux écrire un livre sur l’IA 2026).
La rétropropagation (Backward Pass) : Le réseau remonte à l’envers pour distribuer la responsabilité de l’erreur globale à chaque poids (Codefinity 2026; Bodin and Recher 2026b). Il s’appuie sur la règle de la chaîne (Chain Rule) pour calculer les dérivées partielles (Jouannic 2026; Google Machine Learning 2025).

🔢 La Règle de la Chaîne (Chain Rule)

Pour calculer la contribution d’un poids w d’une couche intermédiaire à l’erreur finale \mathcal{L}, on multiplie les dérivées partielles le long du chemin de propagation :

\frac{\partial \mathcal{L}}{\partial w} = \frac{\partial \mathcal{L}}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} (voir le Glossaire)

\partial (symbole de dérivation partielle) : représente la sensibilité d’une fonction aux variations d’une seule variable (ex: \frac{\partial \mathcal{L}}{\partial w} mesure la variation de la perte globale \mathcal{L} lorsque le poids w change, toutes les autres variables étant fixes).
\mathcal{L} : la fonction de perte (loss).
a : l’activation de sortie du neurone (a = \sigma(z)).
z : la valeur intermédiaire de pré-activation (z = w \cdot x + b).
\sigma'(z) : la dérivée première de la fonction d’activation \sigma (le symbole prime ' indiquant la dérivée).
x : la valeur d’entrée connectée à ce poids.

L’ajustement (Descente de gradient) : Les gradients calculés indiquent la direction et l’amplitude de la correction à appliquer aux poids pour minimiser la perte au pas suivant (Wikipédia 2026a; Ruder 2016; IE-Concept 2026; Mallat 2019).

🕸️ Réseau de Neurones

viewof trafficA = Inputs.range([0, 500],    {value: 300, step: 10,  label: "Zone A (x₁)"})

viewof weightA  = Inputs.range([0, 3],      {value: 1.5, step: 0.1, label: "Route A (w₁)"})

viewof trafficB = Inputs.range([0, 500],    {value: 150, step: 10,  label: "Zone B (x₂)"})

viewof weightB  = Inputs.range([0, 3],      {value: 0.5, step: 0.1, label: "Route B (w₂)"})

viewof bias     = Inputs.range([-300, 300], {value: 100, step: 10,  label: "Piétons (b)"})

viewof bp_target = Inputs.range([20000, 50000], {value: 35000, step: 1000, label: "Objectif (€)"})

viewof bp_lr     = Inputs.range([0.01, 0.2],    {value: 0.05,  step: 0.01,  label: "Taux (lr)"})

Les entrées sont pondérées, sommées (Σ), puis filtrées par ReLU. Ajustez les paramètres dans la barre de contrôles ci-dessus.

L’inspecteur remonte à l’envers : il distribue la responsabilité de l’erreur proportionnellement au trafic (règle de la chaîne).

Le “Budget Travaux” corrige proportionnellement les poids. Modifiez le taux d’apprentissage ci-dessus pour observer l’amplitude des corrections.

Z = (trafficA * weightA) + (trafficB * weightB) + bias
isActive = Z >= 500
revenus = isActive ? (Z - 500) * 50 : 0

// Backward Pass (shared from forward pass values)
bp_error = bp_target - revenus
grad_w1 = (bp_error / 5000) * (trafficA / 100)
grad_w2 = (bp_error / 5000) * (trafficB / 100)
new_w1 = weightA + (bp_lr * grad_w1)
new_w2 = weightB + (bp_lr * grad_w2)

// Graph 1: Forward Pass (reactive via window.simState + refresh)
renderSupermarketNetwork = {
  const nodes = [
    { id: "A",      label: () => `Zone A\n(${window.simState?.trafficA ?? 300})`,        fx: -160, fy: -60,  status: "input",  shape: "pill" },
    { id: "B",      label: () => `Zone B\n(${window.simState?.trafficB ?? 150})`,        fx: -160, fy:  60,  status: "input",  shape: "pill" },
    { id: "Bias",   label: () => `Piétons\n(b = ${window.simState?.bias ?? 100})`,       fx:    0, fy: -110, status: "bias",   shape: "circle" },
    { id: "Neuron", label: () => `Magasin (Σ)\nZ = ${window.simState?.Z ?? 500}`,        fx:    0, fy:    0, status: "neuron", shape: "rounded rect" },
    { id: "Output", label: () => `Revenus\n${window.simState?.revenus ?? 0} €`,          fx:  160, fy:    0,
      status: () => window.simState?.isActive ? "active" : "inactive", shape: "diamond" }
  ];

  const links = [
    { source: "A",      target: "Neuron", label: () => `w₁ = ${(window.simState?.weightA ?? 1.5).toFixed(1)}`, status: "flow",     width: () => 1 + (window.simState?.weightA ?? 1.5) * 2.5 },
    { source: "B",      target: "Neuron", label: () => `w₂ = ${(window.simState?.weightB ?? 0.5).toFixed(1)}`, status: "flow",     width: () => 1 + (window.simState?.weightB ?? 0.5) * 2.5 },
    { source: "Bias",   target: "Neuron", label: "Biais",                                                       status: "biasLink", width: () => 1 + Math.abs(window.simState?.bias ?? 100) / 100 },
    {
      source: "Neuron", target: "Output", label: "ReLU",
      status: () => window.simState?.isActive ? "activeFlow" : "inactiveFlow",
      width: () => window.simState?.isActive ? 2.5 + Math.min(6, (window.simState?.revenus ?? 0) / 2500) : 1,
      condition: () => {
        const active = window.simState?.isActive ?? true;
        return { value: active, label: active ? "Z ≥ 500" : "Z < 500", labelPosition: "right" };
      }
    }
  ];

  const graph = aptitek.createGraph("#plot-supermarket-network", { nodes, links }, {
    nodeRadius: 25, fontSize: 9, height: 300,
    enableZoom: false, enablePan: false, enableDrag: false,
    zoomToFit: true, zoomToFitPadding: 40,
    styles: {
      input:       { nodeBg: "rgba(var(--sol-blue-rgb), 0.15)",    nodeBorder: "var(--sol-blue)",    nodeText: "var(--sol-blue)" },
      bias:        { nodeBg: "rgba(var(--sol-magenta-rgb), 0.15)", nodeBorder: "var(--sol-magenta)", nodeText: "var(--sol-magenta)" },
      neuron:      { nodeBg: "rgba(var(--sol-yellow-rgb), 0.15)",  nodeBorder: "var(--sol-yellow)",  nodeText: "var(--sol-yellow)" },
      active:      { nodeBg: "rgba(var(--sol-green-rgb), 0.15)",   nodeBorder: "var(--sol-green)",   nodeText: "var(--sol-green)" },
      inactive:    { nodeBg: "rgba(var(--sol-red-rgb), 0.15)",     nodeBorder: "var(--sol-red)",     nodeText: "var(--sol-red)" },
      flow:        { linkStroke: "var(--sol-base1)",    linkText: "var(--sol-base01)", particles: 3, particleColor: "var(--sol-blue)" },
      biasLink:    { linkStroke: "var(--sol-magenta)",  linkText: "var(--sol-magenta)", particles: 1, particleColor: "var(--sol-magenta)", particleSpeed: 0.005 },
      activeFlow:  { linkStroke: "var(--sol-green)",    linkText: "var(--sol-green)",   particles: 5, particleColor: "var(--sol-green)",   particleSpeed: 0.02 },
      inactiveFlow:{ linkStroke: "var(--sol-red)",      linkText: "var(--sol-red)",     particles: 0 }
    }
  });

  invalidation.then(() => { if (graph?.destroy) graph.destroy(); });
  return graph;
}

updateState = {
  window.simState = {
    trafficA, trafficB, weightA, weightB, bias,
    Z, revenus, isActive,
    bp_target, bp_error, grad_w1, grad_w2,
    new_w1, new_w2
  };
  if (typeof renderSupermarketNetwork?.refresh === "function") renderSupermarketNetwork.refresh();
  if (typeof renderBackprop?.refresh        === "function") renderBackprop.refresh();
  if (typeof renderGradientDescent?.refresh === "function") renderGradientDescent.refresh();
  return aptitek.noop();
}

// Graph 2: Backpropagation (created once, updated via refresh)
renderBackprop = {
  const nodes = [
    { id: "A",      label: () => `Zone A\n(Trafic: ${window.simState?.trafficA ?? 300})`,          fx: -160, fy: -60,  status: "auditInput",  shape: "pill" },
    { id: "B",      label: () => `Zone B\n(Trafic: ${window.simState?.trafficB ?? 150})`,          fx: -160, fy:  60,  status: "auditInput",  shape: "pill" },
    { id: "Bias",   label: () => `Piétons`,                                                          fx:  -70, fy: -110, status: "auditBias",   shape: "circle" },
    { id: "Neuron", label: () => `Magasin\nCA = ${window.simState?.revenus ?? 0}€`,                 fx:    0, fy:    0, status: "auditNeuron", shape: "rounded rect" },
    { id: "Output", label: () => `Siège Social\nObjectif: ${window.simState?.bp_target ?? 35000}€`, fx:  170, fy:    0, status: "errorNode",   shape: "square" }
  ];

  const links = [
    { source: "Output", target: "Neuron", label: () => `Perte : ${(window.simState?.bp_error ?? 0) > 0 ? "+" : ""}${window.simState?.bp_error ?? 0} €`, status: "errorFlow" },
    { source: "Neuron", target: "A",      label: () => `Resp. Forte (Δ: ${(window.simState?.grad_w1 ?? 0).toFixed(1)})`,                                  status: "errorFlow" },
    { source: "Neuron", target: "B",      label: () => `Resp. Faible (Δ: ${(window.simState?.grad_w2 ?? 0).toFixed(1)})`,                                  status: "errorFlow" },
    { source: "Neuron", target: "Bias",   label: () => `Ajust.`,                                                                                            status: "errorFlow" }
  ];

  const graph = aptitek.createGraph("#plot-backprop", { nodes, links }, {
    nodeRadius: 25, fontSize: 9, height: 300,
    enableZoom: false, enablePan: false, enableDrag: false,
    zoomToFit: true, zoomToFitPadding: 40,
    styles: {
      errorNode:   { nodeBg: "rgba(var(--sol-red-rgb), 0.15)",    nodeBorder: "var(--sol-red)",    nodeText: "var(--sol-red)" },
      auditNeuron: { nodeBg: "rgba(var(--sol-orange-rgb), 0.15)", nodeBorder: "var(--sol-orange)", nodeText: "var(--sol-orange)" },
      auditInput:  { nodeBg: "var(--sol-base2)",  nodeBorder: "var(--sol-base00)", nodeText: "var(--sol-base01)" },
      auditBias:   { nodeBg: "var(--sol-base2)",  nodeBorder: "var(--sol-base00)", nodeText: "var(--sol-base01)" },
      errorFlow:   { linkStroke: "var(--sol-red)", linkText: "var(--sol-red)", particles: 4, particleColor: "var(--sol-red)", particleSpeed: 0.015 }
    }
  });

  invalidation.then(() => { if (graph?.destroy) graph.destroy(); });
  return graph;
}

// Graph 3: Gradient Descent
renderGradientDescent = {
  const nodes = [
    { id: "A",      label: `Zone A`,            fx: -160, fy: -60,  status: "input",  shape: "pill" },
    { id: "B",      label: `Zone B`,            fx: -160, fy:  60,  status: "input",  shape: "pill" },
    { id: "Bias",   label: `Piétons`,           fx:  -70, fy: -110, status: "bias",   shape: "circle" },
    { id: "Neuron", label: `Magasin`,   fx:    0, fy:    0, status: "neuron", shape: "rounded rect" },
    { id: "Output", label: `Prêt pour\nJour 2`, fx:  160, fy:    0, status: "active", shape: "diamond" }
  ];

  const links = [
    { source: "A",      target: "Neuron", label: () => `w₁ : ${(window.simState?.weightA ?? 1.5).toFixed(1)} ➔ ${(window.simState?.new_w1 ?? 1.5).toFixed(2)}`, status: "updateFlow" },
    { source: "B",      target: "Neuron", label: () => `w₂ : ${(window.simState?.weightB ?? 0.5).toFixed(1)} ➔ ${(window.simState?.new_w2 ?? 0.5).toFixed(2)}`, status: "updateFlow" },
    { source: "Bias",   target: "Neuron", label: "b mis à jour",                                        status: "biasFlow" },
    { source: "Neuron", target: "Output", label: "Nouveau Potentiel",                                   status: "activeFlow" }
  ];

  const graph = aptitek.createGraph("#plot-gradient", { nodes, links }, {
    nodeRadius: 25, fontSize: 9, height: 300,
    enableZoom: false, enablePan: false, enableDrag: false,
    zoomToFit: true, zoomToFitPadding: 40,
    styles: {
      input:      { nodeBg: "rgba(var(--sol-blue-rgb), 0.15)",    nodeBorder: "var(--sol-blue)",    nodeText: "var(--sol-blue)" },
      bias:       { nodeBg: "rgba(var(--sol-magenta-rgb), 0.15)", nodeBorder: "var(--sol-magenta)", nodeText: "var(--sol-magenta)" },
      neuron:     { nodeBg: "rgba(var(--sol-yellow-rgb), 0.15)",  nodeBorder: "var(--sol-yellow)",  nodeText: "var(--sol-yellow)" },
      active:     { nodeBg: "rgba(var(--sol-green-rgb), 0.15)",   nodeBorder: "var(--sol-green)",   nodeText: "var(--sol-green)" },
      updateFlow: { linkStroke: "var(--sol-green)",   linkText: "var(--sol-green)",   particles: 2, particleColor: "var(--sol-green)",   particleWidth: 4 },
      activeFlow: { linkStroke: "var(--sol-base1)",   linkText: "var(--sol-base01)",  particles: 1 },
      biasFlow:   { linkStroke: "var(--sol-magenta)", linkText: "var(--sol-magenta)", particles: 1 }
    }
  });

  invalidation.then(() => { if (graph?.destroy) graph.destroy(); });
  return graph;
}

// Ajustements dynamiques pour insérer les contrôles sous les onglets et au-dessus des graphes
layoutAdjust = {
  const card = document.querySelector('.card-window');
  if (card) {
    const controls = card.querySelector('.card-control-row');
    const tabset = card.querySelector('.panel-tabset');
    if (controls && tabset) {
      const navTabs = tabset.querySelector('.nav-tabs');
      const tabContent = tabset.querySelector('.tab-content');
      if (navTabs && tabContent) {
        tabset.insertBefore(controls, tabContent);
      }
    }
  }
  return true;
}

2.5 Les fonctions d’activation en détail

Les fonctions d’activation sont les interrupteurs du réseau : elles décident si le signal d’un neurone est assez fort pour être transmis à la couche suivante, tout en tordant la réalité mathématique pour modéliser des courbes plutôt que de simples lignes droites.

Les fonctions d’activation agissent comme des interrupteurs ou des variateurs, dictant la dynamique de transmission du signal au sein du réseau (Momotoculteur 2026a; Daniella 2024). Elles sont le cœur de la non-linéarité et se divisent en deux grandes familles.

Les fonctions classiques et leurs limitations :
- Sigmoïde & TanH : Courbes en “S” d’inspiration biologique. Elles saturent aux valeurs extrêmes, ce qui paralyse l’apprentissage en bloquant le gradient (Research Archive of Rising Scholars 2026).
- ReLU (Rectified Linear Unit) : Simple et rapide (\max(0, x)), elle évite la saturation positive mais souffre du “Dying ReLU” (extinction définitive de neurones) (YouTube 2026d; Stanford CS231n 2026; Ultralytics 2026a).
- Softmax : Utilisée en sortie pour convertir des scores bruts en distribution de probabilités sur des classes mutuellement exclusives (Ultralytics 2026b).

🔍 Détails et Limites des Fonctions Classiques

Saturation du Gradient : Pour de très grandes ou très petites valeurs de x, la dérivée de Sigmoïde et TanH tend vers 0. Lors de la rétropropagation, ce terme multiplicatif annule le gradient, empêchant la mise à jour des poids précédents.
Problème du “Dying ReLU” : Si un neurone ReLU reçoit une entrée négative, son gradient est nul. Si ce cas se généralise (poids mal initialisés ou taux d’apprentissage trop élevé), le neurone s’éteint définitivement.

⚡ Simulateur des Fonctions d’Activation Classiques

viewof x_classic = Inputs.range([-5, 5], { value: 0, step: 0.1, label: "Valeur de x" })

📈 Courbes d’Activation

import { updateClassicActivation } from "../../assets/js/simulations/activation.js"

_updateClassic = {
  updateClassicActivation(x_classic, {
    chartEl: document.getElementById("classic-plotly-container"),
    varsEl:  document.getElementById("classic-vars-container")
  });
}

Les fonctions modernes :

Ces fonctions plus récentes (comme GELU ou Swish) évitent les pannes sèches en laissant passer une petite partie du signal négatif de manière plus fluide.
- GELU (Gaussian Error Linear Unit) : Fonction probabiliste douce pondérant le signal négatif, pilier des Transformers car elle maintient un flux de gradient fluide (YouTube 2026c; Wikipédia 2026e; Cortial 2026).
- SELU (Scaled Exponential Linear Unit) : Conçue pour introduire des propriétés auto-normalisantes, permettant aux réseaux profonds de converger sans normalisation externe (Inconnu 2026b; Stanford University 2026).
- Swish : Version lissée de ReLU qui laisse passer les petites valeurs négatives pour éviter les coupures abruptes (Lim 2026).

🔍 Fonctionnement des Activations Modernes

GELU et Probabilité : Elle multiplie l’entrée x par la fonction de répartition d’une loi normale standard \Phi(x). Le neurone est donc activé de manière déterministe mais selon son importance probabiliste relative.
Auto-normalisation (SELU) : En combinant un facteur d’échelle \lambda et un paramètre \alpha sur une fonction ELU, SELU garantit que si la moyenne et la variance des activations d’une couche sont proches de 0 et 1, elles le restent après passage dans la couche suivante.

🔢 Formule de l’activation Swish

La fonction Swish s’écrit :

f(x) = x \cdot \text{sigmoid}(\beta x) = \frac{x}{1 + e^{-\beta x}}

Où \beta est un paramètre constant ou entraînable. Lorsque \beta = 1, la fonction est également appelée SiLU (Sigmoid Linear Unit).

✨ Simulateur des Fonctions d’Activation Modernes

viewof x_modern = Inputs.range([-3, 3], { value: 0, step: 0.1, label: "Valeur de x" })

📈 Courbes d’Activation (Modernes)

import { updateModernActivation } from "../../assets/js/simulations/activation.js"

_updateModern = {
  updateModernActivation(x_modern, {
    chartEl: document.getElementById("modern-plotly-container"),
    varsEl:  document.getElementById("modern-vars-container")
  });
}

2.6 Le problème du gradient (Vanishing / Exploding)

Dans un réseau très profond, le message d’erreur peut se perdre en route : soit il s’atténue à chaque étape jusqu’à disparaître (la disparition du gradient, comme un chuchotement répété 10 fois), soit il s’amplifie de manière démesurée jusqu’à tout saturer (l’explosion du gradient, comme un cri amplifié à chaque relais).

L’entraînement des réseaux profonds se heurte souvent à ce que l’on pourrait qualifier de “stabilité instable”. Lors de la phase de rétropropagation, la multiplication successive des gradients à travers les nombreuses couches du réseau peut mener à des phénomènes critiques : leur disparition ou leur explosion (Sun, Xu, and Li 2025; GeeksforGeeks 2026b; Wikipedia 2026).

Le mécanisme du gradient (Vanishing & Exploding) : Lors de la rétropropagation, calculer les gradients des premières couches nécessite de multiplier les dérivées des fonctions d’activation et les poids des couches suivantes en cascade (règle de la chaîne).
- Disparition (Vanishing) : Si ces termes sont inférieurs à 1 (ex: avec la fonction Sigmoïde), le produit tend exponentiellement vers zéro, bloquant l’apprentissage des premières couches (Research Archive of Rising Scholars 2026).
- Explosion (Exploding) : Si ces termes sont supérieurs à 1, le produit grandit de manière exponentielle, rendant les mises à jour chaotiques et déstabilisant le modèle (GeeksforGeeks 2026b, 2026a).

🔢 Formulation mathématique du problème

Dans un réseau à L couches, le gradient de la perte par rapport à un poids w^1 de la première couche s’exprime sous la forme d’un produit :

\frac{\partial \mathcal{L}}{\partial w^1} = \frac{\partial \mathcal{L}}{\partial a^L} \cdot \left( \prod_{k=2}^{L} w^k \sigma'(z^{k-1}) \right) \sigma'(z^1) x^0

Si \forall k, |w^k \sigma'(z^{k-1})| < 1, alors le terme de produit \prod_{k=2}^{L} tend vers 0 lorsque L augmente (gradients évanescents). Si \forall k, |w^k \sigma'(z^{k-1})| > 1, alors ce terme grandit exponentiellement (gradients explosifs).

Illustration par la transmission de la parole :
- Évanouissement : Si 10 personnes se chuchotent un message en divisant le volume par deux à chaque étape (dérivée de 0.5), la dernière personne recevra 0.5^{10} \approx 0.001 du signal initial. Le message devient inaudible.
- Explosion : Si chaque personne double le volume reçu (dérivée de 2), la dernière personne émettra un signal 2^{10} = 1024 fois plus fort. Le message est saturé et déformé.

// 1. Curseur de contrôle interactif
viewof deriv = Inputs.range([0.1, 2.5], {
  value: 0.8,
  step: 0.1,
  label: "Valeur de la dérivée locale :"
})

import { renderGradientFlowStatus } from "../../assets/js/simulations/learning-curves.js"
renderGradientFlowStatus(deriv)

import { renderGradientFlowPlot } from "../../assets/js/simulations/learning-curves.js"
renderGradientFlowPlot(Plot, deriv)

2.7 Solutions à la disparition du gradient et optimisation du paysage

Pour rendre l’apprentissage stable et rapide, on applique plusieurs astuces : on initialise les poids intelligemment, on utilise des fonctions d’activation robustes (comme ReLU) et on normalise les signaux (Batch Normalization) pour aplanir les irrégularités de notre paysage d’erreurs.

La résolution des problèmes de gradient a été un tournant majeur qui a permis l’émergence des modèles massifs actuels. L’enjeu principal est de transformer un paysage d’optimisation mathématiquement accidenté en une voie praticable et stable pour l’algorithme d’apprentissage (Sun, Xu, and Li 2025; Bodin and Recher 2026c; Martens 2010).

📊 Batch Normalization

viewof bn_mu    = Inputs.range([-4, 4], { value: 2.0, step: 0.1, label: "μ (moyenne brute)" })
viewof bn_sigma = Inputs.range([0.3, 5], { value: 3.0, step: 0.1, label: "σ (écart-type brut)" })

import { updateBatchNormViz } from "../../assets/js/simulations/learning-curves.js"

_batchNorm = {
  updateBatchNormViz(document.getElementById("batch-norm-container"), { mu: bn_mu, sigma: bn_sigma });
}

Fonction ReLU & Initialisation :
- Flux du gradient : Contrairement à Sigmoïde/TanH, ReLU ne sature pas pour les valeurs positives, maintenant un flux de gradient stable (iNeuron Intelligence 2026; Kumar 2017; Stanford University 2026).
- Initialisation des poids : Des techniques comme la Sparse Initialization (limitation des connexions non nulles par neurone) préviennent la saturation précoce (Stanford University 2026).

2.7.1 Batch Normalization

La Batch Normalization agit comme un rouleau compresseur qui aplanit la route : elle recentre et redimensionne les signaux à chaque couche pour que l’apprentissage se fasse sur une autoroute lisse plutôt que sur un sentier de montagne chaotique.

La Batch Normalization (BN) (CodeSignal 2025a; Holbrook 2022; golmschenk 2016) est une technique introduite par Ioffe et Szegedy (2015) pour stabiliser et accélérer l’apprentissage. Son rôle majeur est le lissage du paysage d’optimisation, rendant la descente de gradient plus stable et plus rapide (semblable à une autoroute damée ou une piste bleue) (Ioffe and Szegedy 2015; Sarkar 2024; YouTube 2026b).

🔢 Formules de la Batch Normalization

Pour un mini-lot de pré-activations \mathcal{B} = \{z_1, \dots, z_m\}, l’algorithme normalise et met à l’échelle chaque valeur z_i (voir le Glossaire) :

Calcul de la moyenne du mini-lot : \mu_{\mathcal{B}} = \frac{1}{m} \sum_{i=1}^m z_i
Calcul de la variance du mini-lot : \sigma_{\mathcal{B}}^2 = \frac{1}{m} \sum_{i=1}^m (z_i - \mu_{\mathcal{B}})^2
Normalisation : \hat{z}_i = \frac{z_i - \mu_{\mathcal{B}}}{\sqrt{\sigma_{\mathcal{B}}^2 + \epsilon}}
Mise à l’échelle et décalage (Scaling & Shift) : \tilde{z}_i = \gamma \hat{z}_i + \beta

Guide des symboles :

\mathcal{B} : le mini-lot (mini-batch) de données, c’est-à-dire le sous-ensemble d’échantillons calculés simultanément.
m : la taille (nombre d’exemples) du mini-lot.
\mu_{\mathcal{B}} (lettre grecque mu) : la moyenne des pré-activations sur le mini-lot.
\sigma_{\mathcal{B}}^2 (lettre grecque sigma au carré) : la variance des pré-activations sur le mini-lot (l’écart-type étant \sigma_{\mathcal{B}}).
\hat{z}_i (“z-chapeau”) : la valeur de pré-activation normalisée (centrée sur 0 avec une variance de 1).
\epsilon (lettre grecque epsilon) : une très petite constante positive de stabilité numérique (pour éviter la division par zéro).
\tilde{z}_i (“z-tilde”) : la valeur finale après normalisation, mise à l’échelle et décalage.
\gamma (lettre grecque gamma) : le paramètre d’échelle (scaling) apprenable.
\beta (lettre grecque bêta) : le paramètre de décalage (shift) apprenable. (Note : à ne pas confondre avec le coefficient d’inertie de l’optimiseur Adam ou le calendrier de bruit de diffusion).

Intégration de la Batch Normalization :
- Ordre standard : \text{Linear} \to \text{BN} \to \text{Activation} (maximise la sensibilité de la non-linéarité).
- Bénéfices : Permet des taux d’apprentissage élevés, réduit la dépendance à l’initialisation des poids et régularise légèrement via les mini-lots.

🔍 L’Approche par Portes

Dans les réseaux récurrents profonds (séquences longues), les architectures spécialisées introduisent des portes (gates) (comme dans le LSTM et GRU). Ces mécanismes agissent comme des valves mathématiques contrôlant le flux d’informations :

Elles permettent de préserver l’information importante sur de longues distances temporelles.
Elles créent des voies rapides (l’état de la cellule) où le gradient peut s’écouler sans atténuation, contournant ainsi structurellement la disparition du gradient (Bourdois 2019; Rosique 2017; ApX Machine Learning 2026; Le Scribouillard 2026).

Ces innovations ont permis d’industrialiser les réseaux profonds pour des tâches complexes (NLP, planification urbaine…) (Socher and Manning 2018; Wang et al. 2023; The Agility Effect 2025; Baraud-Serfaty 2019; Daoudi, Alfonso, and Cabot 2018).

graph LR
    %% Thème Solarized
    classDef bg fill:var(--sol-base03),stroke:var(--sol-base01),stroke-width:2px,color:var(--sol-base0);
    classDef gate fill:var(--accent-info),stroke:var(--sol-base03),stroke-width:2px,color:var(--sol-base3);
    classDef cell fill:var(--accent-success),stroke:var(--sol-base03),stroke-width:2px,color:var(--sol-base3);
    classDef forget fill:var(--accent-warning),stroke:var(--sol-base03),stroke-width:2px,color:var(--sol-base3);

    X[Entrée X_t]:::bg --> Gate[Portes d'activation]:::gate
    H_prev[État Caché H_t-1]:::bg --> Gate
    C_prev[Cellule C_t-1 'Voie Rapide']:::bg --> Oubli(Porte d'oubli):::forget

    Gate --> Oubli
    Gate --> MiseAJour(Porte de mise à jour):::gate

    Oubli --> C_next[Cellule C_t 'Voie Rapide']:::cell
    MiseAJour --> C_next
    C_next --> Sortie(Porte de sortie):::gate
    Sortie --> H_next[État Caché H_t]:::bg

2.8 Limites Structurelles et Optimisation Continue

Bien que puissants, les réseaux de neurones classiques (MLP) ont leurs limites : ils manquent de sens de l’espace pour analyser les images (ce que résoudront les CNN) et de mémoire pour analyser le texte ou les séries temporelles (ce que résoudront les RNN et les Transformers).

Malgré sa polyvalence et son universalité théorique, le MLP souffre d’une myopie structurelle intrinsèque liée à sa connectivité totale. Comprendre ces limites est essentiel pour justifier l’émergence des architectures spécialisées qui font l’objet des chapitres suivants (Auteur Collectif 2024; ResearchGate 2026).

2.8.1 L’incapacité à capturer les relations spatiales

Un réseau classique traite chaque pixel d’une image de façon isolée, sans comprendre qu’un pixel voisin fait partie du même objet, ce qui fait exploser le nombre de calculs nécessaires pour une simple photo.

Le MLP traite chaque dimension de l’entrée de manière indépendante et isotrope : il ne possède aucun a priori sur la structure spatiale des données. Cette approche est catastrophique pour les images.

Pour une image en niveaux de gris de 100 \times 100 pixels (10\,000 entrées), un seul neurone de la première couche cachée nécessite déjà 10\,000 poids. Une couche de 1\,000 neurones implique 10^7 paramètres pour la seule première couche — et ce pour une image de résolution modeste. À 224 \times 224 pixels (résolution standard d’ImageNet), le coût devient proprement rédhibitoire.

De plus, le MLP ignore la corrélation locale des pixels : deux pixels voisins ne sont pas traités différemment de deux pixels aux antipodes de l’image. Cette indifférence à la topologie spatiale est précisément ce que les CNN résolvent via la connectivité locale et le partage de poids.

2.8.2 La rigidité face aux données séquentielles

Les modèles classiques n’ont aucune mémoire : chaque mot d’une phrase est analysé individuellement, ignorant complètement le contexte des mots précédents.

En l’absence de mécanisme de récurrence ou de mémoire, le MLP traite chaque exemple de manière entièrement indépendante. Pour une séquence de mots ou une série temporelle, chaque pas de temps est traité comme si le passé n’existait pas. Cette limitation fondamentale motive l’introduction des RNN, LSTM et GRU (chapitre 3), puis des Transformers.

Il est important de noter que le MLP ne disparaît pas pour autant dans les architectures modernes. Au cœur même des Transformers, un bloc Position-wise Feed-Forward Network (FFN) — structurellement identique à un MLP à deux couches avec activation GELU — traite chaque position de la séquence indépendamment après le mécanisme d’attention. Le MLP est donc un sous-composant universel des architectures les plus sophistiquées.

2.8.3 Planificateurs de taux d’apprentissage

Un taux d’apprentissage (LR) fixe est rarement optimal tout au long de l’entraînement : trop élevé, il fait osciller la perte autour d’un minimum sans jamais converger ; trop bas, il piège le réseau dans un minimum local médiocre (Dive into Deep Learning 2023; Chugani 2025; Frans 2023). Les planificateurs de LR (learning rate schedulers) adaptent dynamiquement ce taux au cours de l’entraînement :

StepLR : Réduit le LR d’un facteur multiplicatif \gamma (le coefficient de décroissance gamma) tous les k pas d’optimisation (CodeSignal 2025b). Simple et prédictible mais nécessite un réglage manuel de k.
ReduceLROnPlateau : Réduit le LR lorsque la métrique surveillée (typiquement la perte de validation) n’améliore plus depuis p époques. Adaptatif et particulièrement robuste dans les pipelines de production.
CosineAnnealingLR : Fait décroître le LR selon un cosinus depuis \eta_{\max} jusqu’à \eta_{\min} (où la lettre grecque \eta [êta] représente le taux d’apprentissage), permettant un refroidissement progressif qui favorise la convergence vers des minima larges et plus généralisables.
Warmup + Decay : Utilisé dans les Transformers, le LR monte linéairement pendant quelques milliers de pas (warmup) puis décroît selon 1/\sqrt{t}. Cela permet aux paramètres initiaux de se stabiliser avant d’appliquer de grandes mises à jour.

📉 Comparateur de Planificateurs de Taux d’Apprentissage

viewof lr_init   = Inputs.range([0.001, 0.5], { value: 0.1, step: 0.001, label: "LR initial (η₀)" })
viewof lr_epochs = Inputs.range([10, 100],     { value: 50,  step: 1,     label: "Époques totales" })

import { updateLRSchedulerViz } from "../../assets/js/simulations/learning-curves.js"

_lrScheduler = {
  updateLRSchedulerViz(document.getElementById("lr-schedulers-container"), { eta0: lr_init, T: lr_epochs });
}

Ces planificateurs illustrent une réalité fondamentale de l’optimisation profonde : le taux d’apprentissage n’est pas un hyperparamètre fixe, mais une trajectoire dans l’espace des paramètres. Maîtriser le MLP dans toute sa profondeur — architecture, activation, rétropropagation, normalisation et optimisation — constitue le prérequis indispensable à l’étude des architectures spécialisées qui vont suivre.