1  🤖 Machine Learning : Les Fondamentaux

// ==========================================
// _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();
  });
}

1.1 Grande Histoire du Machine Learning

L’histoire de l’IA est un match de ping-pong de 60 ans entre deux visions opposées : d’un côté, donner des règles toutes faites à la machine (l’IA symbolique, comme une recette de cuisine), et de l’autre, la laisser apprendre par elle-même à force d’exemples (le connexionnisme, comme un bébé qui découvre le monde).

L’IA n’est pas née en 2023. C’est une histoire de soixante ans, faite d’espoirs fous, de désillusions et de renaissances — comme un pendule qui oscille entre ces deux grandes idées (Groumpos 2023; “Timeline of Machine Learning,” n.d.).

1.1.1 Timeline

Alan Turing	Le Test de Turing
	Fondation philosophique : « Les machines peuvent-elles penser ? » Il pose l’imitation du comportement humain comme standard de réussite.

Frank Rosenblatt	Le Perceptron
	Le Connexionnisme : Invention du premier réseau de neurones artificiel modélisé sur la biologie, capable d’apprendre par essais et erreurs.

Minsky & Papert	Le Premier Hiver de l’IA
	Désillusion : Démonstration mathématique des limites du Perceptron simple (XOR). Baisse drastique des financements mondiaux.

Systèmes Experts & Rétropropagation	Le Double Visage des Années 80
	Paradoxe : Domination de l’IA symbolique menant au 2nd Hiver, pendant que la Rétropropagation du gradient (Hinton, LeCun) is popularisée dans l’ombre.

Vapnik & Breiman	La Renaissance Statistique
	Rigueur mathématique : Le réseau de neurones est boudé. C’est l’âge d’or des Machines à Vecteurs de Support (SVM) et des méthodes d’ensemble.

ImageNet & GPUs	Le Big Bang du Deep Learning
	Triomphe connexionniste : Grâce à la convergence du Big Data et des GPUs, le réseau AlexNet pulvérise les méthodes statistiques classiques.

🔍 Grandes Époques de l’IA

1.1.2 Les Pionniers et l’Aube de l’Apprentissage (1950 - 1960)

Tout commence en 1950 avec Alan Turing et une question simple mais vertigineuse : « Les machines peuvent-elles penser ? ». Son Test de Turing transforme ce débat philosophique en défi d’ingénierie : imiter le comportement humain devient la mesure du succès.

C’est quelques années plus tard, en 1958, que le premier jalon technique du Machine Learning est posé par le psychologue Frank Rosenblatt. Il invente le Perceptron (Rosenblatt 1958). C’est le premier réseau de neurones artificiel, modélisé à partir des neurones biologiques. À l’époque, il s’agissait d’une machine physique (le Mark I Perceptron) capable d’apprendre à reconnaître des formes simples par essais et erreurs. Rosenblatt pensait alors que le Perceptron finirait par être capable de marcher, parler, voir et écrire.

1.1.3 Le Premier Hiver et le Triomphe Temporaire du Symbolique (1969 - 1980)

L’enthousiasme autour du Perceptron va cependant s’effondrer brutalement. En 1969, Marvin Minsky et Seymour Papert publient le livre Perceptrons, dans lequel ils démontrent mathématiquement les limites sévères du modèle de Rosenblatt : un Perceptron simple est incapable de résoudre des problèmes non linéaires de base (comme la fonction logique XOR) (“Minsky Vs. Rosenblatt - Brain Wars,” n.d.).

Cette publication, combinée à des promesses technologiques non tenues et au Rapport Lighthill (“Lighthill Report,” n.d.) au Royaume-Uni (qui juge sévèrement les avancées réelles de l’IA), entraîne une coupure drastique des financements gouvernementaux. C’est le premier Hiver de l’IA (AI Winter) (“AI Winter,” n.d.; Alex 2024).

Pendant que le connexionnisme est au point mort, l’IA symbolique prend le relais dans les années 80 avec les Systèmes Experts. L’idée n’est plus de faire apprendre la machine, mais d’encoder le savoir humain sous forme de bases de règles complexes (“Si X, alors Y”). Bien qu’utiles en milieu industriel, ces systèmes s’avèrent impossibles à maintenir à grande échelle et totalement inadaptés à l’incertitude ou à la perception (vision, langage naturel).

1.1.4 La Renaissance Statistique et le Second Hiver (1980 - 2000)

Le marché des systèmes experts s’effondre à la fin des années 80, provoquant un second Hiver de l’IA (“This Week in the History of AI at AIWS.net - the Market for Specialised AI Hardware Collapsed in 1987,” n.d.). Cependant, dans l’ombre, les bases du renouveau se mettent en place.

En 1986, la technique de la rétropropagation du gradient (Backpropagation) est popularisée (notamment par Geoffrey Hinton, Yann LeCun et Yoshua Bengio). C’est une percée majeure : elle permet enfin d’entraîner efficacement des réseaux de neurones multicouches, contournant ainsi le problème soulevé par Minsky 20 ans plus tôt.

Toutefois, dans les années 90, les réseaux de neurones sont encore boudés car trop gourmands en calcul et difficiles à entraîner. Le Machine Learning prend alors un tournant très mathématique et statistique. C’est l’âge d’or des Machines à Vecteurs de Support (SVM) et des méthodes d’ensemble (Random Forests), qui dominent la discipline grâce à leurs fondations mathématiques solides et leurs garanties de convergence.

1.1.5 Le Big Bang du Deep Learning (2012 - Présent)

Pourquoi des idées des années 80 ont-elles soudain dominé le monde trente ans plus tard ? Parce que trois ingrédients manquants sont enfin arrivés en même temps :

1. L’explosion des données (Big Data) : L’avènement d’Internet et des réseaux sociaux a fourni les quantités massives de données étiquetées nécessaires pour entraîner de grands réseaux.
2. La puissance de calcul matérielle : Le détournement des cartes graphiques (GPU), initialement conçues pour le jeu vidéo, a permis de paralléliser les calculs matriciels du Machine Learning, réduisant les temps d’entraînement de plusieurs mois à quelques jours.
3. Les innovations algorithmiques : De meilleures fonctions d’activation (ReLU) et techniques d’optimisation ont résolu les problèmes mathématiques qui empêchaient l’entraînement de réseaux très profonds (le problème de la disparition du gradient).

L’année charnière est 2012, lors de la compétition de vision par ordinateur ImageNet. Le réseau de neurones convolutif AlexNet pulvérise littéralement les méthodes statistiques classiques, divisant le taux d’erreur par deux. Cet événement signe la victoire éclatante du paradigme connexionniste et ouvre l’ère dans laquelle nous évoluons aujourd’hui, de la vision par ordinateur jusqu’aux modèles génératifs et larges modèles de langage (LLM).

1.2 Typologie des Paradigmes et Architectures Profondes

Avant de choisir un modèle, il faut répondre à une question : qu’est-ce qu’on a comme données, et qu’est-ce qu’on veut faire avec ? La réponse détermine tout. C’est comme choisir le bon outil avant de commencer un chantier — un marteau ne remplace pas une scie (“BIAS-VARIANCE TRADEOFF IN MACHINE LEARNING: CONCEPTS & TUTORIALS,” n.d.).

1.2.1 Quatre Paradigmes d’Apprentissage

Les modèles d’apprentissage se structurent autour de quatre grands paradigmes, selon la nature des données d’entraînement et le mode d’interaction avec l’environnement :

🎯 Apprentissage Supervisé

Apprendre avec un enseignant qui donne les bonnes réponses.

Metaphore : Un enfant apprend à nommer des animaux à l’aide de cartes d’images portant le nom correct au dos.

🔍 Détails techniques

L’algorithme s’entraîne sur des couples entrée-sortie étiquetés (contenant la “vérité terrain”) et ajuste ses paramètres pour minimiser l’erreur (Delua, n.d.).

• Régression : Prédire une valeur numérique continue (ex. : prix de l’immobilier, température).
• Classification : Prédire une catégorie ou classe discrète (ex. : e-mail indésirable vs légitime) (Lee, n.d.).

Cas d’usage : Détection de fraudes, reconnaissance d’objets, diagnostic médical.

🧩 Apprentissage Non Supervisé

Apprendre à trouver des structures par soi-même, sans guide.

Metaphore : Un explorateur classe des plantes inconnues dans des paniers selon leur ressemblance visuelle, sans connaître leur nom.

🔍 Détails techniques

L’algorithme reçoit des données brutes sans étiquettes et cherche à découvrir des regroupements naturels ou à réduire la complexité des données (“Unsupervised Machine Learning Algorithms” 2021).

• Clustering : Regroupement d’observations similaires (ex. : segmentation de clients via K-Means) (“Advantages and Disadvantages of k-Means,” n.d.).
• Réduction de dimension : Simplification des données en ne gardant que l’information essentielle (ex. : PCA) (Shlens 2014).

Cas d’usage : Systèmes de recommandation, détection d’anomalies, compression de données.

🌗 Apprentissage Semi-Supervisé

Utiliser quelques exemples corrigés pour s’aider à trier une montagne de données brutes.

Metaphore : Un étudiant a seulement 3 exercices corrigés par son professeur, et doit s’en inspirer pour résoudre et classer 100 exercices non corrigés.

🔍 Détails techniques

Cette approche hybride associe une petite quantité de données étiquetées à un très grand volume de données brutes pour réduire le coût élevé de l’annotation manuelle (Chapelle, Schölkopf, and Zien 2006).

• Pseudo-étiquetage : Le modèle s’entraîne sur les données étiquetées puis étiquette lui-même les données brutes.
• Graphes de similarité : Propagation des étiquettes connues aux observations les plus proches.

Cas d’usage : Classification de pages web, indexation d’images médicales, reconnaissance de la parole.

🎮 Apprentissage par Renforcement

Apprendre par l’action, l’erreur, et la récompense.

Metaphore : Dresser un chien en lui offrant des friandises (récompenses) pour ses bonnes actions ou en l’ignorant pour ses erreurs.

🔍 Détails techniques

Un agent autonome interagit avec un environnement dynamique pour maximiser une récompense cumulative au fil du temps (Sutton and Barto 2018).

• Exploration vs Exploitation : Arbitrage permanent entre tester de nouvelles actions et exploiter les connaissances déjà acquises.
• Algorithmes clés : Q-Learning, PPO, SAC.

Cas d’usage : Robotique industrielle, voitures autonomes, IA de jeux (AlphaGo, échecs), gestion de portefeuilles financiers.

L’impact stratégique : Le choix entre classification et clustering modifie radicalement l’objectif métier. Là où la classification répond à une question fermée sur une catégorie connue (ex: “ce client va-t-il résilier ?”), le clustering permet la découverte de segments de marché “cachés”. Cela offre une opportunité de différenciation par la révélation de niches comportementales jusqu’alors invisibles.

1.2.2 L’Ère de l’Apprentissage Profond pour les Données Complexes

Les algorithmes classiques sont bons avec des tableaux bien rangés. Mais pour des données non structurées — images, sons, textes, vidéos — ils sont dépassés. C’est là qu’entre en jeu le Deep Learning.

Pour le volet supervisé, deux grandes architectures dominent la perception automatisée :

• Les Réseaux de Neurones Convolutifs (CNN - Convolutional Neural Networks) : Principalement utilisés pour la vision par ordinateur. Ils utilisent des “filtres” mathématiques et des poids pour balayer une image et en extraire des textures, des contours, puis des sémantiques spatiales complexes (“Understanding Weights and Biases in Neural Networks: The Core of AI Decision-Making,” n.d.).
• Les Réseaux de Neurones Récurrents (RNN - Recurrent Neural Networks) : Conçus spécifiquement pour la persistance de l’information. Contrairement aux CNN, ils possèdent une “mémoire” interne qui leur permet de traiter des données séquentielles, comme les séries temporelles (météo, bourse) ou le traitement du langage naturel (NLP).

1.2.3 Les Architectures Génératives et Non-Supervisées

Si les CNN et les RNN ont excellé dans la classification, de nouvelles architectures ont bouleversé le domaine non-supervisé en rendant les machines capables de créer :

• Les Auto-encodeurs : Des réseaux qui apprennent à compresser (encoder) la donnée dans un espace très réduit, puis à la reconstruire (décoder). Ils sont excellents pour la détection d’anomalies et la réduction de dimension extrême.
• Les GANs (Réseaux Antagonistes Génératifs) : Une architecture fascinante opposant deux réseaux (un Faussaire qui génère des données, et un Détective qui essaie de repérer les fausses données). Cette compétition pousse le réseau à synthétiser du contenu d’un réalisme bluffant (“BIAS-VARIANCE TRADEOFF IN MACHINE LEARNING: CONCEPTS & TUTORIALS,” n.d.).
• Les Transformateurs (Transformers) : L’architecture derrière les LLM modernes (comme ChatGPT). Ils utilisent des mécanismes d’attention pour comprendre le contexte global d’une séquence de données, généralisant des motifs d’une complexité inédite.

1.2.4 L’Impact Stratégique de la Perception Automatisée

Ces réseaux ne suivent pas des règles écrites à la main. Ils apprennent à reconnaître les choses — un chat de dos, dans l’ombre, stylisé — parce qu’ils ont absorbé des milliers d’exemples. Cette flexibilité vient de l’ajustement de millions de petits paramètres internes, que nous allons explorer dans le chapitre suivant avec la descente de gradient (“Understanding Weights and Biases in Neural Networks: The Core of AI Decision-Making,” n.d.).

1.3 Mécanique de l’Optimisation

Un modèle qui prédit bien, ce n’est pas qu’une bonne architecture — c’est surtout un apprentissage bien guidé. Comment une machine apprend-elle ? En commettant des erreurs, en les mesurant, et en se corrigeant — encore et encore. C’est cette mécanique qu’on appelle l’optimisation.

1.3.1 Modèles, Données et Apprentissage

Pour démystifier ce qu’est réellement l’apprentissage en machine learning, nous pouvons utiliser une analogie physique simple : le moulage.

• Les Données (L’original) : Imaginez que vos données d’entraînement constituent une figurine de référence. Informatiquement, ce sont des matrices de nombres bruts.
• Le Modèle (La matière) : Le modèle est la matière brute avec laquelle nous allons fabriquer un moule autour de cette figurine. Cette matière est définie par des nombres modifiables.
• L’Apprentissage (Le processus) : Apprendre consiste à presser, déformer et ajuster cette matière itérativement pour qu’elle épouse le plus parfaitement possible la forme de la figurine originale, afin de pouvoir en générer de nouvelles à l’avenir.

🛠️ Le Moule et l’Objet

Imaginez que votre jeu de données est une pièce mécanique complexe (avec sa forme globale et ses micro-rayures). Votre modèle d’IA est un matériau de moulage. L’apprentissage (les époques) consiste à presser ce matériau sur l’objet pour en capturer la forme.

🛠️ Presse en Action

viewof epoch = aptitek.createVerticalSlider({
  label: "Pression",
  min: 0, max: 100, step: 1,
  value: 0,
  direction: "down",
  height: 200
})

objectData = d3.range(0, 100, 2).map(x => ({
  x: x,
  y: 60 + 25 * Math.sin(x / 12) + (x % 8 === 0 ? 12 : -4) // Macro-forme + Micro-texture
}))

// ==========================================
// 🎨 MOTEUR DE RENDU D3
// ==========================================

graph1 = {
  const width = 800;
  const height = 250;

  // Création du SVG
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("class", "w-100 h-auto");

  // Échelles
  const xScale = d3.scaleLinear()
    .domain([0, 100])
    .range([50, width - 50]);

  const yScale = d3.scaleLinear()
    .domain([0, 100])
    .range([height - 30, 30]);

  // Générateur de ligne (Spline adoucie)
  const line = d3.line()
    .curve(d3.curveMonotoneX)
    .x(d => xScale(d.x))
    .y(d => yScale(d.y));

  // 1. Rendu de L'Objet Original (La Donnée)
  svg.append("path")
    .datum(objectData)
    .attr("fill", "none")
    // Utilisation stricte des tokens Bootstrap/Solarized
    .attr("stroke", "var(--sol-base01)")
    .attr("stroke-width", 3)
    .attr("stroke-dasharray", "4 4")
    .attr("d", line);

  // 2. Calcul dynamique du Moule (Le Modèle)
  // Interpolation de la position Y basée sur l'état 'epoch'
  const moldData = objectData.map(d => {
    const startY = 100; // Position de repos initiale du moule (très haut)
    const targetY = d.y;
    // Plus epoch augmente, plus currentY s'approche de targetY
    const currentY = startY + (targetY - startY) * (epoch / 100);
    return { x: d.x, y: currentY };
  });

  // 3. Rendu du Moule Dynamique
  svg.append("path")
    .datum(moldData)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-yellow)") // Couleur sémantique Primary
    .attr("stroke-width", 6)
    .attr("stroke-linecap", "round")
    .attr("stroke-linejoin", "round")
    .attr("d", line);

  // Projection dans le DOM
  const container = document.getElementById("d3-graph-1-container");
  if (container) {
    container.replaceChildren(svg.node());
  }

  return svg.node();
}

1.3.2 Poids et Biais

Pour ajuster notre moule à la bonne forme, nous tournons deux types de boutons : les poids (qui augmentent ou diminuent l’importance d’une information) et le biais (qui décale l’ensemble du moule vers le haut ou le bas).

Dans cette matière à mouler, deux types de paramètres contrôlent tout (“Understanding Weights and Biases in Neural Networks: The Core of AI Decision-Making,” n.d.; Glander, n.d.) :

• Les Poids : Ce sont des “boutons de volume”. Ils amplifient ou atténuent l’importance de chaque signal d’entrée. Plus le poids est grand, plus cette entrée compte dans la décision finale. C’est la malléabilité de notre moule.
• Le Biais : Un paramètre souvent sous-estimé. Imaginez-le comme le revenu de base du modèle — le niveau de réponse minimal même quand toutes les entrées sont nulles. Il donne la flexibilité de décaler la réponse du modèle vers le haut ou le bas.

🔢 Détail mathématique

Le calcul de base d’un neurone s’écrit (Trofimov 2020) :

y = w \cdot x + b

où x est l’entrée, w le poids (importance), b le biais (décalage). Le but de l’apprentissage : trouver les valeurs de w et b qui minimisent l’erreur.

🎛️ Poids et Biais

viewof bias = aptitek.createVerticalSlider({
  label: "Biais (b)",
  min: -40, max: 40, step: 1,
  value: 0,
  direction: "down",
  height: 200
})

viewof weight = aptitek.createVerticalSlider({
  label: "Poids (w)",
  min: 0, max: 1.5, step: 0.1,
  value: 0.2,
  direction: "down",
  height: 200
})

// ==========================================
// 🎨 MOTEUR DE RENDU D3 (Graphique 2)
// ==========================================

graph2 = {
  const width = 800;
  const height = 250;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("class", "w-100 h-auto");

  // Définition des marqueurs pour les flèches vectorielles
  const defs = svg.append("defs");

  // Flèche Bleue (Biais)
  defs.append("marker")
    .attr("id", "arrow-bias")
    .attr("viewBox", "0 0 10 10")
    .attr("refX", 8)
    .attr("refY", 5)
    .attr("markerWidth", 6)
    .attr("markerHeight", 6)
    .attr("orient", "auto")
    .append("path")
    .attr("d", "M 0 0 L 10 5 L 0 10 z")
    .attr("fill", "var(--sol-blue)");

  // Flèche Magenta (Poids)
  defs.append("marker")
    .attr("id", "arrow-weight")
    .attr("viewBox", "0 0 10 10")
    .attr("refX", 8)
    .attr("refY", 5)
    .attr("markerWidth", 5)
    .attr("markerHeight", 5)
    .attr("orient", "auto")
    .append("path")
    .attr("d", "M 0 0 L 10 5 L 0 10 z")
    .attr("fill", "var(--sol-magenta)");

  const xScale = d3.scaleLinear().domain([0, 100]).range([50, width - 50]);
  const yScale = d3.scaleLinear().domain([0, 120]).range([height - 30, 30]);

  const line = d3.line()
    .curve(d3.curveMonotoneX)
    .x(d => xScale(d.x))
    .y(d => yScale(d.y));

  // 1. L'Objet (Toujours en pointillé discret)
  // On réutilise objectData défini dans le bloc OJS du Graphique 1
  svg.append("path")
    .datum(objectData)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-base01)")
    .attr("stroke-width", 2)
    .attr("stroke-dasharray", "3 3")
    .attr("d", line);

  // 2. Mathématiques : Calcul des positions
  const baseLineY = 100 - bias; // Position neutre + Biais

  const moldData2 = objectData.map(d => {
    // La déformation est proportionnelle à la distance entre l'objet et la ligne de repos 100
    const deltaY = d.y - 100;
    const currentY = baseLineY + (deltaY * weight);
    return { x: d.x, y: currentY, targetY: d.y, baseY: baseLineY };
  });

  // 3. Visualisation du Biais (Ligne de base décalée)
  svg.append("line")
    .attr("x1", xScale(0))
    .attr("y1", yScale(baseLineY))
    .attr("x2", xScale(100))
    .attr("y2", yScale(baseLineY))
    .attr("stroke", "var(--sol-blue)")
    .attr("stroke-width", 2)
    .attr("stroke-dasharray", "6 4")
    .attr("opacity", 0.6);

  // Indicateur global de biais (Flèche à gauche)
  svg.append("line")
    .attr("x1", xScale(2))
    .attr("y1", yScale(100))
    .attr("x2", xScale(2))
    .attr("y2", yScale(baseLineY))
    .attr("stroke", "var(--sol-blue)")
    .attr("stroke-width", 3)
    .attr("marker-end", "url(#arrow-bias)");

  // 4. Visualisation des Poids (Flèches d'étirement locales)
  // On ne dessine les flèches que sur certains points pour ne pas surcharger visuellement
  const samplePoints = moldData2.filter((d, i) => i % 6 === 0 && weight > 0);

  svg.selectAll(".weight-vector")
    .data(samplePoints)
    .enter()
    .append("line")
    .attr("class", "weight-vector")
    .attr("x1", d => xScale(d.x))
    .attr("y1", d => yScale(d.baseY))
    .attr("x2", d => xScale(d.x))
    .attr("y2", d => yScale(d.y))
    .attr("stroke", "var(--sol-magenta)")
    .attr("stroke-width", 2)
    .attr("opacity", 0.7)
    .attr("marker-end", "url(#arrow-weight)");

  // 5. Rendu du Moule Final (Le Modèle w*x + b)
  svg.append("path")
    .datum(moldData2)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-yellow)")
    .attr("stroke-width", 4)
    .attr("stroke-linecap", "round")
    .attr("stroke-linejoin", "round")
    .attr("d", line);

  const container = document.getElementById("d3-graph-2-container");
  if (container) {
    container.replaceChildren(svg.node());
  }

  return svg.node();
}

1.3.3 La Fonction de Perte et la Boussole du Gradient

La fonction de perte mesure l’erreur globale (combien notre moule est imparfait) tandis que le gradient est une boussole qui nous indique dans quelle direction modifier nos réglages pour réduire cette erreur.

Pour ajuster le moule, il faut d’abord mesurer à quel point il est mauvais.

• La Fonction de Perte : C’est le thermomètre de l’erreur. Elle mesure l’écart entre la prédiction du modèle et la réalité. Plus l’écart est grand, plus la valeur est élevée. L’objectif : la faire descendre le plus possible (Grover, n.d.; “Mean Squared Error,” n.d.; Mitra 2023).
• Le Gradient : Une fois l’erreur mesurée, comment savoir dans quel sens corriger ? Le gradient est une boussole : il indique la direction et la force avec laquelle ajuster chaque paramètre pour réduire l’erreur.

🔢 Ce qu’est un gradient

Le gradient est un vecteur de dérivées partielles de la fonction de perte par rapport à chaque paramètre. Intuitivement : si vous êtes perdu dans un paysage montagneux et voulez atteindre la vallée, le gradient vous dit quelle pente descendre à chaque pas. Mathématiquement, pour un paramètre w : \frac{\partial \mathcal{L}}{\partial w}.

🧭 Perte et Gradient

viewof epochG3 = aptitek.createVerticalSlider({
  label: "Époques",
  min: 0, max: 100, step: 1,
  value: 0,
  direction: "down",
  height: 270
})

// ==========================================
// 🎨 MOTEUR DE RENDU D3 (Graphique 3)
// ==========================================

graph3 = {
  const width = 800;
  const height = 320; // Un peu plus grand pour accueillir la courbe de perte en bas

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("class", "w-100 h-auto");

  // Définition des marqueurs de flèches pour le Gradient (Rouge)
  const defs = svg.append("defs");
  defs.append("marker")
    .attr("id", "arrow-gradient")
    .attr("viewBox", "0 0 10 10")
    .attr("refX", 6)
    .attr("refY", 5)
    .attr("markerWidth", 5)
    .attr("markerHeight", 5)
    .attr("orient", "auto")
    .append("path")
    .attr("d", "M 0 0 L 10 5 L 0 10 z")
    .attr("fill", "var(--sol-red)");

  // Échelles de la zone supérieure (Géométrie du moule)
  const xScale = d3.scaleLinear().domain([0, 100]).range([50, width - 50]);
  const yScale = d3.scaleLinear().domain([0, 100]).range([200, 20]);

  // Échelles de la zone inférieure (Courbe de convergence de la Perte)
  const xLossScale = d3.scaleLinear().domain([0, 100]).range([50, width - 50]);
  const yLossScale = d3.scaleLinear().domain([0, 1500]).range([300, 230]);

  const lineGenerator = d3.line()
    .curve(d3.curveMonotoneX)
    .x(d => xScale(d.x))
    .y(d => yScale(d.y));

  // --- 1. CALCULS DES ETATS ET GÉOMÉTRIE ---
  const startY = 95;
  let totalSquareError = 0;

  const currentSimulationData = objectData.map(d => {
    // Évolution du modèle similaire au graphe 1
    const currentY = startY + (d.y - startY) * (epochG3 / 100);
    const error = d.y - currentY; // Distance/Erreur locale
    totalSquareError += error * error;

    return {
      x: d.x,
      targetY: d.y,
      moldY: currentY,
      error: error
    };
  });

  const meanSquaredError = totalSquareError / currentSimulationData.length;

  // Mise à jour dynamique du badge HTML de perte (via classes sémantiques de ton thème)
  const badge = document.getElementById("loss-badge");
  if (badge) {
    badge.textContent = meanSquaredError.toFixed(1);
    badge.dataset.state = meanSquaredError > 100 ? "danger" : "success";
  }

  // --- 2. RENDU GÉOMÉTRIQUE (Zone Supérieure) ---

  // Tracé des espaces vides / Air Gaps (Volume de Perte)
  const areaLoss = d3.area()
    .curve(d3.curveMonotoneX)
    .x(d => xScale(d.x))
    .y0(d => yScale(d.moldY))
    .y1(d => yScale(d.targetY));

  svg.append("path")
    .datum(currentSimulationData)
    .attr("fill", "var(--sol-red)")
    .attr("opacity", 0.15)
    .attr("d", areaLoss);

  // Profil de l'Objet Réel (Données)
  svg.append("path")
    .datum(objectData)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-base01)")
    .attr("stroke-width", 2)
    .attr("stroke-dasharray", "4 4")
    .attr("d", lineGenerator);

  // Vecteurs de Gradients (Forces directionnelles)
  // Échantillonnage pour éviter l'encombrement visuel
  const vectors = currentSimulationData.filter((d, i) => i % 4 === 0 && Math.abs(d.error) > 1);

  svg.selectAll(".gradient-arrow")
    .data(vectors)
    .enter()
    .append("line")
    .attr("class", "gradient-arrow")
    .attr("x1", d => xScale(d.x))
    .attr("y1", d => yScale(d.moldY))
    .attr("x2", d => xScale(d.x))
    // La flèche pointe vers la cible (direction de la descente de gradient)
    .attr("y2", d => yScale(d.targetY - (d.error * 0.15)))
    .attr("stroke", "var(--sol-red)")
    .attr("stroke-width", 1.5)
    .attr("opacity", 0.6)
    .attr("marker-end", "url(#arrow-gradient)");

  // Tracé du Moule (Modèle en cours de compression)
  svg.append("path")
    .datum(currentSimulationData)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-yellow)")
    .attr("stroke-width", 4)
    .attr("d", lineGenerator);

  // --- 3. RENDU DE LA COURBE DE PERTE HISTORIQUE (Zone Inférieure) ---

  // Génération de l'historique complet de la perte de l'époque 0 jusqu'à l'époque actuelle
  const lossHistory = d3.range(0, epochG3 + 1).map(e => {
    let sqErr = 0;
    objectData.forEach(d => {
      const mY = startY + (d.y - startY) * (e / 100);
      const err = d.y - mY;
      sqErr += err * err;
    });
    return { epoch: e, lossValue: sqErr / objectData.length };
  });

  // Séparateur visuel horizontal
  svg.append("line")
    .attr("x1", 50)
    .attr("y1", 215)
    .attr("x2", width - 50)
    .attr("y2", 215)
    .attr("stroke", "var(--sol-base02)")
    .attr("stroke-width", 1)
    .attr("stroke-dasharray", "2 2");

  // Titre du mini-graphe
  svg.append("text")
    .attr("x", 50)
    .attr("y", 226)
    .attr("fill", "var(--sol-base00)")
    .attr("font-family", "var(--font-code, monospace)")
    .attr("font-size", "10px")
    .text("HISTORIQUE DE LA PERTE GLOBALE : J(w,b)");

  // Axes discrets de la courbe de perte
  svg.append("line")
    .attr("x1", 50)
    .attr("y1", yLossScale(0))
    .attr("x2", width - 50)
    .attr("y2", yLossScale(0))
    .attr("stroke", "var(--sol-base02)")
    .attr("stroke-width", 1);

  // Générateur de la courbe de perte
  const lossLineGenerator = d3.line()
    .x(d => xLossScale(d.epoch))
    .y(d => yLossScale(d.lossValue));

  // Tracé de la courbe d'historique de perte
  svg.append("path")
    .datum(lossHistory)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-red)")
    .attr("stroke-width", 2)
    .attr("d", lossLineGenerator);

  // Point d'état actuel sur la courbe de perte
  if (lossHistory.length > 0) {
    const currentLoss = lossHistory[lossHistory.length - 1];
    svg.append("circle")
      .attr("cx", xLossScale(currentLoss.epoch))
      .attr("cy", yLossScale(currentLoss.lossValue))
      .attr("r", 4)
      .attr("fill", "var(--sol-red)");
  }

  // Projection Finale dans l'UI
  const container = document.getElementById("d3-graph-3-container");
  if (container) {
    container.replaceChildren(svg.node());
  }

  return svg.node();
}

1.3.4 La Descente de Gradient et les Optimiseurs Modernes

Pour trouver le réglage parfait, on lâche une bille dans notre paysage d’erreurs : elle roule vers la vallée la plus basse (la descente de gradient). Le taux d’apprentissage contrôle la vitesse de la bille, et les optimiseurs (comme Adam) ajustent automatiquement cette vitesse pour éviter qu’elle ne se perde.

La Descente de Gradient est le mécanisme central : à chaque étape, on ajuste les paramètres dans le sens qui réduit l’erreur (“Gradient Descent,” n.d.; Ruder 2016).

Imaginez la fonction de perte comme un paysage montagneux : chaque combinaison possible de paramètres correspond à un point dans ce relief. Le but est de trouver le point le plus bas (l’erreur minimale). 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 dans tous les sens sans jamais se stabiliser (You et al., n.d.; Dharanalakota, Raikar, and Ghosh 2025).
• 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 (Chawla, n.d.; Dauphin et al., n.d.).

Les optimiseurs modernes automatisent ces réglages (“Lecture 2: Optimization Algorithms in Neural Networks,” n.d.; Bottou 2010) :

• Adam : L’optimiseur par défaut aujourd’hui — il adapte automatiquement le pas d’apprentissage pour chaque paramètre (“Why Adam Optimizer Outperforms SGD? Adaptive Momentum Explained,” n.d.).
• 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 s’écrit (voir le Glossaire) : w \leftarrow w - \eta \cdot \nabla_w \mathcal{L}

• \leftarrow (flèche gauche) : l’opérateur d’affectation (le paramètre à gauche prend la nouvelle valeur calculée à droite à chaque étape).
• \eta (lettre grecque êta) : le taux d’apprentissage (learning rate).
• \nabla_w (nabla avec indice w) : le gradient de la perte par rapport aux poids w (vecteur des dérivées partielles).
• \mathcal{L} : la fonction de perte (loss).

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}

• t en indice (ex: m_t) : représente le pas d’optimisation ou l’itération temporelle en cours.
• La notation chapeau \hat{} (ex: \hat{m}_t, \hat{v}_t) : désigne les moyennes mobiles corrigées pour éliminer le biais d’initialisation à zéro.
• \epsilon (lettre grecque epsilon) : une constante de stabilité numérique (ex: 10^{-8}) empêchant toute division par zéro.

1.3.5 Simulation de la Trajectoire d’Optimisation

Visualisez de manière interactive comment le choix de l’optimiseur et ses paramètres modifient la trajectoire de la descente dans un paysage de coût en trois dimensions.

🏔️ Descente de Gradient 3D

• Lancer
• Pause
• Reset

Momentum

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

RMSprop

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

AdaGrad

AdaGrad adapte le pas d’apprentissage de chaque paramètre selon l’historique de ses gradients accumulés depuis le début (efficace pour les caractéristiques éparses).

Adam

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

mutable optType = "momentum"

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

viewof optParam = {
  if (optType === "momentum") {
    return Inputs.range([0.5, 1.0], {
      value: 0.771,
      step: 0.001,
      label: "⚡ Inertie (Momentum)"
    });
  } else if (optType === "rmsprop") {
    return Inputs.range([0.8, 0.999], {
      value: 0.9,
      step: 0.001,
      label: "⚡ Taux de Décroissance (β)"
    });
  } else if (optType === "adagrad") {
    return Inputs.range([0.01, 0.5], {
      value: 0.15,
      step: 0.01,
      label: "⚡ Taux d'Apprentissage (η)"
    });
  } else { // adam
    return Inputs.range([0.5, 0.999], {
      value: 0.9,
      step: 0.001,
      label: "⚡ Premier Moment (β₁)"
    });
  }
}

🔍 Surface de Coût 3D

Coût (Loss)

7.9000

θ₁

2.200

θ₂

1.500

Vitesse

0.00

import { createGradientSimulation } from "../../assets/js/simulations/gradient-descent.js"

// Reinitialises the Plotly chart only when the optimizer type changes.
// Does NOT depend on optParam — slider changes are handled by _gradPath below.
_gradSim = {
  const sm = createGradientSimulation({
    containerId: "gradient-descent-container",
    metrics: {
      cost:   "grad-3d-cost",
      theta1: "grad-3d-theta1",
      theta2: "grad-3d-theta2",
      speed:  "grad-3d-speed"
    }
  });
  if (!sm) return null;
  const controller = new aptitek.SimulationController(sm, {
    play:  "#btn-grad-play",
    pause: "#btn-grad-pause",
    reset: "#btn-grad-reset"
  });
  invalidation.then(() => controller.destroy());
  return sm;
}

// Updates the descent path whenever optParam (or optType) changes.
// No chart re-initialisation — just recomputes the trajectory and resets the ball.
_gradPath = {
  if (_gradSim) _gradSim.updatePath(optType, optParam);
  return aptitek.noop();
}

1.4 Le Compromis Biais-Variance

Trouver le bon modèle est une affaire de compromis : soit il est trop rigide et rate les grandes tendances (le biais), soit il est trop fluide et mémorise les moindres détails inutiles, y compris le bruit (la variance).

Un bon modèle doit trouver le juste milieu entre deux défauts opposés : trop simpliste (il rate les vraies tendances) ou trop rigoureux (il mémorise le bruit au lieu d’apprendre). C’est le compromis biais-variance (“BIAS-VARIANCE TRADEOFF IN MACHINE LEARNING: CONCEPTS & TUTORIALS,” n.d.).

1.4.1 Le Biais et le Sous-apprentissage

C’est le défaut d’un modèle trop simpliste, comme un moule en métal rigide incapable d’épouser les courbes d’une figurine (le sous-apprentissage ou underfitting).

Le Biais est l’erreur systématique d’un modèle trop simplet. Il “manque” les vraies tendances des données — comme un moule trop rigide qui ne parvient pas à épouser la forme de la figurine. Le modèle reste grossièrement plat, incapable de capter la structure réelle : c’est le sous-apprentissage (underfitting) (“Bias-Variance Analysis: Theory and Practice,” n.d.; “Bias-Variance Trade Off - Machine Learning,” n.d.; Ghadigaonkar 2025).

🔢 Définition formelle (Biais)

\text{Biais}(\hat{Y}) = E[\hat{Y}] - Y (voir le Glossaire)

• \hat{Y} (“Y-chapeau”) : la prédiction estimée par le modèle. La notation chapeau (\hat{}) est la convention standard en statistiques pour désigner un estimateur.
• Y : la valeur réelle de référence (la vérité terrain).
• E[\cdot] : l’espérance mathématique (la moyenne théorique attendue des prédictions sur différents jeux d’entraînement).

L’espérance de la prédiction moins la vraie valeur — l’écart moyen et systématique entre ce que le modèle prédit et la réalité.

1.4.2 La Variance et le Sur-apprentissage

C’est le défaut d’un modèle trop zélé, comme un moule en silicone trop liquide qui moule aussi la poussière et les rayures de la figurine (le sur-apprentissage ou overfitting).

La Variance représente l’erreur liée à une sensibilité excessive aux fluctuations du jeu d’entraînement. Le modèle procède à une mémorisation du bruit (“What Is Overfitting Vs. Underfitting?” n.d.; “Bias/Variance Tradeoff and Ensemble Methods,” n.d.) au lieu d’une généralisation.

🔢 Définition formelle (Variance)

\text{Variance}(\hat{Y}) = E\left[(\hat{Y} - E[\hat{Y}])^2\right] (voir le Glossaire)

• \hat{Y} : la prédiction du modèle.
• E[\hat{Y}] : la valeur moyenne prédite par le modèle sur tous les entraînements possibles.
• E[\cdot] (crochets extérieurs) : l’espérance calculée sur l’écart au carré, mesurant ainsi la dispersion.

La mesure de la dispersion des prédictions du modèle autour de sa moyenne pour différents jeux d’entraînement.

Dans notre analogie, la matière du moule est ici beaucoup trop liquide et réactive. Non seulement elle capture parfaitement la forme générale de la figurine, mais elle va jusqu’à s’infiltrer dans la moindre micro-rayure et englober chaque grain de poussière présent sur cet exemplaire précis. Le résultat est un sur-apprentissage (overfitting). Si vous essayez d’utiliser ce moule ultra-spécifique pour valider une nouvelle figurine légèrement différente, il sera totalement inadapté et produira une erreur importante.

⚖️ Biais et Variance

Propriété du matériau (Complexité du modèle) :

// Curseur allant de 0 (Très Rigide) à 100 (Très Fluide)
viewof complexity = Inputs.range([0, 100], {
  value: 50,
  step: 1
})

// ==========================================
// 🎨 MOTEUR DE RENDU D3 (Graphique 4)
// ==========================================

graph4 = {
  const width = 800;
  const height = 250;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("class", "w-100 h-auto");

  const xScale = d3.scaleLinear().domain([0, 100]).range([50, width - 50]);
  const yScale = d3.scaleLinear().domain([0, 100]).range([height - 30, 30]);

  // Ligne générique D3
  const lineGenerator = d3.line()
    .curve(d3.curveMonotoneX)
    .x(d => xScale(d.x))
    .y(d => yScale(d.moldY));

  // --- 1. LOGIQUE D'INTERPOLATION (Rigide -> Optimal -> Fluide) ---

  // On calcule l'état du modèle en fonction du slider (0 à 100)
  const currentModelData = objectData.map(d => {
    // État 1 : Rigide (Sous-apprentissage / Biais fort) -> Une simple ligne droite (Moyenne Y = 60)
    const yRigid = 60;

    // État 2 : Optimal (Équilibre) -> Le vrai signal sans le bruit (Macro-forme)
    const yOptimal = 60 + 25 * Math.sin(d.x / 12);

    // État 3 : Fluide (Sur-apprentissage / Variance forte) -> Épouse parfaitement le bruit
    const yOverfit = d.y;

    let currentY;

    if (complexity <= 50) {
      // Transition Rigide (0) -> Optimal (50)
      const ratio = complexity / 50;
      currentY = yRigid + (yOptimal - yRigid) * ratio;
    } else {
      // Transition Optimal (50) -> Fluide (100)
      const ratio = (complexity - 50) / 50;
      currentY = yOptimal + (yOverfit - yOptimal) * ratio;
    }

    return { x: d.x, targetY: d.y, moldY: currentY };
  });

  // --- 2. GESTION DU BADGE UI (Diagnostic) ---
  const badge = document.getElementById("complexity-badge");
  let lineColor = "var(--sol-yellow)";

  if (badge) {
    if (complexity < 30) {
      badge.textContent = "SOUS-APPRENTISSAGE (Biais Élevé)";
      badge.dataset.state = "warning";
      lineColor = "var(--sol-orange)";
    } else if (complexity > 70) {
      badge.textContent = "SUR-APPRENTISSAGE (Variance Élevée)";
      badge.dataset.state = "danger";
      lineColor = "var(--sol-red)";
    } else {
      badge.textContent = "GÉNÉRALISATION OPTIMALE";
      badge.dataset.state = "success";
      lineColor = "var(--sol-green)";
    }
  }

  // --- 3. RENDU GRAPHIQUE ---

  // A. Les données brutes (Le Nuage de points représentant l'objet avec ses défauts)
  svg.selectAll(".data-point")
    .data(objectData)
    .enter()
    .append("circle")
    .attr("class", "data-point")
    .attr("cx", d => xScale(d.x))
    .attr("cy", d => yScale(d.y))
    .attr("r", 4)
    .attr("fill", "var(--sol-base01)")
    .attr("opacity", 0.6);

  // B. Optionnel : L'ombre du signal optimal parfait (pour référence visuelle)
  const optimalData = objectData.map(d => ({ x: d.x, moldY: 60 + 25 * Math.sin(d.x / 12) }));
  svg.append("path")
    .datum(optimalData)
    .attr("fill", "none")
    .attr("stroke", "var(--sol-base02)")
    .attr("stroke-width", 2)
    .attr("stroke-dasharray", "4 4")
    .attr("d", lineGenerator);

  // C. Le Modèle (Le Moule avec sa rigidité/fluidité actuelle)
  svg.append("path")
    .datum(currentModelData)
    .attr("fill", "none")
    .attr("stroke", lineColor)
    .attr("stroke-width", 5)
    .attr("stroke-linecap", "round")
    .attr("stroke-linejoin", "round")
    .attr("d", lineGenerator);

  // Projection DOM
  const container = document.getElementById("d3-graph-4-container");
  if (container) {
    container.replaceChildren(svg.node());
  }

  return svg.node();
}

1.4.3 Le Phénomène de Double Descente

Parfois, un très grand modèle que l’on pense condamné au sur-apprentissage recommence mystérieusement à s’améliorer : c’est la double descente, une zone où le modèle découvre des règles encore plus simples et robustes.

La courbe classique en U montre que la variance augmente avec la complexité. Cependant, le Deep Learning montre parfois une Double Descente (la perte diminue de nouveau pour de très grands modèles).

🔍 Explication de la Double Descente et de l’Unfolding

Selon l’hypothèse de l’unfolding, ce phénomène est souvent un artefact visuel lié à un scaling composite (variation simultanée de la taille du modèle et des données) (Cimadevila, n.d.). Si l’on fait varier la complexité et les données indépendamment, le modèle réadopte des motifs classiques en U ou en L (Cimadevila, n.d.).

1.4.4 L’Impact Stratégique

• Diagnostic : Une erreur d’entraînement très faible couplée à une erreur de test élevée indique une variance excessive (“What Is Overfitting Vs. Underfitting?” n.d.; “A Deep Dive into Learning Curves in Machine Learning,” n.d.).
• Ajustement : Il faut adapter l’architecture ou régulariser le modèle plutôt que de sur-interpréter les performances (Yates et al., n.d.).

1.5 Stratégies de Régularisation et Généralisation

La régularisation regroupe les techniques permettant d’empêcher un modèle de sur-apprendre (mémoriser le bruit), en agissant comme une contrainte ou une force externe qui le force à rester simple (comme un film plastique tendu sur le moule).

Si le sur-apprentissage (une variance excessive) est la maladie, la régularisation en est le remède. La régularisation impose une contrainte mathématique de “lissage” pour favoriser la généralisation en pénalisant la complexité excessive du modèle (“Early Stopping,” n.d.; Goyal 2021).

Pour reprendre notre analogie du moulage : si notre matière est devenue trop liquide et commence à s’infiltrer dans les micro-rayures de la figurine, la régularisation consiste à appliquer une force de tension externe (comme un film plastique tendu par-dessus). Cette contrainte empêche la matière de capter les détails superflus (le bruit) et la force à se concentrer uniquement sur la structure globale et pertinente (le signal).

1.5.1 Ridge, Lasso et Coefficients

Pour garder le modèle simple, on punit les poids trop grands en ajoutant une amende à l’erreur globale. Le Lasso (L1) supprime complètement les variables inutiles en mettant leur poids à zéro (comme un tri sélectif strict), tandis que le Ridge (L2) réduit doucement tous les poids sans jamais en éliminer aucun (comme un amortisseur général).

En apprentissage automatique, on applique cette contrainte en ajoutant une pénalité directement dans la fonction de perte. Cette pénalité sanctionne les paramètres (les poids ou coefficients) qui prennent trop d’importance. Deux approches géométriques s’opposent :

• Ridge (Régularisation L2) : Cette méthode ajoute une pénalité proportionnelle au carré des coefficients. Géométriquement, cela agit comme une contrainte circulaire concentrique autour de l’origine. Ridge réduit la magnitude globale des coefficients pour stabiliser le modèle. L’effet visuel est un “amortissement” : les valeurs sont compressées doucement vers le centre, mais ne sont pratiquement jamais réduites à zéro (Shizuya 2024; Dave 2020).
• Lasso (Régularisation L1) : Cette méthode ajoute une pénalité proportionnelle à la valeur absolue des coefficients. Géométriquement, la zone de contrainte prend la forme d’un losange (ou d’un diamant). En raison de ses angles aigus, l’optimisation a tendance à rencontrer cette contrainte directement sur les axes du repère géométrique. Le résultat est radical : le Lasso force mathématiquement certains coefficients à valoir exactement zéro (“What Is Overfitting Vs. Underfitting?” n.d.; “Lasso Vs. Ridge Regression: Why Lasso Creates Sparsity and Ridge Does Not,” n.d.; S et al. 2025).

🪄 Simulateur Interactif des Chemins de Régularisation

Lasso (L1)

Ridge (L2)

ElasticNet

mutable regType = "lasso"

_regTypeWatcher = {
  const w = aptitek.createTabsetWatcher(
    ".reg-type-tabset",
    { "Lasso (L1)": "lasso", "Ridge (L2)": "ridge", "ElasticNet": "elastic" },
    (val) => { mutable regType = val; }
  );
  invalidation.then(() => w.destroy());
  return aptitek.noop();
}

viewof regLambda = Inputs.range([0, 100], { value: 15, step: 1, label: "⚡ Intensité (λ)" })

🧪 Évolution des Coefficients Régressifs

{{title}}

{{body}}

type	max_lambda	color	title	body
lasso	0	var(–sol-cyan)	🟡 Lasso (λ = 0) : Régression standard (Moindres Carrés)	Sans aucune pénalité, le modèle garde toutes les variables, y compris la variable de Bruit (bruit purement aléatoire) avec un coefficient de +1.5. C’est la zone propice au surapprentissage (overfitting).
lasso	34	var(–sol-green)	🏆 Lasso (λ = {λ}) : Sélection intelligente active !	La pénalité L1 a immédiatement annulé la variable de Bruit (w = 0) ! Elle a également fortement réduit le coefficient de la variable Garage (qui fait doublon avec la Taille). Le modèle se concentre sur les variables réellement importantes.
lasso	74	var(–sol-yellow)	🟡 Lasso (λ = {λ}) : Sélection sévère	La pénalité élimine maintenant l’Âge et le Garage. Seules les variables fondamentales Taille et Chambres survivent dans l’équation. C’est idéal pour obtenir un modèle très parcimonieux et simple.
lasso	100	var(–sol-red)	⚠️ Lasso (λ = {λ}) : Sous-apprentissage (Underfitting)	La pénalité L1 est trop agressive. Elle a tué quasiment tous les coefficients. Même la Taille (variable majeure) s’approche de zéro. Le modèle a perdu sa capacité prédictive.
ridge	0	var(–sol-cyan)	🟡 Ridge (λ = 0) : Aucune régularisation	Le modèle conserve tous les coefficients au maximum. La colinéarité entre Taille et Garage n’est pas traitée, ce qui gonfle artificiellement la variance du modèle.
ridge	100	var(–sol-green)	🏆 Ridge (λ = {λ}) : Réduction de la variance (L2)	Observez la différence avec Lasso ! La pénalité Ridge ne réduit jamais aucun coefficient à exactement zéro (toutes les variables restent actives). Elle courbe et atténue les poids de manière progressive pour stabiliser le modèle face au Bruit, ce qui est parfait pour gérer la colinéarité (les variables corrélées) sans jeter d’information.
elastic	100	var(–sol-magenta)	🏆 ElasticNet (λ = {λ}) : Le Compromis L1 + L2	ElasticNet mélange le meilleur des deux mondes : il élimine complètement les variables de Bruit (comme Lasso) tout en conservant les variables corrélées ensemble avec des coefficients stables (effet de groupe Ridge), évitant le choix aléatoire d’une variable par rapport à une autre.

id	name	w0	color	desc	lassoThreshold	elasticThreshold
taille	Taille (m²)	8.0	var(–sol-cyan)	Variable majeure très prédictive.	0.98	0.99
chambres	Chambres	5.0	var(–sol-green)	Variable importante modérée.	0.72	0.85
garage	Garage	3.5	var(–sol-yellow)	Corrélée à Taille (Redondance).	0.28	0.45
age	Âge	-4.0	var(–sol-red)	Impact négatif sur le prix.	0.48	0.68
bruit	Bruit dB (Bruit)	1.5	var(–sol-magenta)	Bruit aléatoire sans intérêt.	0.12	0.20

import { updateRegularization } from "../../assets/js/simulations/regularization.js"

renderSimulator = {
  updateRegularization(regType, regLambda, {
    svgEl:     document.getElementById("reg-svg-container"),
    varsEl:    document.getElementById("reg-vars-container"),
    detailsEl: document.getElementById("reg-details-container")
  });
}

1.5.2 Elastic Net et Early Stopping

Pour réguler le modèle, on peut combiner les forces de tri et d’amortissement (ElasticNet), ou simplement interrompre l’entraînement en direct dès que le modèle commence à faire moins bien sur de nouvelles données (Early Stopping).

Face à des jeux de données complexes, d’autres stratégies complètent l’arsenal du Data Scientist :

• ElasticNet : Dans les cas où les données présentent de nombreuses variables fortement corrélées entre elles, on utilise cet hybride. Il combine littéralement le meilleur des deux mondes en fusionnant la contrainte circulaire (L2) et la contrainte en losange (L1) (Zou and Hastie, n.d.; N. 2024).
• Early Stopping (Arrêt prématuré) : Il s’agit d’une régularisation purement temporelle. Au lieu de complexifier la fonction de perte, on observe la courbe d’apprentissage en direct. On interrompt l’entraînement au point critique exact où le modèle commence à mémoriser le bruit (c’est-à-dire le moment où l’erreur sur les données de validation commence à remonter, formant une courbe en U) (“Early Stopping,” n.d.).

1.5.3 Le Lasso comme Gouvernance

Utiliser le Lasso n’est pas qu’un choix technique, c’est aussi un choix stratégique : en éliminant les données inutiles, il permet de réduire les coûts opérationnels et de rendre les décisions de l’IA faciles à expliquer pour les régulateurs.

L’impact d’une méthode comme le Lasso dépasse très largement la simple performance statistique. C’est un véritable outil de décision stratégique.

En annulant purement et simplement les coefficients des variables non contributives, le Lasso réalise une sélection automatique de variables. Il permet d’identifier les leviers métier réels qui influencent une prédiction. Cela a des conséquences directes en entreprise :

1. Réduction des coûts opérationnels : On peut stopper la collecte, le traitement et le stockage de flux de données qui s’avèrent finalement inutiles.
2. Auditabilité : Il simplifie drastiquement l’interprétabilité du modèle pour les instances de gouvernance, rendant l’IA transparente et explicable (“White Box”) (A. et al. 2020).

1.6 Expansion du Savoir par l’Augmentation de Données

L’augmentation de données consiste à tricher intelligemment en créant des variantes artificielles de nos exemples (rotation, zoom, bruit) pour forcer le modèle à comprendre la forme globale plutôt que de mémoriser les conditions de la photo.

Si la régularisation consiste à contraindre le modèle pour l’empêcher d’apprendre le bruit, l’augmentation de données (data augmentation) s’attaque au problème par l’autre bout : en enrichissant le jeu d’entraînement d’exemples artificiels mais réalistes (Shorten and Khoshgoftaar 2019). C’est une étape particulièrement critique pour assurer la robustesse d’un modèle lors de son déploiement en production, notamment dans les domaines de la vision par ordinateur (“What Is Overfitting Vs. Underfitting?” n.d.; Sandru, Georgescu, and Ionescu 2022).

1.6.1 Forger l’Invariance (L’Analogie du Moule)

Reprenons notre analogie une dernière fois. Si vous n’avez qu’une seule figurine, parfaitement droite et sous un éclairage idéal, pour créer votre moule, la matière risque de s’adapter uniquement à cette configuration parfaite. Si l’on vous présente ensuite la même figurine, mais couchée sur le côté ou dans la pénombre, votre moule (votre modèle) ne la reconnaîtra pas.

L’augmentation de données consiste à prendre cette figurine originale et à en créer artificiellement des dizaines de variantes avant le moulage : on la penche, on l’éloigne, on la salit avec un peu de poussière, on l’éclaire avec une lumière rasante. En forçant le modèle à s’entraîner sur toutes ces variations, on s’assure que le moule final capture l’essence géométrique et structurelle de l’objet, et non les conditions accidentelles de sa présentation.

1.6.2 Les Techniques d’Augmentation

Pour enrichir artificiellement le jeu d’entraînement, on applique diverses transformations programmées sur les données sources :

• Transformations géométriques : Rotation (tourner l’image), zoom (rapprocher ou éloigner), déformation (étirement affine) et recadrage (couper une partie de l’image) (“Affine Transformation,” n.d.; Anonymous, n.d.).
• Ajustements de qualité et colorimétrie : Ajout de bruit artificiel (comme de la “neige” sur une télévision), modification du contraste, de la luminosité ou de la saturation (Levi et al., n.d.).

🧪 Vue Machine

viewof augTransforms = Inputs.checkbox(
  ["rotation", "flip", "zoom", "deformation", "noise", "contrast", "brightness", "saturation"],
  {
    value: ["rotation"],
    label: "Transformations appliquées",
    format: (key) => ({
      rotation: "Rotation",
      flip: "Effet miroir",
      zoom: "Zoom",
      deformation: "Déformation",
      noise: "Ajout de bruit",
      contrast: "Contraste",
      brightness: "Luminosité",
      saturation: "Saturation"
    }[key])
  }
)

🖼️ Image Augmentée

import { updateDataAugmentation } from "../../assets/js/simulations/augmentation.js"

renderAugmentation = {
  updateDataAugmentation({
    transforms: augTransforms,
    previewEl: document.getElementById("augmentation-preview"),
    analysisEl: document.getElementById("augmentation-analysis")
  });
}

1.6.3 L’Impact Stratégique et Conclusion

Ces méthodes forcent mathématiquement le modèle à acquérir une invariance (“What Is Overfitting Vs. Underfitting?” n.d.; Hendrycks and Dietterich 2019). En vision industrielle, par exemple, le système de contrôle qualité doit pouvoir reconnaître un défaut sur une pièce de fabrication quels que soient l’angle de vue de la caméra, l’heure de la journée ou l’usure de l’éclairage de l’usine. L’augmentation de données garantit cette résilience.

Conclusion du Cours : La conception d’une intelligence artificielle performante ne se résume pas à empiler des couches de neurones. Elle exige une vision holistique où le choix de l’architecture (le type de moule), l’optimisation mathématique (la manière de presser la matière) et la qualité des données (les figurines de référence) convergent. C’est cette synergie qui permet de créer des systèmes non seulement statistiquement précis en laboratoire, mais résilients et stratégiquement alignés avec les réalités du monde physique.

1.7 TP Machine Learning

Cancer du sein ZIP

• tp02.ipynb (Notebook complet de synthèse à compléter)
• tp02.md (Fichier Markdown avec le code)

“A Deep Dive into Learning Curves in Machine Learning.” n.d. Weights & Biases. https://wandb.ai/mostafaibrahim17/ml-articles/reports/A-Deep-Dive-Into-Learning-Curves-in-Machine-Learning--Vmlldzo0NjA1ODY0.

A., Oyegoke O., Oyeyemi G. M., Adeleke M. O., and Kolawole R. O. 2020. “REGULARIZATION TECHNIQUES IN MULTIPLE LINEAR REGRESSION IN THE PRESENCE OF MULTICOLLINEARITY.” FULafia Journal of Science and Technology 6 (1): 48–53. https://lafiascijournals.org.ng/index.php/fjst/article/view/185.

“Advantages and Disadvantages of k-Means.” n.d. Google for Developers. https://developers.google.com/machine-learning/clustering/kmeans/advantages-disadvantages.

“Affine Transformation.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Affine_transformation.

“AI Winter.” n.d. Wikipedia. https://en.wikipedia.org/wiki/AI_winter.

Alex. 2024. “History of the AI Winter.” SlimSaaS Kit. https://slimsaas.com/blog/the-ai-winter/.

Anonymous. n.d. “DATA AUGMENTATION IN TRAINING CNNS: INJECTING NOISE TO IMAGES.” OpenReview. https://openreview.net/forum?id=SkeKtyHYPS.

“Bias-Variance Analysis: Theory and Practice.” n.d. CS229: Machine Learning. https://cs229.stanford.edu/summer2019/BiasVarianceAnalysis.pdf.

“Bias-Variance Trade Off - Machine Learning.” n.d. GeeksforGeeks. https://www.geeksforgeeks.org/machine-learning/ml-bias-variance-trade-off/.

“BIAS-VARIANCE TRADEOFF IN MACHINE LEARNING: CONCEPTS & TUTORIALS.” n.d. BMC Blogs. https://www.bmc.com/blogs/bias-variance-machine-learning/.

“Bias/Variance Tradeoff and Ensemble Methods.” n.d. The University of Texas at Dallas. https://personal.utdallas.edu/~nrr150130/cs6375/2022sp/lects/Lecture_10_Ensemble.pdf.

Bottou, Léon. 2010. “Large-Scale Machine Learning with Stochastic Gradient Descent.” https://leon.bottou.org/papers/bottou-2010.

Chapelle, Olivier, Bernhard Schölkopf, and Alexander Zien. 2006. “Semi-Supervised Learning.” MIT Press. https://direct.mit.edu/books/book/2196/Semi-Supervised-Learning.

Chawla, Avi. n.d. “A Visual and Intuitive Explanation to Momentum in Machine Learning.” https://blog.dailydoseofds.com/p/a-visual-and-intuitive-explanation.

Cimadevila, Guillermo Comesaña. n.d. “Evaluating Double Descent in Machine Learning: Insights from Tree-Based Models Applied to a Genomic Prediction Task.” arXiv Preprint. https://arxiv.org/abs/2509.25216.

Dauphin, Yann N., Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho retreats, Surya Ganguli, and Yoshua Bengio. n.d. “Identifying and Attacking the Saddle Point Problem in High-Dimensional Non-Convex Optimization.” Neural Dynamics and Computation Lab. https://arxiv.org/abs/1406.2572.

Dave, Ashutosh. 2020. “Building and Regularizing Linear Regression Models in Scikit-Learn.” QuantInsti Blog. https://blog.quantinsti.com/linear-regression-models-scikit-learn/.

Delua, Julianna. n.d. “Supervised Vs. Unsupervised Learning: What’s the Difference?” IBM. https://www.ibm.com/think/topics/supervised-vs-unsupervised-learning.

Dharanalakota, Veerababu, Ashwin Arvind Raikar, and Prasanta Kumar Ghosh. 2025. “Improving Neural Network Training Using Dynamic Learning Rate Schedule for PINNs and Image Classification.” arXiv Preprint. https://doi.org/10.1016/j.mlwa.2025.100697.

“Early Stopping.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Early_stopping.

Ghadigaonkar, Ashish. 2025. “Bias-Variance Tradeoff — Visually and Practically Explained (Part 6).” DEV Community. https://dev.to/ashish_ghadigaonkar_/bias-variance-tradeoff-visually-and-practically-explained-part-6-1466.

Glander, Dr. Shirin. n.d. “Parameters Vs Hyperparameters.” Amazon S3. https://s3.amazonaws.com/assets.datacamp.com/production/course_6650/slides/chapter1.pdf.

Goyal, Chirag. 2021. “Complete Guide to Prevent Overfitting in Neural Networks (Part-1).” Analytics Vidhya. https://www.analyticsvidhya.com/blog/2021/06/complete-guide-to-prevent-overfitting-in-neural-networks-part-1/.

“Gradient Descent.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Gradient_descent.

Groumpos, Peter P. 2023. “A Critical Historic Overview of Artificial Intelligence: Issues, Challenges, Opportunities, and Threats.” Artificial Intelligence and Applications 1 (4): 181–97. https://doi.org/10.47852/bonviewAIA3202689.

Grover, Prince. n.d. “5 Regression Loss Functions All Machine Learners Should Know.” Comet. https://www.comet.com/site/blog/5-regression-loss-functions-all-machine-learners-should-know/.

Hendrycks, Dan, and Thomas Dietterich. 2019. “Benchmarking Neural Network Robustness to Common Corruptions and Perturbations.” arXiv Preprint arXiv:1903.12261. https://arxiv.org/abs/1903.12261.

“Lasso Vs. Ridge Regression: Why Lasso Creates Sparsity and Ridge Does Not.” n.d. DEV Community. https://dev.to/aiwithabhishek/lasso-vs-ridge-regression-why-lasso-creates-sparsity-and-ridge-does-not-l83.

“Lecture 2: Optimization Algorithms in Neural Networks.” n.d. https://www.uomustansiriyah.edu.iq/media/lectures/5/5_2025_09_26!11_06_34_AM.pdf.

Lee, Fangfang. n.d. “Classification Vs Regression.” IBM. https://www.ibm.com/think/topics/classification-vs-regression.

Levi, Noam, Itay M. Bloch, Marat Freytsis, and Tomer Volansky. n.d. “Noise Injection Node Regularization for Robust Learning.” arXiv Preprint. https://arxiv.org/abs/2210.15764.

“Lighthill Report.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Lighthill_report.

“Mean Squared Error.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Mean_squared_error.

“Minsky Vs. Rosenblatt - Brain Wars.” n.d. UMass Amherst. https://websites.umass.edu/brain-wars/the-debates/minsky-vs-rosenblatt/.

Mitra, Mainak. 2023. “Unboxing Weights, Biases, Loss: Hone in on Deep Learning.” Towards AI. https://pub.towardsai.net/unboxing-weights-biases-loss-hone-in-on-deep-learning-523e659eac80.

N., Neena. 2024. “Elastic Net Regression.” University of Alberta - Edubirdie. https://edubirdie.com/university-of-alberta/cmput-396-intermediate-machine-learnin/111952-elastic-net-regression.

Rosenblatt, F. 1958. “THE PERCEPTRON: A PROBABILISTIC MODEL FOR INFORMATION STORAGE AND ORGANIZATION IN THE BRAIN.” Psychological Review 65 (6): 386–408. https://doi.org/10.1037/h0042519.

Ruder, Sebastian. 2016. “An Overview of Gradient Descent Optimization Algorithms.” arXiv Preprint. https://doi.org/10.1017/9781108699211.008.

S, Deepa, Rashmi Siddalingappa, Kalpana P, Loveline Zeema J, Vinay M, Jayapriya J, Suganthi J, and Priya Stella Mary. 2025. “A Comparative Analysis of L1, L2, and L1L2 Regularization Techniques in Neural Networks for Image Classification.” International Journal of Engineering Trends and Technology 73 (10): 107–16. https://doi.org/10.14445/22315381/IJETT-V73I10P108.

Sandru, Adrian, Mariana-Iuliana Georgescu, and Radu Tudor Ionescu. 2022. “Feature-Level Augmentation to Improve Robustness of Deep Neural Networks to Affine Transformations.” arXiv Preprint arXiv:2202.05152. https://arxiv.org/abs/2202.05152.

Shizuya, Yuki. 2024. “Understanding L1 and L2 Regularization with Analytical and Probabilistic Views.” Intuition. https://medium.com/intuition/understanding-l1-and-l2-regularization-with-analytical-and-probabilistic-views-8386285210fc.

Shlens, Jonathon. 2014. “A Tutorial on Principal Component Analysis.” arXiv Preprint arXiv:1404.1100v1. https://arxiv.org/abs/1404.1100.

Shorten, Connor, and Taghi M. Khoshgoftaar. 2019. “A Survey on Image Data Augmentation for Deep Learning.” Journal of Big Data 6 (60). https://doi.org/10.1186/s40537-019-0197-0.

Sutton, Richard S., and Andrew G. Barto. 2018. Reinforcement Learning: An Introduction. Second. MIT Press. http://incompleteideas.net/book/the-book-2nd.html.

“This Week in the History of AI at AIWS.net - the Market for Specialised AI Hardware Collapsed in 1987.” n.d. AIWS.net. https://aiws.net/aiws-history-of-ai/the-history-of-ai/this-week-in-the-history-of-ai-at-aiws-net-the-market-for-specialised-ai-hardware-collapsed-in-1987/.

“Timeline of Machine Learning.” n.d. Wikipedia. https://en.wikipedia.org/wiki/Timeline_of_machine_learning.

Trofimov, Alexander. 2020. “Introduction to Neural Networks.” Data Learning. https://datalearning.ru/study/Courses/neuralnetworks/lections/lection01.pdf.

“Understanding Weights and Biases in Neural Networks: The Core of AI Decision-Making.” n.d. Ficus Technologies. https://ficustechnologies.com/blog/understanding-weights-and-biases-in-neural-networks-the-core-of-ai-decision-making/.

“Unsupervised Machine Learning Algorithms.” 2021. CFA, FRM,; Actuarial Exams Study Notes (AnalystPrep). https://analystprep.com/study-notes/cfa-level-2/quantitative-method/study-notes-cfa-level-ii-quantitative-methods-offered-analystprep/.

“What Is Overfitting Vs. Underfitting?” n.d. IBM. https://www.ibm.com/think/topics/overfitting.

“Why Adam Optimizer Outperforms SGD? Adaptive Momentum Explained.” n.d. PatSnap Eureka. https://eureka.patsnap.com/article/why-adam-optimizer-outperforms-sgd-adaptive-momentum-explained.

Yates, Luke A. et al. n.d. “Cross Validation for Model Selection: A Primer with Examples from Ecology.” arXiv Preprint. https://l-a-yates.github.io/CVPrimer/.

You, Kaichao et al. n.d. “How Does Learning Rate Decay Help Modern Neural Networks?” arXiv Preprint. https://arxiv.org/abs/1908.01878.

Zou, Hui, and Trevor Hastie. n.d. “Regularization and Variable Selection via the Elastic Net.” https://hastie.su.domains/Papers/B67.2%20(2005)%20301-320%20Zou%20&%20Hastie.pdf.