Entraînement & Fonction de Perte

Comprendre l’ajustement des poids et biais par la mesure et la minimisation de l’erreur globale.

Pour qu’un modèle apprenne, il ajuste deux types de paramètres en se guidant sur une mesure d’erreur. Les poids et le biais définissent ce qu’il fait ; la fonction de perte et le gradient lui indiquent comment s’améliorer.

Dans cette matière à mouler, deux types de paramètres contrôlent tout :

• Les Poids : Des “boutons de volume” qui 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 : 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 — le revenu de base du modèle.

Détail mathématique

Le calcul de base d’un neurone :

\[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

Biais (b)0

▼

Poids (w)0.2

▼

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

poidsGraph = {
  const el = document.getElementById("poids-graph");
  if (!el) return;

  const H = 260, VW = 800;
  const pad = { t: 30, r: 20, b: 30, l: 50 };

  const svg = d3.create("svg")
    .attr("width", "100%")
    .attr("height", "100%")
    .attr("viewBox", `0 0 ${VW} ${H}`);

  const defs = svg.append("defs");
  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)");
  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 xSc = d3.scaleLinear().domain([0, 100]).range([pad.l, VW - pad.r]);
  const ySc = d3.scaleLinear().domain([0, 120]).range([H - pad.b, pad.t]);
  const line = d3.line().curve(d3.curveMonotoneX).x(d => xSc(d.x)).y(d => ySc(d.y));

  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);

  const baseY = 100 - bias;
  const moldData = objectData.map(d => ({ x: d.x, y: baseY + (d.y - 100) * weight }));

  svg.append("line")
    .attr("x1", xSc(0)).attr("y1", ySc(baseY))
    .attr("x2", xSc(100)).attr("y2", ySc(baseY))
    .attr("stroke", "var(--sol-blue)").attr("stroke-width", 2)
    .attr("stroke-dasharray", "6 4").attr("opacity", 0.6);

  svg.append("line")
    .attr("x1", xSc(2)).attr("y1", ySc(100))
    .attr("x2", xSc(2)).attr("y2", ySc(baseY))
    .attr("stroke", "var(--sol-blue)").attr("stroke-width", 3)
    .attr("marker-end", "url(#arrow-bias)");

  svg.selectAll(".wv").data(moldData.filter((d, i) => i % 6 === 0 && weight > 0))
    .enter().append("line")
    .attr("x1", d => xSc(d.x)).attr("y1", ySc(baseY))
    .attr("x2", d => xSc(d.x)).attr("y2", d => ySc(d.y))
    .attr("stroke", "var(--sol-magenta)").attr("stroke-width", 2)
    .attr("opacity", 0.7).attr("marker-end", "url(#arrow-weight)");

  svg.append("path").datum(moldData)
    .attr("fill", "none").attr("stroke", "var(--sol-yellow)")
    .attr("stroke-width", 4).attr("stroke-linecap", "round").attr("stroke-linejoin", "round")
    .attr("d", line);

  // Légende
  const lx = VW - pad.r - 120;
  [
    { col: "var(--sol-base01)", dash: "3 3", w: 2, label: "Données", y: pad.t },
    { col: "var(--sol-blue)",   dash: "6 4", w: 2, label: "Biais (b)",  y: pad.t + 18 },
    { col: "var(--sol-yellow)", dash: null,  w: 4, label: "Modèle",  y: pad.t + 36 }
  ].forEach(({ col, dash, w, label, y }) => {
    const l = svg.append("line").attr("x1", lx).attr("y1", y + 5).attr("x2", lx + 22).attr("y2", y + 5)
      .attr("stroke", col).attr("stroke-width", w);
    if (dash) l.attr("stroke-dasharray", dash);
    svg.append("text").attr("x", lx + 28).attr("y", y + 9)
      .attr("fill", "var(--sol-base01)").attr("font-size", "11px").text(label);
  });

  el.replaceChildren(svg.node());
  return svg.node();
}

La fonction de perte mesure l’erreur globale — combien notre moule est imparfait. Le gradient est une boussole qui indique dans quelle direction modifier les paramètres pour réduire cette erreur.

• La Fonction de Perte : 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.
• Le Gradient : Une fois l’erreur mesurée, comment savoir dans quel sens corriger ? Le gradient indique la direction et la force avec laquelle ajuster chaque paramètre.

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. Si vous êtes perdu dans un paysage montagneux et voulez atteindre la vallée, le gradient vous dit quelle pente descendre à chaque pas.

\[\frac{\partial \mathcal{L}}{\partial w}\]

Perte et Gradient

Époques0

▼

perteGraph = {
  const el = document.getElementById("perte-graph");
  if (!el) return;

  const H = 340, VW = 800;
  const pad = { t: 20, r: 20, b: 20, l: 50 };

  const svg = d3.create("svg")
    .attr("width", "100%")
    .attr("height", "100%")
    .attr("viewBox", `0 0 ${VW} ${H}`);

  const defs = svg.append("defs");
  defs.append("marker")
    .attr("id", "arrow-grad").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)");

  const xSc  = d3.scaleLinear().domain([0, 100]).range([pad.l, VW - pad.r]);
  const ySc  = d3.scaleLinear().domain([0, 100]).range([200, pad.t]);
  const xLS  = d3.scaleLinear().domain([0, 100]).range([pad.l, VW - pad.r]);
  const yLS  = d3.scaleLinear().domain([0, 1500]).range([325, 235]);
  const line = d3.line().curve(d3.curveMonotoneX).x(d => xSc(d.x)).y(d => ySc(d.moldY));

  const startY = 95;
  let sqErr = 0;
  const sim = objectData.map(d => {
    const mY = startY + (d.y - startY) * (epochG / 100);
    const err = d.y - mY;
    sqErr += err * err;
    return { x: d.x, moldY: mY, targetY: d.y, error: err };
  });
  const mse = sqErr / sim.length;

  svg.append("path").datum(sim)
    .attr("fill", "var(--sol-red)").attr("opacity", 0.12)
    .attr("d", d3.area().curve(d3.curveMonotoneX)
      .x(d => xSc(d.x)).y0(d => ySc(d.moldY)).y1(d => ySc(d.targetY)));

  svg.append("path").datum(objectData)
    .attr("fill", "none").attr("stroke", "var(--sol-base01)")
    .attr("stroke-width", 2).attr("stroke-dasharray", "4 4")
    .attr("d", d3.line().curve(d3.curveMonotoneX).x(d => xSc(d.x)).y(d => ySc(d.y)));

  svg.selectAll(".ga").data(sim.filter((d, i) => i % 4 === 0 && Math.abs(d.error) > 1))
    .enter().append("line")
    .attr("x1", d => xSc(d.x)).attr("y1", d => ySc(d.moldY))
    .attr("x2", d => xSc(d.x)).attr("y2", d => ySc(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-grad)");

  svg.append("path").datum(sim)
    .attr("fill", "none").attr("stroke", "var(--sol-yellow)")
    .attr("stroke-width", 4).attr("d", line);

  svg.append("text")
    .attr("x", VW - pad.r).attr("y", pad.t + 14).attr("text-anchor", "end")
    .attr("fill", mse > 100 ? "var(--sol-red)" : "var(--sol-green)")
    .attr("font-size", "12px").attr("font-family", "var(--font-code, monospace)")
    .text(`J = ${mse.toFixed(1)}`);

  svg.append("line")
    .attr("x1", pad.l).attr("y1", 218).attr("x2", VW - pad.r).attr("y2", 218)
    .attr("stroke", "var(--sol-base02)").attr("stroke-width", 1).attr("stroke-dasharray", "2 2");

  svg.append("text").attr("x", pad.l).attr("y", 230)
    .attr("fill", "var(--sol-base00)").attr("font-family", "var(--font-code, monospace)")
    .attr("font-size", "10px").text("HISTORIQUE DE LA PERTE : J(w,b)");

  svg.append("line")
    .attr("x1", pad.l).attr("y1", yLS(0)).attr("x2", VW - pad.r).attr("y2", yLS(0))
    .attr("stroke", "var(--sol-base02)").attr("stroke-width", 1);

  const hist = d3.range(0, epochG + 1).map(e => {
    let sq = 0;
    objectData.forEach(d => { const mY = startY + (d.y - startY) * (e / 100); sq += (d.y - mY) ** 2; });
    return { epoch: e, v: sq / objectData.length };
  });

  svg.append("path").datum(hist)
    .attr("fill", "none").attr("stroke", "var(--sol-red)").attr("stroke-width", 2)
    .attr("d", d3.line().x(d => xLS(d.epoch)).y(d => yLS(d.v)));

  if (hist.length > 0) {
    const cur = hist[hist.length - 1];
    svg.append("circle").attr("cx", xLS(cur.epoch)).attr("cy", yLS(cur.v)).attr("r", 4).attr("fill", "var(--sol-red)");
  }

  el.replaceChildren(svg.node());
  return svg.node();
}