5  🤖 Modélisation et Machine Learning

// Block de stabilisation OJS pour le projet Quarto
_stabilize = true

5.1 🤖 Supervisé vs Non Supervisé

Tabulaire vs Non-Structuré : Le choc des réalités

Avant de plonger dans les algorithmes, il faut faire un point sur l’état de l’art. On entend beaucoup parler de Deep Learning (Réseaux de Neurones profonds), mais il faut savoir qu’ils excellent surtout sur des données non structurées (images, son, texte) qui possèdent une hiérarchie spatiale.

Dans le monde de l’entreprise, 90% des bases de données sont tabulaires (des colonnes hétérogènes : âge, revenu, statut). Sur ce terrain, les algorithmes classiques basés sur les arbres (Random Forest, XGBoost) dominent encore largement l’industrie face au Deep Learning (Nishida 2026).

Pour naviguer dans cet écosystème algorithmique, il faut d’abord comprendre la séparation philosophique majeure du Machine Learning : l’utilisation (ou non) d’étiquettes.

5.1.1 👨‍🏫 1. L’Apprentissage Supervisé (Avec Étiquettes)

L’apprentissage supervisé est de loin l’approche la plus utilisée en entreprise.

• Le Concept : Le modèle apprend à partir d’un jeu de données où la “réponse” (la cible à prédire) est déjà connue et fournie sous forme d’étiquette (Label).
• La Métaphore Pédagogique : Imaginez un élève travaillant sous la tutelle d’un professeur. Le professeur donne des exercices dont les solutions sont écrites au dos de la page. L’élève fait l’exercice, compare sa réponse avec la solution, et ajuste sa méthode de calcul (ses “poids synaptiques”) en fonction de son erreur pour faire mieux la prochaine fois (Kushwaha and Kudale 2026).

Cas d’usage métiers :

L’objectif est de formuler des prédictions concrètes sur de nouvelles données.

• Prognostic médical : Fournir les symptômes d’un patient à l’IA pour qu’elle prédise la malignité d’une tumeur (Classification).
• Analyse de risque financier : Évaluer la probabilité qu’un client fasse défaut sur son crédit immobilier.
• Prévision du Churn : Déterminer si un client va résilier son abonnement le mois prochain.

5.1.2 🕵️‍♂️ 2. L’Apprentissage Non Supervisé (Sans Étiquettes)

Ici, il n’y a pas de professeur, pas de corrigé, et pas de cible explicite à prédire.

• Le Concept : L’algorithme est lâché dans un jeu de données brut et on lui demande de “trouver du sens” ou de découvrir des structures latentes par lui-même.
• La Métaphore Pédagogique : C’est un explorateur (ou un détective) qui arrive dans une nouvelle ville sans carte. Il va regrouper les habitants par similarité (ceux qui s’habillent pareil, ceux qui fréquentent les mêmes lieux) en se basant sur une notion mathématique de “distance” (Karl 2024).

Cas d’usage métiers :

L’objectif est d’explorer et de structurer la donnée.

• Segmentation de clientèle (Clustering) : Regrouper des clients aux comportements d’achat similaires pour créer des campagnes marketing ultra-ciblées, révélant des profils insoupçonnés par l’équipe marketing.
• Détection d’anomalies : Identifier des transactions bancaires dont la structure diverge radicalement de la “norme” établie par les autres transactions, signalant potentiellement une fraude (Karl 2024).

5.1.3 🧠 Synthèse des deux mondes

Pour résumer la bifurcation fondamentale du Machine Learning, voici une cartographie claire distinguant le mode supervisé (guidé par des étiquettes) du mode non supervisé (guidé par la structure intrinsèque) :

flowchart TD
    A[Machine Learning] --> B(Apprentissage Supervisé)
    A --> C(Apprentissage Non Supervisé)
    
    B --> D[Données Étiquetées\nLe but : Prédire l'avenir]
    C --> E[Données Brutes\nLe but : Trouver des structures]
    
    D --> F(Classification\nEx: Chien ou Chat ?)
    D --> G(Régression\nEx: Quel prix ?)
    
    E --> H(Clustering\nEx: Groupes de clients)
    E --> I(Détection d'Anomalies\nEx: Fraude)
    
    style B fill:#268bd2,stroke:#073642,color:#fdf6e3
    style C fill:#6c71c4,stroke:#073642,color:#fdf6e3

5.2 🏷️ Régression vs Classification

💡 Concept Clé : Apprendre du Passé

Une fois les indices étiquetés, nous voulons que la machine apprenne la fonction mathématique qui relie nos entrées (ex: caractéristiques d’un suspect) à une sortie (ex: probabilité de culpabilité). Selon la nature de ce que l’on prédit, on choisit son arme : la Régression ou la Classification.

5.2.1 ⚖️ Comparaison des Approches

Régression

Prédire une Valeur L’objectif est d’estimer un nombre continu.

• Régression Linéaire : Trace la droite la plus proche des points.
• Exemple : Prédire le prix d’un appartement ou la température de demain.

Classification

Ranger dans des Boîtes L’objectif est de prédire une catégorie.

• KNN : “Dis-moi qui sont tes voisins…”.
• SVM : Maximiser la marge entre les classes.
• Exemple : Spam ou Non-Spam, Chat ou Chien.

🔬 Expérimentation : La Magie du KNN

Le paramètre K (le nombre de voisins) est le curseur de sensibilité de votre enquêteur. Manipulez K pour voir comment la frontière de décision évolue entre le bruit et la tendance lourde.

viewof k_neighbors = Inputs.range([1, 11], { value: 3, step: 2, label: "Nombre de voisins (K) :" })

// 2. Définition du simulateur (Logique métier)
knnSimulator = ({ k = 3 }) => {
  const points = [
    { x: 15, y: 20, class: "A" }, { x: 25, y: 35, class: "A" }, { x: 10, y: 60, class: "A" },
    { x: 40, y: 25, class: "A" }, { x: 30, y: 15, class: "A" }, { x: 45, y: 40, class: "A" },
    { x: 75, y: 80, class: "B" }, { x: 85, y: 60, class: "B" }, { x: 60, y: 90, class: "B" },
    { x: 90, y: 30, class: "B" }, { x: 70, y: 50, class: "B" }, { x: 55, y: 70, class: "B" }
  ];
  
  const target = { x: 50, y: 50, class: "?" };
  const calcDistance = (p1, p2) => Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
  
  const pointsWithDist = points.map(p => ({
    ...p,
    distance: calcDistance(p, target)
  })).sort((a, b) => a.distance - b.distance);

  const topK = pointsWithDist.slice(0, k);
  let votes = { A: 0, B: 0 };
  topK.forEach(p => votes[p.class]++);
  const winningClass = votes.A > votes.B ? "A" : (votes.B > votes.A ? "B" : "Égalité");

  const mapHtml = pointsWithDist.map((p, index) => {
    const isTopK = index < k;
    const color = p.class === "A" ? theme.colors.info : theme.colors.warning;
    const border = isTopK ? `2px solid var(--sol-base3)` : `2px solid transparent`;
    const shadow = isTopK ? `0 0 10px ${color}` : `none`;
    const opacity = isTopK ? `1` : `0.3`;

    return `
      <div style="position: absolute; left: ${p.x}%; bottom: ${p.y}%; width: 14px; height: 14px; background: ${color}; border-radius: 50%; transform: translate(-50%, 50%); border: ${border}; box-shadow: ${shadow}; opacity: ${opacity}; transition: all 0.3s ease; z-index: 5;">
      </div>
    `;
  }).join('');

  const targetHtml = `
    <div style="position: absolute; left: ${target.x}%; bottom: ${target.y}%; width: 22px; height: 22px; background: var(--sol-base3); border-radius: 50%; transform: translate(-50%, 50%); display: flex; align-items: center; justify-content: center; font-weight: bold; color: var(--sol-base01); font-size: 14px; z-index: 10; box-shadow: 0 0 15px rgba(var(--sol-base01-rgb), 0.2); border: 2px solid var(--sol-base01);">
      ?
    </div>
  `;

  const logs = [
    ui.logLine({ message: `Calcul de la distance de Minkowski...`, type: "info" }),
    ui.logLine({ message: `Isolement des K=${k} voisins les plus proches.`, type: "info" }),
    ui.logLine({ message: `Votes : A (${votes.A}), B (${votes.B}).`, type: "warning" }),
    ui.logLine({ message: `Prédiction finale : Classe ${winningClass}`, type: "success" })
  ];

  return `
    <div style="display: flex; flex-direction: column; gap: 20px; padding: 20px; background: rgba(var(--sol-base03-rgb), 0.03); border-radius: 8px;">
      
      <div class="ui-metrics-row">
        ${ui.metricCard({ title: "K-Voisins", value: k, trend: "neutral" })}
        ${ui.metricCard({ title: "Classe Prédite", value: winningClass, trend: winningClass === "A" ? "positive" : "warning" })}
        ${ui.metricCard({ title: "Confiance", value: `${Math.round(Math.max(votes.A, votes.B) / k * 100)}%`, trend: "positive" })}
      </div>

      <div style="display: flex; gap: 20px; flex-wrap: wrap;">
        <div style="flex: 1; min-width: 250px;">
          ${ui.vectorSpace({ 
            label: "Espace Vectoriel (KNN)", 
            content: `
              ${mapHtml} ${targetHtml}
              <div style="position: absolute; bottom: 10px; right: 10px; background: rgba(var(--sol-base3-rgb), 0.8); padding: 5px 10px; border-radius: 4px; font-size: 0.75em; border: 1px solid var(--sol-base2); z-index: 10; backdrop-filter: blur(2px);">
                <div style="color: var(--sol-blue);">● Classe A</div>
                <div style="color: var(--sol-yellow);">● Classe B</div>
              </div>
            `
          })}
        </div>
        
        <div style="flex: 1; min-width: 250px;">
          ${ui.terminalConsole({ header: "Pipeline d'inférence KNN", logs: logs })}
        </div>
      </div>

    </div>
  `;
};

ui.render(knnSimulator({ k: k_neighbors }))

⚠️ Danger : Le Surapprentissage

Un modèle trop complexe (ex: KNN avec K=1) apprendra les bruits de la scène de crime par cœur au lieu de comprendre la logique générale. C’est ce qu’on appelle l’Overfitting.

🎒 Astuce Pro : Le SVM

Pour les problèmes où les classes sont difficilement séparables, le SVM est votre meilleur allié. Il cherche à tracer l’autoroute la plus large possible entre deux groupes pour éviter toute ambiguïté.

5.3 📐 Techniques de Régularisation (Ridge et Lasso)

Brider pour mieux généraliser

Lorsqu’un modèle (comme une régression linéaire) s’entraîne sur des données contenant beaucoup de bruit ou des variables très corrélées, il a tendance à sur-ajuster (Overfitting). Il attribue des poids extrêmement élevés à certaines variables pour s’ajuster parfaitement au jeu d’entraînement.

La Régularisation consiste à ajouter une contrainte (une “pénalité”) sur la taille de ces poids dans la fonction de coût, forçant le modèle à rester simple et à privilégier la généralisation.

5.3.1 ⚖️ Ridge vs Lasso vs ElasticNet

Pour pénaliser la complexité d’un modèle linéaire, on dispose de trois grandes approches mathématiques.

1. Régression Ridge (Pénalité L2)

La régression Ridge ajoute une pénalité proportionnelle à la somme des carrés des coefficients (\lambda \sum w_i^2).

• Effet : Elle force les coefficients à se rapprocher de zéro, sans jamais les annuler complètement.
• Cas d’usage : Idéal lorsque toutes les variables explicatives ont une influence ou en présence de forte colinéarité (les variables sont corrélées entre elles) (McDonald 2026).

2. Régression Lasso (Pénalité L1)

La régression Lasso ajoute une pénalité proportionnelle à la somme des valeurs absolues des coefficients (\lambda \sum |w_i|).

• Effet : Elle a la particularité de pouvoir réduire certains coefficients à exactement zéro. Elle agit donc comme un algorithme de sélection de variables (Feature Selection) automatique en éliminant les variables inutiles.
• Cas d’usage : Idéal lorsque vous suspectez que seul un petit nombre de variables a un réel impact sur la cible (McDonald 2026).

3. ElasticNet (Pénalité Hybride)

ElasticNet combine les deux pénalités L1 et L2 avec un dosage ajustable (\alpha).

• Effet : Il bénéficie de l’effet de groupe de Ridge (les variables corrélées sont conservées ensemble) tout en effectuant de la sélection de caractéristiques comme Lasso.

🪄 Simulateur Interactif des Chemins de Régularisation

Jouez avec l’intensité de pénalisation \lambda pour constater en temps réel comment Ridge (L2) amortit doucement les coefficients sans jamais en éliminer aucun, tandis que Lasso (L1) coupe chirurgicalement à zéro (sparsity) les variables inutiles (le bruit ou la redondance).

ui.regularizationSimulator()

5.3.2 💻 Implémentation Scikit-Learn

Voici comment instancier et comparer ces modèles en Python en utilisant scikit-learn :

from sklearn.linear_model import Ridge, Lasso, ElasticNet

# L'hyperparamètre 'alpha' (équivalent à lambda) contrôle la force de la régularisation.
# Plus 'alpha' est grand, plus les coefficients sont contraints vers 0.

# 1. Régression Ridge
model_ridge = Ridge(alpha=1.0)
model_ridge.fit(X_train, y_train)

# 2. Régression Lasso
model_lasso = Lasso(alpha=0.1)
model_lasso.fit(X_train, y_train)

# 3. ElasticNet (l1_ratio contrôle le dosage entre L1 et L2)
model_elastic = ElasticNet(alpha=0.5, l1_ratio=0.5)
model_elastic.fit(X_train, y_train)

# Inspection des coefficients annulés par Lasso
coefficients_inutiles = sum(model_lasso.coef_ == 0)
print(f"Lasso a automatiquement éliminé {coefficients_inutiles} variables !")

5.4 🎯 Clustering

L’art de l’exploration à l’aveugle

Contrairement à la régression ou la classification, l’apprentissage non supervisé travaille sur des données non étiquetées. L’objectif n’est pas de prédire une réponse précise, mais d’explore les données pour y découvrir des motifs cachés ou une structure naturelle (Inconnu 2026). La grande famille de ces algorithmes est le Clustering (regroupement).

5.4.1 🎯 Le Clustering

Le but du clustering est de diviser un jeu de données en groupes (clusters) de telle sorte que les points d’un même groupe soient très similaires, et très différents des autres groupes.

Le K-Means (L’algorithme des centres de gravité)

C’est le grand classique. Il partitionne les données en un nombre “K” de groupes en minimisant la distance entre les points et le centre de leur groupe (le Centroïde) (Satish, Bowers, and Bhatt 2026).

• Le Fonctionnement : On place K points au hasard. Chaque donnée s’accroche au point le plus proche. Puis, on déplace le point au centre géométrique du groupe formé. On recommence jusqu’à ce que plus rien ne bouge.
• Les Limites : Il nécessite de définir K (le nombre de groupes) à l’avance. Surtout, il force la création de clusters de forme sphérique et est très vulnérable aux valeurs aberrantes (Karl 2024).

Le DBSCAN (L’algorithme de la foule)

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) est basé sur la densité spatiale (Karl 2024).

• L’Avantage : Pas besoin de lui donner un nombre de groupes à l’avance ! Il regroupe les points fortement concentrés et peut détecter des clusters de formes arbitraires (ex: une forme de lune ou d’anneau).
• Détection d’Anomalies : Contrairement au K-Means qui force chaque point à rejoindre un groupe, DBSCAN identifie automatiquement les données isolées comme du “bruit” (valeurs aberrantes) (Karl 2024).

Interactif : La faille du K-Means

Pour bien comprendre la différence entre ces deux algorithmes, observez comment ils réagissent face à des formes complexes (comme deux demi-lunes imbriquées). K-Means va les couper brutalement avec une ligne droite (car il cherche des sphères), tandis que DBSCAN va suivre la courbe de densité.

🧩 Comparateur de Clustering : K-Means vs DBSCAN

Observez en temps réel comment les algorithmes partitionnent les données. Notez la faille géométrique du K-Means face aux formes courbes (demi-lunes), alors que DBSCAN les épouse parfaitement grâce à l’analyse de la densité.

viewof selected_dataset = ui.toggle({
  label: "Jeu de données :", 
  options: ["Nuages (Sphères)", "Demi-Lunes"], 
  value: "Demi-Lunes",
  states: { "Nuages (Sphères)": "info", "Demi-Lunes": "success" }
})

viewof selected_algo = ui.toggle({
  label: "Algorithme :", 
  options: ["K-Means", "DBSCAN"], 
  value: "K-Means",
  states: { "K-Means": "info", "DBSCAN": "success" }
})

// 2. K-Means controls
viewof kmeans_k = Inputs.range([1, 5], { value: 3, step: 1, label: "Nombre de Clusters (K) :" })

viewof dbscan_eps = Inputs.range([3.0, 25.0], { value: 10.0, step: 0.5, label: "Rayon de Densité (Epsilon) :" })
viewof dbscan_minpts = Inputs.range([1, 10], { value: 4, step: 1, label: "Points minimum (MinPts) :" })

seeded_random = (seed) => {
  let s = seed;
  return () => {
    s = (s * 9301 + 49297) % 233280;
    return s / 233280.0;
  };
}

// Generate the stable datasets
datasets = {
  const rand = seeded_random(1337);
  
  // 1. Nuages (Sphères)
  const clouds = [];
  const centers = [
    {cx: 25, cy: 30},
    {cx: 75, cy: 30},
    {cx: 50, cy: 75}
  ];
  for (let c = 0; c < 3; c++) {
    const center = centers[c];
    for (let i = 0; i < 28; i++) {
      const r = rand() * 12;
      const theta = rand() * 2 * Math.PI;
      clouds.push({
        x: center.cx + r * Math.cos(theta),
        y: center.cy + r * Math.sin(theta),
        type: "normal"
      });
    }
  }
  for (let i = 0; i < 10; i++) {
    clouds.push({
      x: 15 + rand() * 70,
      y: 15 + rand() * 70,
      type: "noise"
    });
  }

  // 2. Demi-Lunes
  const moons = [];
  for (let i = 0; i < 40; i++) {
    const t = (i / 39) * Math.PI;
    const x = 50 + 26 * Math.cos(t) + (rand() - 0.5) * 6;
    const y = 42 + 18 * Math.sin(t) + (rand() - 0.5) * 6;
    moons.push({ x, y, type: "normal" });
  }
  for (let i = 0; i < 40; i++) {
    const t = (i / 39) * Math.PI;
    const x = 50 + 26 * Math.cos(t + Math.PI) + 13 + (rand() - 0.5) * 6;
    const y = 52 - 18 * Math.sin(t) + (rand() - 0.5) * 6;
    moons.push({ x, y, type: "normal" });
  }
  for (let i = 0; i < 12; i++) {
    moons.push({
      x: 15 + rand() * 70,
      y: 15 + rand() * 70,
      type: "noise"
    });
  }

  return { clouds, moons };
}

// K-Means actual runner
run_kmeans = (data, K) => {
  let centroids = [];
  for (let i = 0; i < K; i++) {
    const idx = Math.floor((i + 0.5) * data.length / K) % data.length;
    centroids.push({ x: data[idx].x, y: data[idx].y });
  }

  let assignments = new Array(data.length).fill(0);
  let iterations = 0;
  let changed = true;

  while (changed && iterations < 30) {
    changed = false;
    iterations++;

    for (let i = 0; i < data.length; i++) {
      const p = data[i];
      let minDist = Infinity;
      let closestCluster = 0;
      for (let c = 0; c < K; c++) {
        const d = Math.pow(p.x - centroids[c].x, 2) + Math.pow(p.y - centroids[c].y, 2);
        if (d < minDist) {
          minDist = d;
          closestCluster = c;
        }
      }
      if (assignments[i] !== closestCluster) {
        assignments[i] = closestCluster;
        changed = true;
      }
    }

    const newCentroids = [];
    const counts = new Array(K).fill(0);
    for (let c = 0; c < K; c++) {
      newCentroids.push({ x: 0, y: 0 });
    }

    for (let i = 0; i < data.length; i++) {
      const c = assignments[i];
      newCentroids[c].x += data[i].x;
      newCentroids[c].y += data[i].y;
      counts[c]++;
    }

    for (let c = 0; c < K; c++) {
      if (counts[c] > 0) {
        centroids[c] = {
          x: newCentroids[c].x / counts[c],
          y: newCentroids[c].y / counts[c]
        };
      }
    }
  }

  return { centroids, assignments };
}

// DBSCAN actual runner
run_dbscan = (data, epsilon, minPts) => {
  const n = data.length;
  const assignments = new Array(n).fill(-1);
  const visited = new Array(n).fill(false);
  let clusterId = 0;

  const getNeighbors = (idx) => {
    const neighbors = [];
    const p1 = data[idx];
    for (let i = 0; i < n; i++) {
      const p2 = data[i];
      const dist = Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
      if (dist <= epsilon) {
        neighbors.push(i);
      }
    }
    return neighbors;
  };

  for (let i = 0; i < n; i++) {
    if (visited[i]) continue;
    visited[i] = true;

    const neighbors = getNeighbors(i);
    if (neighbors.length < minPts) {
      assignments[i] = -1;
    } else {
      assignments[i] = clusterId;
      const queue = [...neighbors];
      for (let j = 0; j < queue.length; j++) {
        const neighborIdx = queue[j];
        
        if (!visited[neighborIdx]) {
          visited[neighborIdx] = true;
          const nextNeighbors = getNeighbors(neighborIdx);
          if (nextNeighbors.length >= minPts) {
            queue.push(...nextNeighbors);
          }
        }
        
        if (assignments[neighborIdx] === -1) {
          assignments[neighborIdx] = clusterId;
        }
      }
      clusterId++;
    }
  }

  return { assignments, totalClusters: clusterId };
}

active_sliders_style = html`
  <style>
    #kmeans-control {
      opacity: ${selected_algo === "K-Means" ? 1 : 0.35};
      pointer-events: ${selected_algo === "K-Means" ? "auto" : "none"};
      transition: all 0.3s ease;
    }
    #dbscan-control {
      opacity: ${selected_algo === "DBSCAN" ? 1 : 0.35};
      pointer-events: ${selected_algo === "DBSCAN" ? "auto" : "none"};
      transition: all 0.3s ease;
    }
  </style>
`

custom_styles = html`
  <style>
    .ui-vector-point.is-c0 { background: var(--sol-blue) !important; box-shadow: 0 0 6px rgba(var(--sol-blue-rgb), 0.5); }
    .ui-vector-point.is-c1 { background: var(--sol-green) !important; box-shadow: 0 0 6px rgba(var(--sol-green-rgb), 0.5); }
    .ui-vector-point.is-c2 { background: var(--sol-orange) !important; box-shadow: 0 0 6px rgba(var(--sol-orange-rgb), 0.5); }
    .ui-vector-point.is-c3 { background: var(--sol-magenta) !important; box-shadow: 0 0 6px rgba(var(--sol-magenta-rgb), 0.5); }
    .ui-vector-point.is-c4 { background: var(--sol-cyan) !important; box-shadow: 0 0 6px rgba(var(--sol-cyan-rgb), 0.5); }
    
    .ui-vector-point.is-noise { 
      background: #111111 !important; 
      border: 2px solid var(--sol-red) !important;
      box-shadow: 0 0 8px var(--sol-red) !important;
      width: 11px !important;
      height: 11px !important;
      z-index: 10 !important;
    }
    
    .ui-centroid {
      position: absolute;
      width: 24px;
      height: 24px;
      transform: translate(-50%, 50%);
      display: flex;
      align-items: center;
      justify-content: center;
      pointer-events: none;
      z-index: 15;
      animation: centroid-pulse 1.2s infinite alternate;
    }
    
    @keyframes centroid-pulse {
      from { transform: translate(-50%, 50%) scale(0.9); }
      to { transform: translate(-50%, 50%) scale(1.25); }
    }
  </style>
`

current_data = selected_dataset === "Nuages (Sphères)" ? datasets.clouds : datasets.moons

clustering_results = {
  const data = current_data;
  if (selected_algo === "K-Means") {
    const K = kmeans_k;
    const { centroids, assignments } = run_kmeans(data, K);
    const processed = data.map((d, i) => ({
      ...d,
      cluster: assignments[i],
      status: `Cluster ${assignments[i] + 1}`
    }));
    return { processed, centroids, totalClusters: K, noiseCount: 0 };
  } else {
    const eps = dbscan_eps;
    const minPts = dbscan_minpts;
    const { assignments, totalClusters } = run_dbscan(data, eps, minPts);
    let noiseCount = 0;
    const processed = data.map((d, i) => {
      const c = assignments[i];
      if (c === -1) noiseCount++;
      return {
        ...d,
        cluster: c,
        status: c === -1 ? "Bruit" : `Cluster ${c + 1}`
      };
    });
    return { processed, centroids: [], totalClusters, noiseCount };
  }
}

// 5. HTML Assembly
clustering_simulator_html = {
  const { processed, centroids, totalClusters, noiseCount } = clustering_results;
  const total = processed.length;
  
  const pointsHtml = processed.map(p => {
    let statusClass = p.cluster === -1 ? "is-noise" : `is-c${p.cluster % 5}`;
    return `
      <div class="ui-vector-point ${statusClass}" style="
        left: ${p.x}%; 
        bottom: ${p.y}%;
      " title="Point (X: ${p.x.toFixed(1)}, Y: ${p.y.toFixed(1)}) - ${p.status}">
      </div>
    `;
  }).join('');

  const centroidsHtml = centroids.map((c, idx) => {
    return `
      <div class="ui-centroid" style="left: ${c.x}%; bottom: ${c.y}%;">
        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" style="color: var(--sol-red); filter: drop-shadow(0 0 5px var(--sol-red));">
          <line x1="12" y1="4" x2="12" y2="20"></line>
          <line x1="4" y1="12" x2="20" y2="12"></line>
        </svg>
      </div>
    `;
  }).join('');

  const logs = [
    ui.logLine({ message: `Jeu de données : ${selected_dataset}`, type: "info" }),
    ui.logLine({ message: `Algorithme : ${selected_algo}`, type: "info" }),
    selected_algo === "K-Means"
      ? ui.logLine({ message: `Config : K=${kmeans_k} groupes demandés`, type: "info" })
      : ui.logLine({ message: `DBSCAN : Eps=${dbscan_eps.toFixed(1)}%, MinPts=${dbscan_minpts}`, type: "info" }),
    ui.logLine({ message: `Identifié : ${totalClusters} cluster(s) | ${noiseCount} points de bruit`, type: noiseCount > 0 ? "warning" : "success" })
  ];

  return `
    <div class="ui-vector-container">
      
      <div class="ui-metrics-row">
        ${ui.metricCard({ title: "Groupes Trouvés", value: totalClusters, trend: "neutral" })}
        ${ui.metricCard({ title: "Bruit / Exclus", value: noiseCount, trend: noiseCount > 0 ? "negative" : "neutral" })}
        ${ui.metricCard({ title: "Total Inspecté", value: total, trend: "neutral" })}
      </div>

      <div class="ui-vector-layout">
        <div class="ui-vector-panel">
          ${ui.vectorSpace({ 
            label: `Simulation de Clustering (${selected_algo})`, 
            height: "380px",
            content: `
              ${pointsHtml}
              ${centroidsHtml}
              <div class="ui-canvas-legend">
                <div class="ui-legend-item" style="color: var(--sol-blue);">● Grp 1</div>
                <div class="ui-legend-item" style="color: var(--sol-green);">● Grp 2</div>
                ${totalClusters > 2 ? '<div class="ui-legend-item" style="color: var(--sol-orange);">● Grp 3</div>' : ''}
                ${selected_algo === "DBSCAN" 
                  ? '<div class="ui-legend-item" style="color: #111111; font-weight: bold; border-bottom: 2px solid var(--sol-red); padding-bottom: 1px;">● Bruit</div>' 
                  : '<div class="ui-legend-item" style="color: var(--sol-red); font-weight: bold;">✦ Centroïde</div>'}
              </div>
            `
          })}
        </div>
        
        <div class="ui-vector-sidebar">
          ${ui.terminalConsole({ header: "Console de Clustering", logs: logs })}
        </div>
      </div>

    </div>
  `;
}

ui.render(clustering_simulator_html)

L’enquête prend une tournure critique. La découverte du vol des sujets d’examen fait monter la pression : le directeur pédagogique vient de vous appeler en urgence sur la ligne sécurisée. Les sujets volés sont ceux de la prochaine session d’IA des Master 1 ! Il faut absolument identifier à qui Charlie compte les vendre avant que la transaction n’ait lieu.

Puisque nous cherchons à découvrir des groupes cachés d’acheteurs dans une liste de suspects sans savoir à l’avance qui ils sont, c’est le moment idéal pour introduire l’Apprentissage Non Supervisé.

5.5 🕵️‍♂️ Mission 5

Le directeur pédagogique est formel : si ces sujets fuitent, toute l’évaluation des Master 1 devra être annulée. Heureusement, vous avez mis la main sur le carnet d’adresses de Charlie sur le Dark Web.

Exécutez la cellule ci-dessous pour charger la base des prospects :

import pandas as pd
from sklearn.cluster import KMeans

# Données récupérées sur le serveur de Charlie
donnees_darkweb = {
    'pseudo': ['Shadow99', 'NoobMaster', 'IA_Slayer', 'StressMax', 'RichKid', 'GhostHacker', 'BeauGosseDu69'],
    'budget_crypto': [50, 20, 2500, 100, 3000, 40, 2800],
    'niveau_stress': [2, 1, 9, 8, 10, 3, 9]
}
df_prospects = pd.DataFrame(donnees_darkweb)

print("Carnet d'adresses Dark Web décrypté.")
display(df_prospects)

Votre objectif : Demander à un algorithme de Clustering (K-Means) de regrouper ces individus en 3 catégories distinctes, afin d’isoler automatiquement le cluster des “Acheteurs VIP” (haut budget, haut stress).

5.6 🗳️ Méthodes d’Ensemble

L’intelligence collective

Pourquoi se contenter d’un seul avis quand on peut consulter un jury d’experts ? C’est la philosophie des méthodes d’ensemble : combiner plusieurs “apprenants faibles” (souvent des arbres de décision simples) pour créer un modèle “fort” et résilient (Kushwaha and Kudale 2026). Pour les données de type Excel ou SQL, ces méthodes sont aujourd’hui les championnes incontestées de la précision.

Il existe deux grandes philosophies pour faire travailler les modèles en groupe : le Bagging et le Boosting.

5.6.1 🗳️ Bagging (Random Forest)

Le Bagging (Bootstrap Aggregation) consiste à entraîner de nombreux modèles de manière indépendante et en parallèle sur des sous-ensembles aléatoires de vos données.

• La Métaphore : C’est un jury d’assises. Chaque juré étudie une partie du dossier de son côté. À la fin, on fait un vote majoritaire. Comme les erreurs de chaque juré sont aléatoires, elles tendent à s’annuler une fois agrégées (Kushwaha and Kudale 2026).
• Le champion : La Forêt Aléatoire (Random Forest). Elle crée des centaines d’arbres de décision. Pour s’assurer qu’ils ne soient pas tous identiques, elle ajoute du hasard : chaque arbre ne voit qu’une partie des colonnes et une partie des lignes.
• Force : Très robuste contre le sur-ajustement (Overfitting).

5.6.2 🚀 Boosting (XGBoost)

Le Boosting fonctionne de manière séquentielle. Les modèles ne sont pas indépendants : ils apprennent les uns des autres.

• La Métaphore : C’est un coureur de fond qui s’entraîne avec un coach. Le premier jour, il court et fait des erreurs. Le deuxième jour, il s’entraîne uniquement sur les points où il a échoué la veille. Chaque nouvel arbre est construit spécifiquement pour corriger les erreurs (les résidus) des précédents (Dalvs 2026).

• Les champions :

  • XGBoost : Le standard industriel, ultra-optimisé et régularisé.
  • LightGBM : Développé par Microsoft, il est beaucoup plus rapide sur les très gros jeux de données car il fait croître les arbres par les feuilles plutôt que par niveaux (Nishida 2026).
  • CatBoost : Le spécialiste des variables textuelles (catégorielles), capable de les gérer sans préparation manuelle complexe (Kushwaha and Kudale 2026).

Interactif : Bagging vs Boosting

Comprenez visuellement la différence de stratégie. Dans le Bagging, les modèles s’additionnent simplement. Dans le Boosting, chaque nouveau modèle vient combler les “trous” laissés par ses prédécesseurs.

🕹️ Simulateur d’Ensemble Learning : Bagging vs Boosting

Manipulez les contrôles ci-dessous pour observer comment la Forêt Aléatoire (Bagging) et l’algorithme XGBoost (Boosting) construisent leurs prédictions différemment.

viewof mode_ensemble = ui.toggle({
  label: "Algorithme :",
  options: ["Forêt Aléatoire (Bagging)", "Gradient Boosting (XGBoost)"],
  value: "Forêt Aléatoire (Bagging)",
  states: {
    "Forêt Aléatoire (Bagging)": "info",
    "Gradient Boosting (XGBoost)": "warning"
  }
})

viewof test_profile = ui.toggle({
  label: "Profil Client à tester :",
  options: ["Client Légitime (Revenus élevés)", "Client Suspect (Transactions de nuit)", "Client Atypique (Jeune entrepreneur)"],
  value: "Client Légitime (Revenus élevés)",
  states: {
    "Client Légitime (Revenus élevés)": "success",
    "Client Suspect (Transactions de nuit)": "danger",
    "Client Atypique (Jeune entrepreneur)": "info"
  }
})

viewof n_arbres = Inputs.range([1, 10], { value: 3, step: 1, label: "Nombre d'arbres (N) :" })

getBaggingPrediction = (profile, treeId) => {
  if (profile.includes("Légitime")) {
    return "✅ Légitime";
  } else if (profile.includes("Suspect")) {
    return (treeId % 2 === 0) ? "✅ Légitime" : "❌ Fraude";
  } else {
    return (treeId === 3 || treeId === 5 || treeId === 9) ? "❌ Fraude" : "✅ Légitime";
  }
}

getBoostingCorrection = (profile, treeId) => {
  if (profile.includes("Légitime")) {
    const corrections = [-0.30, -0.10, -0.05, -0.02, -0.01, 0.00, 0.00, 0.00, 0.00, 0.00];
    return corrections[treeId - 1] || 0.0;
  } else if (profile.includes("Suspect")) {
    const corrections = [+0.15, +0.08, -0.03, +0.05, -0.01, +0.02, -0.01, 0.00, 0.00, 0.00];
    return corrections[treeId - 1] || 0.0;
  } else {
    const corrections = [-0.20, +0.12, -0.08, +0.04, -0.03, +0.01, -0.01, 0.00, 0.00, 0.00];
    return corrections[treeId - 1] || 0.0;
  }
}

ensemble_dashboard_html = {
  const isBagging = mode_ensemble.includes("Bagging");
  const trees = Array.from({ length: n_arbres }, (_, i) => i + 1);

  // Bagging calculations
  const votes = trees.map(t => getBaggingPrediction(test_profile, t));
  const legitCount = votes.filter(v => v.includes("Légitime")).length;
  const fraudCount = n_arbres - legitCount;
  const consensusLegit = legitCount >= fraudCount;
  const finalBaggingResult = consensusLegit 
    ? `Légitime (Vote: ${legitCount}/${n_arbres})` 
    : `Fraude (Vote: ${fraudCount}/${n_arbres})`;

  // Boosting calculations
  const baseScore = 0.50;
  let currentSum = baseScore;
  for (let t = 1; t <= n_arbres; t++) {
    currentSum += getBoostingCorrection(test_profile, t);
  }
  const finalBoostingResult = `Risque ${(currentSum * 100).toFixed(0)}% ➡️ ${currentSum > 0.45 ? 'Refusé' : 'Accepté'}`;

  // Génération des logs personnalisés pour la console
  const logs = isBagging ? [
    ui.logLine({ message: `Profil analysé : ${test_profile.split(" (")[0]}`, type: "info" }),
    ui.logLine({ message: `Algorithme : Forêt Aléatoire (${n_arbres} arbres indépendants)`, type: "info" }),
    ...trees.map(t => {
      const pred = getBaggingPrediction(test_profile, t);
      return ui.logLine({ message: `Arbre ${t} prédit : ${pred.split(" ")[1]}`, type: pred.includes("Légitime") ? "success" : "danger" });
    }),
    ui.logLine({ message: `Consensus global : ${legitCount} Légitimes vs ${fraudCount} Fraudes`, type: "info" }),
    ui.logLine({ message: `Décision Finale : ${consensusLegit ? 'Légitime' : 'Fraude (Rejet)'}`, type: consensusLegit ? "success" : "danger" })
  ] : [
    ui.logLine({ message: `Profil analysé : ${test_profile.split(" (")[0]}`, type: "info" }),
    ui.logLine({ message: `Algorithme : XGBoost (${n_arbres} étapes séquentielles)`, type: "info" }),
    ui.logLine({ message: `Score initial de base : 0.50`, type: "info" }),
    ...trees.map(t => {
      const corr = getBoostingCorrection(test_profile, t);
      let runningSum = 0.50;
      for (let i = 1; i <= t; i++) runningSum += getBoostingCorrection(test_profile, i);
      return ui.logLine({ 
        message: `Arbre ${t} (Correction: ${corr >= 0 ? '+' : ''}${corr.toFixed(2)}) ➡️ Score cumulé: ${runningSum.toFixed(2)}`, 
        type: corr < 0 ? "success" : "warning" 
      });
    }),
    ui.logLine({ message: `Décision finale (Risque de fraude): ${(currentSum * 100).toFixed(0)}%`, type: currentSum > 0.45 ? "danger" : "success" })
  ];

  // Visualisation des nœuds d'arbres
  const colorClass = isBagging ? "is-info" : "is-warning";
  
  const treesHtml = isBagging 
    ? `
      <div style="display: flex; flex-direction: column; align-items: center; gap: 15px; width: 100%;">
        <div style="display: flex; gap: 10px; flex-wrap: wrap; justify-content: center; width: 100%;">
          ${trees.map(t => {
            const pred = getBaggingPrediction(test_profile, t);
            const isLegit = pred.includes("Légitime");
            return `
              <div class="ui-ensemble-node ${colorClass}" style="animation: scaleIn 0.3s ease-out forwards; animation-delay: ${t * 0.05}s;">
                <div class="node-icon">🌲</div>
                <div class="node-title">Arbre ${t}</div>
                <div class="node-subtitle" style="color: ${isLegit ? 'var(--sol-green)' : 'var(--sol-red)'}; font-weight: bold; margin-top: 4px; font-size: 0.8em;">
                  ${pred.split(' ')[1]}
                </div>
              </div>
            `;
          }).join('')}
        </div>
        <div style="font-size: 1.3em; color: var(--sol-base1); margin: 5px 0;">⬇️ (Agrégation par Vote Majoritaire)</div>
        <div class="ui-ensemble-consensus" style="border: 2.5px solid ${consensusLegit ? 'var(--sol-green)' : 'var(--sol-red)'}; padding: 8px 16px; border-radius: 20px; font-weight: bold; background: ${consensusLegit ? 'rgba(133, 153, 0, 0.1)' : 'rgba(220, 50, 47, 0.1)'}; color: ${consensusLegit ? 'var(--sol-green)' : 'var(--sol-red)'}; display: flex; align-items: center; gap: 8px;">
          <span>👑</span> Décision Finale : ${finalBaggingResult}
        </div>
      </div>
    `
    : `
      <div style="display: flex; flex-direction: column; align-items: center; gap: 15px; width: 100%;">
        <div style="display: flex; align-items: center; gap: 8px; flex-wrap: wrap; justify-content: center; width: 100%;">
          ${trees.map((t, idx) => {
            const corr = getBoostingCorrection(test_profile, t);
            const isPositive = corr >= 0;
            return `
              <div class="ui-ensemble-node ${colorClass}" style="animation: scaleIn 0.3s ease-out forwards; animation-delay: ${t * 0.05}s;">
                <div class="node-icon">🌲</div>
                <div class="node-title">Arbre ${t}</div>
                <div class="node-subtitle" style="color: ${corr < 0 ? 'var(--sol-green)' : 'var(--sol-red)'}; font-weight: bold; margin-top: 4px; font-size: 0.8em;">
                  ${corr >= 0 ? '+' : ''}${corr.toFixed(2)}
                </div>
              </div>
              ${idx < trees.length - 1 ? '<span style="font-size: 1.2em; color: var(--sol-yellow); font-weight: bold;">➡️</span>' : ''}
            `;
          }).join('')}
        </div>
        <div style="font-size: 1.3em; color: var(--sol-base1); margin: 5px 0;">⬇️ (Combinaison par Somme Cumulative)</div>
        <div class="ui-ensemble-consensus" style="border: 2.5px solid ${currentSum > 0.45 ? 'var(--sol-red)' : 'var(--sol-green)'}; padding: 8px 16px; border-radius: 20px; font-weight: bold; background: ${currentSum > 0.45 ? 'rgba(220, 50, 47, 0.1)' : 'rgba(133, 153, 0, 0.1)'}; color: ${currentSum > 0.45 ? 'var(--sol-red)' : 'var(--sol-green)'}; display: flex; align-items: center; gap: 8px;">
          <span>🚀</span> Décision Finale : ${finalBoostingResult}
        </div>
      </div>
    `;

  return html`
    <style>
      .ui-ensemble-node {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        background: var(--sol-base02);
        border: 2px solid var(--sol-base01);
        border-radius: 10px;
        padding: 10px 14px;
        min-width: 85px;
        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.15);
        opacity: 0;
        transform: scale(0.9);
      }
      .ui-ensemble-node.is-info {
        border-color: var(--sol-blue);
      }
      .ui-ensemble-node.is-warning {
        border-color: var(--sol-yellow);
      }
      .ui-ensemble-node .node-icon {
        font-size: 1.8em;
        margin-bottom: 4px;
      }
      .ui-ensemble-node .node-title {
        font-weight: bold;
        font-size: 0.85em;
        color: var(--sol-base0);
      }
      .ui-ensemble-node .node-subtitle {
        font-family: var(--sol-font-mono, monospace);
        font-size: 0.7em;
        margin-top: 2px;
      }

      @keyframes scaleIn {
        to { opacity: 1; transform: scale(1); }
      }
    </style>

    <div class="ui-vector-container">
      
      <div class="ui-metrics-row">
        ${ui.metricCard({ 
          title: "Type de Structure", 
          value: isBagging ? "Parallèle (Jury)" : "Séquentielle (Série)", 
          trend: "neutral" 
        })}
        ${ui.metricCard({ 
          title: "Principe Mathématique", 
          value: isBagging ? "Vote / Moyenne" : "Somme des Résidus", 
          trend: "neutral" 
        })}
        ${ui.metricCard({ 
          title: "Objectif Principal", 
          value: isBagging ? "Réduire la Variance" : "Réduire le Biais", 
          trend: "neutral" 
        })}
      </div>

      <div class="ui-vector-layout">
        <div class="ui-vector-panel" style="flex: 1.2; display: flex; align-items: center; justify-content: center; min-height: 220px; padding: 20px;">
          ${treesHtml}
        </div>
        
        <div class="ui-vector-sidebar" style="flex: 0.8;">
          ${ui.terminalConsole({ header: "Console de l'Ensemble", logs: logs })}
        </div>
      </div>

    </div>
  `;
}

ui.render(ensemble_dashboard_html)

💡 Analyse Pédagogique : Comprendre le Bagging vs le Boosting

md`
${mode_ensemble.includes("Bagging")
  ? "Le **Bagging (Bootstrap Aggregating)** est une approche démocratique. Chaque arbre est entraîné de manière totalement indépendante sur un échantillon aléatoire de vos données (le bootstrap). Certains arbres verront certains exemples, d'autres non. À la fin, la prédiction finale est un simple vote majoritaire (ou une moyenne). Cette indépendance garantit que si un arbre se trompe ou surapprend, la collectivité corrige l'erreur, réduisant drastiquement la **variance (overfitting)**."
  : "Le **Boosting** est une approche méritocratique et progressive. Les arbres ne sont pas indépendants mais construits les uns à la suite des autres en file indienne. L'Arbre 1 fait une prédiction grossière. Le modèle calcule ses erreurs (les résidus), puis entraîne l'Arbre 2 spécifiquement pour corriger les erreurs de l'Arbre 1. Ce processus itératif se répète N fois. En concentrant le calcul sur les exemples difficiles, le Boosting minimise le **biais (underfitting)** pour atteindre une précision chirurgicale."
}
`

5.6.3 🥊 Quel camp choisir ?

Caractéristique	Bagging (Random Forest)	Boosting (XGBoost/LightGBM)
Ordre	Parallèle (Indépendant)	Séquentiel (Correctif)
Objectif principal	Réduire la Variance (Overfitting)	Réduire le Biais (Précision)
Vitesse	Très rapide (Multi-thread)	Plus lent (Séquentiel par nature)
Complexité	Facile à régler	Nécessite un réglage fin (Hyperparamètres)

5.6.4 💻 Implémentation Scikit-Learn

from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier

# Initialisation du jury (Random Forest)
model_bagging = RandomForestClassifier(n_estimators=100, max_depth=5)

# Initialisation du coach (XGBoost)
model_boosting = XGBClassifier(n_estimators=100, learning_rate=0.1)

# L'entraînement est identique pour les deux
model_bagging.fit(X_train, y_train)
model_boosting.fit(X_train, y_train)

5.7 🧠 Concepts Clés

La quête de la généralisation

Le but ultime du Machine Learning n’est pas d’obtenir 100 % de précision sur vos données actuelles, mais de performer sur des données que le modèle n’a jamais rencontrées. Pour atteindre cet objectif, l’ingénieur doit naviguer entre deux écueils : le sous-ajustement et le sur-ajustement (Jiang 2026).

5.7.1 🎯 Compromis Biais-Variance

C’est l’équilibre délicat au cœur de toute modélisation. Imaginez une cible de tir à l’arc.

• Le Biais (L’Erreur de Logique) : C’est l’erreur issue d’un modèle trop simpliste qui ne comprend pas la complexité des données. L’élève applique toujours la même formule, même quand elle ne convient pas. Un biais élevé mène au Sous-ajustement.
• La Variance (La Sensibilité au Bruit) : C’est l’erreur issue d’un modèle trop complexe qui réagit à la moindre petite fluctuation des données d’entraînement. L’élève apprend par cœur les exercices mais panique dès qu’un mot change dans l’énoncé. Une variance élevée mène au Sur-ajustement (Ohiri 2026).

5.7.2 ⚠️ Sous vs Sur-ajustement

• L’Underfitting (Sous-ajustement) : Le modèle est trop simple ou “paresseux”.
  • La Métaphore : C’est comme essayer d’apprendre à faire du vélo uniquement sur un vélo d’appartement. Une fois sur le terrain, vos aptitudes seront insuffisantes car vous n’avez pas saisi la complexité de l’équilibre réel.
  • Signe : Erreur élevée à l’entraînement ET au test.
  • Solution : Augmenter la complexité du modèle ou la durée de l’entraînement.
• L’Overfitting (Sur-ajustement) : Le modèle est “trop intelligent” : il mémorise tout, y compris les erreurs et le bruit du passé.
  • La Métaphore : C’est l’élève qui mémorise toutes les réponses d’un examen blanc par cœur. S’il tombe sur le même examen, il a 20/20. Si l’examen change ne serait-ce qu’une question, il échoue car il n’a pas compris la logique, il a juste mémorisé les données.
  • Signe : Excellente performance à l’entraînement, mais catastrophe au test.
  • Solution : Simplifier le modèle, utiliser plus de données, ou appliquer de la Régularisation.

🎯 Simulateur Interactif d’Ajustement Polynomial

Visualisez ci-dessous la différence concrète entre les trois régimes d’apprentissage.

Sélectionnez la complexité du modèle pour voir comment la courbe s’adapte aux données d’entraînement (vertes) et observez l’impact direct sur les erreurs de train et de test (orange).

ui.fittingSimulator()

5.7.3 🌋 3. La Théorie du “Hot Mess” (L’Incohérence des Erreurs)

Des recherches de pointe en 2026 introduisent un concept fascinant : l’incohérence des erreurs. On a découvert que plus les modèles deviennent massifs et “intelligents”, plus leurs échecs deviennent imprévisibles. Au lieu de faire des erreurs systématiques (Biais), ils se comportent comme un “Hot Mess” (un désordre total) où la Variance domine tout (Hägele and al. 2026). Cela signifie que les futurs risques de l’IA ne seront pas forcément une “mauvaise direction” constante, mais des accidents erratiques et imprévisibles.

5.7.4 🛠️ Guide de survie du Data Scientist

Problème	Symptôme	Remède principal
Underfitting	Score faible partout	Utiliser un modèle plus puissant (ex: passer de Linéaire à XGBoost).
Overfitting	Score parfait (train) / Mauvais (test)	Réduire le nombre de variables ou utiliser des méthodes d’ensemble (Random Forest).
Hot Mess	Erreurs erratiques et imprévisibles	Augmenter la diversité des données et stabiliser l’apprentissage.

5.8 🌉 Conclusion et Transition

Nous avons exploré les principaux algorithmes de Machine Learning. Cependant, construire un modèle ne suffit pas ; il faut être capable de mesurer sa performance de manière rigoureuse pour s’assurer de sa fiabilité.

C’est l’objet du Chapitre 6 : Évaluation des Modèles.

Dalvs, Moin. 2026. “Gradient Boosting Algorithms from Scratch: 4 Boosting Algorithms You Should Know – GBM, XGBoost, LightGBM & CatBoost.” GitHub. https://github.com/MoinDalvs/Gradient_Boosting_Algorithms_From_Scratch.

Hägele, Alexander, and et al. 2026. “The Hot Mess of AI: How Does Misalignment Scale with Model Intelligence and Task Complexity?” In International Conference on Learning Representations (ICLR).

Inconnu. 2026. “5.ml.md (Modélisation Et Machine Learning).”

Jiang, et al. 2026. “OmniTabBench: A Tabular Benchmark at Unprecedented Scale.” arXiv Preprint.

Karl, Taylor. 2024. “DBSCAN Vs. K-Means: A Guide in Python.” New Horizons. https://www.newhorizons.com/resources/blog/dbscan-vs-kmeans-a-guide-in-python.

Kushwaha, Amit, and Ganesh Kudale. 2026. “A Comparative Study of Machine Learning Algorithms for Tabular Data Classification.” International Journal of Engineering Research & Technology (IJERT) 14 (02). https://www.ijert.org/a-comparative-study-of-machine-learning-algorithms-for-tabular-data-classification-ijertconv14is020007.

McDonald, Colin. 2026. “Ridge Vs. Lasso Vs. ElasticNet Regression: A Comparative Analysis of L1 and L2 Regularization.” Towards Data Science. https://towardsdatascience.com/ridge-vs-lasso-regression-a-complete-guide.

Nishida, Kan. 2026. “Why Deep Learning Didn’t Replace Tree Models for Tabular Data.” Exploratory. https://blog.exploratory.io/why-deep-learning-didnt-replace-tree-models-for-tabular-data-d80b796d652f.

Ohiri, Emmanuel. 2026. “Overfitting and Underfitting in Machine Learning: Causes, Indicators, and How to Fix Them.” CUDO Compute. https://www.cudocompute.com/blog/overfitting-and-underfitting-in-machine-learning.

Satish, Swathi Bangalore, Fatima Bowers, and Prapti Bhatt. 2026. “K-MEANS VS DBSCAN CLUSTERING ALGORITHMS.” UTK-EECS. https://web.eecs.utk.edu/~kneupan1/cs581-spring26/presentations/CS581-KMeans-vs-DBSCAN.pdf.