Régularisation & Généralisation

Appliquer des méthodes de régularisation (L1, L2, Dropout) pour préserver la capacité de généralisation.

Si le sur-apprentissage est la maladie, la régularisation en est le remède. Elle impose une contrainte mathématique de “lissage” pour favoriser la généralisation en pénalisant la complexité excessive du modèle.

Pour reprendre notre analogie du moulage : si la matière est devenue trop liquide et commence à s’infiltrer dans les micro-rayures, la régularisation applique 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 sur la structure globale pertinente.

Ridge, Lasso et Coefficients

Pour garder le modèle simple, on punit les poids trop grands en ajoutant une pénalité à l’erreur globale. Deux géométries s’opposent :

• Ridge (L2) : Pénalité proportionnelle au carré des coefficients. Contrainte circulaire : réduit la magnitude de tous les coefficients de manière douce, sans jamais en éliminer aucun. Efficace pour stabiliser les variables corrélées.
• Lasso (L1) : Pénalité proportionnelle à la valeur absolue des coefficients. Contrainte en losange : force mathématiquement certains coefficients à exactement zéro — c’est une sélection automatique de variables.

Chemins de Régularisation

La pénalité L1 élimine les variables non contributives en mettant leur coefficient à exactement zéro. Les variables faibles disparaissent les premières.

La pénalité L2 réduit tous les coefficients progressivement, sans jamais en annuler aucun. Idéal pour les variables corrélées entre elles.

Combine L1 et L2 : élimine les variables de bruit (effet Lasso) tout en conservant les variables corrélées avec des coefficients stables (effet Ridge).

Intensité (λ)

mutable regType = "lasso"

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

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

  const H = 300, VW = 800;
  const pad = { t: 30, r: 160, b: 40, l: 50 };

  const vars = [
    { name: "Taille (m²)", w0: 8.0,  lt: 0.98, et: 0.99, col: "var(--sol-cyan)"    },
    { name: "Chambres",    w0: 5.0,  lt: 0.72, et: 0.85, col: "var(--sol-green)"   },
    { name: "Garage",      w0: 3.5,  lt: 0.28, et: 0.45, col: "var(--sol-yellow)"  },
    { name: "Âge",         w0: -4.0, lt: 0.48, et: 0.68, col: "var(--sol-red)"     },
    { name: "Bruit dB",    w0: 1.5,  lt: 0.12, et: 0.20, col: "var(--sol-magenta)" }
  ];

  const coef = (v, λ, type) => {
    if (type === "ridge") {
      return v.w0 / (1 + λ / 5);
    } else if (type === "lasso") {
      return v.w0 * Math.max(0, 1 - λ / (100 * v.lt));
    } else {
      return v.w0 * Math.max(0, 1 - λ / (100 * v.et)) / (1 + λ / 20);
    }
  };

  const lambdas = d3.range(0, 101);

  const xSc = d3.scaleLinear().domain([0, 100]).range([pad.l, VW - pad.r]);
  const ySc = d3.scaleLinear().domain([-5, 9]).range([H - pad.b, pad.t]);

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

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

  // X axis
  svg.append("line")
    .attr("x1", pad.l).attr("y1", H - pad.b)
    .attr("x2", VW - pad.r).attr("y2", H - pad.b)
    .attr("stroke", "var(--sol-base01)").attr("stroke-width", 1);

  // X ticks
  [0, 25, 50, 75, 100].forEach(v => {
    svg.append("text").attr("x", xSc(v)).attr("y", H - pad.b + 14)
      .attr("text-anchor", "middle").attr("fill", "var(--sol-base01)")
      .attr("font-size", "10px").text(v);
  });
  svg.append("text").attr("x", (pad.l + VW - pad.r) / 2).attr("y", H - pad.b + 28)
    .attr("text-anchor", "middle").attr("fill", "var(--sol-base01)")
    .attr("font-size", "11px").text("Intensité de la pénalité (λ)");

  // Y axis label
  svg.append("text").attr("x", pad.l - 10).attr("y", pad.t - 10)
    .attr("text-anchor", "middle").attr("fill", "var(--sol-base01)").attr("font-size", "11px")
    .text("Coefficient");

  // Coefficient paths
  const lineGen = d3.line().x(d => xSc(d.λ)).y(d => ySc(d.c));

  vars.forEach(v => {
    const pts = lambdas.map(λ => ({ λ, c: coef(v, λ, regType) }));
    svg.append("path").datum(pts)
      .attr("fill", "none").attr("stroke", v.col).attr("stroke-width", 2.5)
      .attr("stroke-linecap", "round").attr("d", lineGen);
  });

  // Current lambda vertical marker
  svg.append("line")
    .attr("x1", xSc(regLambda)).attr("y1", pad.t)
    .attr("x2", xSc(regLambda)).attr("y2", H - pad.b)
    .attr("stroke", "var(--sol-base01)").attr("stroke-width", 1.5)
    .attr("stroke-dasharray", "4 2").attr("opacity", 0.7);

  svg.append("text").attr("x", xSc(regLambda) + 4).attr("y", pad.t + 12)
    .attr("fill", "var(--sol-base01)").attr("font-size", "10px")
    .attr("font-family", "var(--font-code, monospace)").text(`λ=${regLambda}`);

  // Current coef dots + legend
  const lx = VW - pad.r + 12;
  vars.forEach((v, i) => {
    const cv = coef(v, regLambda, regType);
    svg.append("circle").attr("cx", xSc(regLambda)).attr("cy", ySc(cv)).attr("r", 4)
      .attr("fill", v.col).attr("stroke", "white").attr("stroke-width", 1.5);
    // Legend
    svg.append("line").attr("x1", lx).attr("y1", pad.t + 20 + i * 22)
      .attr("x2", lx + 18).attr("y2", pad.t + 20 + i * 22)
      .attr("stroke", v.col).attr("stroke-width", 2.5).attr("stroke-linecap", "round");
    svg.append("text").attr("x", lx + 24).attr("y", pad.t + 24 + i * 22)
      .attr("fill", "var(--sol-base01)").attr("font-size", "11px")
      .text(`${v.name} (${cv.toFixed(1)})`);
  });

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

Elastic Net et Early Stopping

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

• ElasticNet : Pour les données présentant de nombreuses variables fortement corrélées, cet hybride combine littéralement le meilleur des deux mondes — la contrainte circulaire (L2) et la contrainte en losange (L1). Il élimine les variables de bruit tout en conservant les variables corrélées avec des coefficients stables.
• Early Stopping (Arrêt prématuré) : Une régularisation purement temporelle. On observe la courbe d’apprentissage en direct et on interrompt l’entraînement au moment exact où le modèle commence à mémoriser le bruit — c’est-à-dire quand l’erreur sur les données de validation recommence à remonter.

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 réduit les coûts opérationnels et rend les décisions de l’IA explicables pour les régulateurs.

En annulant les coefficients des variables non contributives, le Lasso réalise une sélection automatique de variables et identifie les leviers métier réels. Cela a des conséquences directes :

1. Réduction des coûts opérationnels : On peut stopper la collecte et le traitement 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.