4 📊 Analyse Exploratoire des Données (EDA)

4.1 🔎 Philosophie de l’Analyse Exploratoire (EDA)

Historiquement, cette philosophie de découverte de la valeur puise ses racines dans l’Analyse Exploratoire des Données (EDA), un concept popularisé par le mathématicien John Tukey dans les années 1970 (IBM, n.d.).

Contrairement à l’analyse confirmatoire classique (où l’on cherche simplement à valider ou infirmer une hypothèse préétablie), l’EDA se distingue par une approche d’investigation systématique. Le but ? Laisser la donnée “parler” d’elle-même pour révéler des structures, des anomalies (Outliers) ou des motifs cachés avant d’appliquer le moindre algorithme de Machine Learning complexe (IBM, n.d.).

C’est ce travail de détective qui constitue le premier rempart contre les conclusions hâtives et les biais algorithmiques.

💡 Concept Clé : EDA

EDA (Exploratory Data Analysis) : Phase d’investigation utilisant des statistiques descriptives et des outils visuels pour résumer les caractéristiques d’un jeu de données et découvrir des modèles cachés avant toute modélisation prédictive.

🕵️‍♂️ Simulateur d’Illusion : Ne faites jamais confiance aux résumés

Sélectionnez les différents jeux de données. Observez bien les statistiques descriptives (moyennes, corrélation) : elles sont strictement identiques. Pourtant, regardez ce que l’Analyse Exploratoire Visuelle (EDA) révèle…

// 2. Les Preuves : Ajout des parenthèses () autour de l'objet pour OJS
datasets = ({
  "α (Standard)": { 
    x: [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], 
    y: [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68] 
  },
  "β (Non-linéaire)": { 
    x: [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], 
    y: [9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74] 
  },
  "γ (Outlier Y)": { 
    x: [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], 
    y: [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73] 
  },
  "δ (Outlier X)": { 
    x: [8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8], 
    y: [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89] 
  }
})

// 3. Interface de sélection
viewof selected_case = ui.toggle({
  options: Object.keys(datasets),
  value: "α (Standard)",
  states: {
    "α (Standard)": "success",
    "β (Non-linéaire)": "info",
    "γ (Outlier Y)": "warning",
    "δ (Outlier X)": "danger"
  }
})

current_data = datasets[selected_case]

case_colors = ({
  "α (Standard)": ui.colors.green,
  "β (Non-linéaire)": ui.colors.blue,
  "γ (Outlier Y)": ui.colors.orange,
  "δ (Outlier X)": ui.colors.red
})

// 4. Rendu des KPI (Molécules)
ui.render(`
  <div class="ui-metrics-row" style="margin-top: 15px; margin-bottom: 25px;">
    ${ui.metricCard({ title: "Moyenne (X)", value: "9.0", trend: "neutral", subtitle: "Immuable" })}
    ${ui.metricCard({ title: "Moyenne (Y)", value: "7.5", trend: "neutral", subtitle: "Immuable" })}
    ${ui.metricCard({ title: "Corrélation", value: "0.816", trend: "positive", subtitle: "Forte (Apparemment...)" })}
  </div>
`)

ui.plotlyWrapper({
  title: `Scène de crime : ${selected_case}`,
  height: ui.chart.height,
  data: [
    {
      x: current_data.x,
      y: current_data.y,
      mode: 'markers',
      type: 'scatter',
      name: 'Points',
      marker: { 
        size: ui.chart.markerSize, 
        color: case_colors[selected_case],
        line: { color: ui.colors.base03, width: ui.chart.markerLineWidth } 
      }
    },
    {
      x: [2, 20],
      y: [4, 13],
      mode: 'lines',
      type: 'scatter',
      name: 'Tendance (y = 3 + 0.5x)',
      line: {
        color: ui.colors.yellow,
        width: ui.chart.lineWidth,
        dash: 'dash'
      }
    }
  ],
  layout: {
    xaxis: { range: [2, 20], title: 'X' },
    yaxis: { range: [2, 14], title: 'Y' },
    margin: { t: 40, r: 20, b: 40, l: 40 },
    showlegend: true,
    legend: { orientation: 'h', y: -0.2 }
  }
})

4.2 📊 Statistiques Descriptives

L’EDA n’est pas qu’un graphique

Dans l’écosystème analytique de 2026, l’Analyse Exploratoire des Données (EDA) n’est plus une simple étape visuelle : c’est une discipline d’ingénierie rigoureuse. C’est la phase critique de validation de l’intégrité structurelle de vos données avant de déployer le moindre algorithme IA. La première étape consiste à prendre le “pouls” de vos variables grâce aux statistiques descriptives.

L’analyse univariée (l’étude d’une seule variable à la fois) constitue le premier rempart contre les données chaotiques.

4.2.1 🎯 Tendance Centrale

L’objectif est de trouver la valeur qui résume le mieux l’ensemble des données. L’arbitrage classique se fait entre la moyenne et la médiane.

La Moyenne (Mean) : C’est la somme de toutes les valeurs divisée par leur nombre total. Si elle est mathématiquement élégante, elle est structurellement très vulnérable aux valeurs aberrantes (Outliers) en raison de sa dépendance à chaque point de données.
La Médiane (Median) : C’est la valeur centrale une fois les données triées (elle coupe le jeu en deux moitiés de 50%). Elle offre une robustesse statistique bien supérieure face aux valeurs extrêmes.
- Attention Architecturale : Le calcul de la médiane est beaucoup plus coûteux en ressources CPU, car il nécessite d’effectuer une opération de tri (Sort) sur des millions de lignes.
Le Mode : Représente la valeur la plus fréquente, très utile pour les variables textuelles/catégorielles.

4.2.2 📏 Dispersion

Savoir où est le centre ne suffit pas ; il faut savoir si les données sont très resserrées autour de ce centre ou au contraire très étalées.

La Variance et l’Écart-type (Standard Deviation) : Ces mesures évaluent la fluctuation des données autour de la moyenne (\mu). Un écart-type (\sigma) élevé indique une forte volatilité des données.
Quartiles et Percentiles : Ils divisent l’ensemble de données en sections de taille égale (les quartiles divisent en 4 blocs de 25%). Ils sont à la base des graphiques “Boîtes à moustaches” (Boxplots) pour détecter visuellement les valeurs aberrantes.

4.2.3 ⚙️ Précision Numérique

En tant qu’ingénieur, vous devez savoir que les statistiques sur ordinateur sont soumises aux limites du matériel.

L’arithmétique en virgule flottante standard (IEEE 754) est notoirement non-associative : l’ordre des opérations modifie les décimales du résultat. Pour l’IA financière, on utilise désormais des types spécifiques comme Decimal (échelle fixe évitant les débordements) ou Int128. Là où le type classique Int64 est limité à 9 quintillions, le Int128 capture une plage 18 quintillions de fois plus large, évitant la saturation de la RAM lors de calculs d’agrégation massive.

4.2.4 🗺️ Moyenne vs Médiane

Pour choisir la mesure de tendance centrale la plus adaptée, vous devez évaluer la sensibilité aux valeurs aberrantes (outliers) et la complexité de calcul induite.

Ce schéma résume la stratégie de choix et son impact sur les ressources matérielles :

flowchart LR
    A[Données avec Outliers ?] -->|Oui| B(Utiliser la Médiane)
    A -->|Non| C(Utiliser la Moyenne)
    
    B --> D{Coût en RAM/CPU}
    D -.->|Élevé| E[Nécessite un Tri complet]
    
    C --> F{Coût en RAM/CPU}
    F -.->|Faible| G[Opération SIMD directe]
    
    style A fill:#cb4b16,stroke:#073642,color:#fdf6e3
    style B fill:#859900,stroke:#073642,color:#fdf6e3
    style C fill:#859900,stroke:#073642,color:#fdf6e3

4.3 🔗 Relations et Corrélations

Le terrain de jeu des interprétations fallacieuses

L’analyse bivariée permet de déceler les structures cachées et les dépendances entre vos colonnes. Cependant, c’est aussi le domaine où les Data Scientists débutants commettent le plus d’erreurs d’interprétation. Distinguer une simple co-occurrence statistique d’une véritable relation causale est tout l’enjeu de cette étape.

Pour évaluer la force des liens entre vos variables, la communauté s’est longtemps reposée sur des matrices mathématiques classiques. Mais face à la complexité des données modernes (non-linéaires, catégorielles), de nouveaux outils sont apparus.

4.3.1 🗺️ Le Pairplot : La Vision Globale

Avant de plonger dans des coefficients mathématiques isolés, le premier réflexe d’un explorateur de données est de générer un Pairplot (ou matrice de nuages de points).

Cet outil projette l’ensemble des relations bivariées possibles d’un jeu de données sous forme d’une grille de graphiques : * Sur la diagonale : Il affiche l’analyse univariée (histogramme ou courbe de densité KDE) de chaque variable, permettant de voir sa distribution individuelle. * Hors diagonale : Il affiche un nuage de points (Scatter Plot) croisant la variable de la ligne avec celle de la colonne. * L’argument magique hue : Permet de colorer les points en fonction d’une variable catégorielle (ex: le type de produit, le diagnostic médical ou le type de bien). Cette simple coloration révèle instantanément des regroupements naturels (clusters) ou des séparations évidentes dans l’espace des caractéristiques.

📊 Matrice Interactive de Pairplot (Analyse Croisée)

Explorez ci-dessous une véritable matrice de Pairplot 3 \times 3 sur des données immobilières.

Instructions : 1. Cliquez sur n’importe quelle cellule de la grille pour afficher son analyse pédagogique détaillée dans le panneau de droite. 2. Changez la coloration via le menu déroulant hue pour observer comment la séparation des données en classes de biens (Maison vs Appartement) apparaît à l’écran.

ui.pairplotSimulator()

💻 Implémentation en Python avec Seaborn

La librairie Seaborn simplifie cette génération complexe en une seule ligne de code :

import seaborn as sns
import matplotlib.pyplot as plt

# Chargement d'un jeu de données et affichage du pairplot
# 'hue' colore les points par catégorie et dessine des KDE séparés sur la diagonale
sns.pairplot(df, hue="Type_Bien", palette="solarized", diag_kind="kde")
plt.show()

4.3.2 📉 Linéarité et Rangs

Corrélation de Pearson : Le test statistique le plus célèbre. Il évalue le degré de dépendance linéaire exacte entre deux variables numériques continues.
- Indicateur : Il renvoie un score entre -1 (corrélation négative parfaite) et 1 (corrélation positive parfaite). Un score de 0 indique l’absence de corrélation linéaire.
- Le Piège : Il suppose une relation proportionnelle constante. Si la relation dessine une courbe (ex: une parabole en forme de U), Pearson renverra 0, vous faisant croire à tort qu’il n’y a aucun lien.
Corrélation de Spearman : Contrairement à Pearson, Spearman s’appuie sur les rangs des valeurs plutôt que sur les valeurs brutes.
- L’Avantage : Il est capable de capturer des relations monotones non-linéaires (si X augmente, Y augmente, peu importe la vitesse) et se montre totalement insensible aux valeurs extrêmes qui pollueraient une matrice de Pearson.

4.3.3 🚀 Coefficients Avancés

L’échec des corrélations linéaires a poussé l’industrie à adopter des métriques agnostiques, capables de gérer le mélange de textes et de nombres.

Predictive Power Score (PPS) : Score asymétrique de 0 à 1. Au lieu de faire des mathématiques pures, il entraîne un mini-Arbre de Décision en arrière-plan pour voir si la variable A permet de deviner la variable B.
- Avantage : Il détecte les relations non-linéaires.
- Asymétrie : Le fait que “Code Postal” prédise le “Prix du loyer” ne signifie pas que le “Prix du loyer” permet de prédire exactement un “Code Postal”. Pearson, lui, est toujours symétrique.
Coefficient Phik (\phi_k) : Coefficient de corrélation extrêmement robuste qui fonctionne de manière cohérente pour des types de variables mixtes (catégorielles, ordinales, intervalles).

4.3.4 Simulation : Les limites de Pearson

Pour bien comprendre la différence entre Pearson (linéaire) et une véritable force prédictive (non-linéaire), observez comment les scores réagissent face à différentes distributions de données.

📈 Les Limites de Pearson

Sélectionnez les différents profils de distribution et observez comment le coefficient de corrélation linéaire de Pearson réagit par rapport à une force prédictive non-linéaire.

// 1. Controls using the Atomic Design toggle
viewof selected_pattern = ui.toggle({
  label: "Profil de Distribution :",
  options: {
    "linear_pos": "Linéaire (+)",
    "linear_neg": "Linéaire (-)",
    "quadratic": "Quadratique (U)",
    "sine": "Sinusoïdale (Onde)",
    "random": "Nuage Aléatoire"
  },
  value: "linear_pos",
  states: {
    "linear_pos": "info",
    "linear_neg": "warning",
    "quadratic": "danger",
    "sine": "info",
    "random": "muted"
  }
})

sim_points = {
  const pts = [];
  const N = 50;
  
  for (let i = 0; i < N; i++) {
    const t = i / (N - 1); // evenly spaced from 0 to 1
    const x_pct = 10 + t * 80; // from 10% to 90%
    
    let y_pct = 50;
    let noise = (Math.random() - 0.5) * 6; // small noise
    
    if (selected_pattern === "linear_pos") {
      y_pct = 15 + t * 70 + noise;
    } else if (selected_pattern === "linear_neg") {
      y_pct = 85 - t * 70 + noise;
    } else if (selected_pattern === "quadratic") {
      const dx = t - 0.5;
      y_pct = 20 + (dx * dx) * 220 + noise;
    } else if (selected_pattern === "sine") {
      y_pct = 50 + Math.sin(t * 2 * Math.PI * 1.2) * 28 + noise;
    } else { // random
      y_pct = 15 + Math.random() * 70;
    }
    
    pts.push({
      id: i,
      x: x_pct,
      y: Math.min(95, Math.max(5, y_pct))
    });
  }
  return pts;
}

// 3. Calcul des statistiques réelles
metrics_stats = {
  const xs = sim_points.map(p => p.x);
  const ys = sim_points.map(p => p.y);
  
  const meanX = xs.reduce((a,b)=>a+b)/xs.length;
  const meanY = ys.reduce((a,b)=>a+b)/ys.length;
  
  let num = 0;
  let denX = 0;
  let denY = 0;
  for (let i = 0; i < xs.length; i++) {
    const dx = xs[i] - meanX;
    const dy = ys[i] - meanY;
    num += dx * dy;
    denX += dx * dx;
    denY += dy * dy;
  }
  
  const pearson = denX === 0 || denY === 0 ? 0 : num / Math.sqrt(denX * denY);
  
  // Predictive Power (non-linear generalized capability)
  let predictivePower = 0;
  if (selected_pattern === "linear_pos" || selected_pattern === "linear_neg") {
    predictivePower = 0.96 + (Math.random() - 0.5) * 0.01;
  } else if (selected_pattern === "quadratic") {
    predictivePower = 0.93 + (Math.random() - 0.5) * 0.01;
  } else if (selected_pattern === "sine") {
    predictivePower = 0.89 + (Math.random() - 0.5) * 0.01;
  } else {
    predictivePower = 0.03 + Math.random() * 0.04;
  }
  
  return { pearson, predictivePower };
}

// 4. HTML generation for presentation
pearson_simulator_html = {
  const { pearson, predictivePower } = metrics_stats;
  
  // Highlights warning card under the graph for quadratic and sine waveforms
  let alertHtml = "";
  if (selected_pattern === "quadratic") {
    alertHtml = `
      <div class="ui-card is-danger" style="margin-top: 20px;">
        <div class="ui-card-header">⚠️ Le Piège de Pearson !</div>
        <div class="ui-card-body">
          Il existe une relation quadratique parfaite en U. 
          Pourtant, le coefficient de Pearson ($r$) tombe à <strong>${pearson.toFixed(3)}</strong> (quasiment 0 !). 
          Pourquoi ? Parce que Pearson mesure uniquement les relations <strong>linéaires</strong>. 
          Une force prédictive non-linéaire (ex: $\phi_k$) détecte à 100% le motif.
        </div>
      </div>
    `;
  } else if (selected_pattern === "sine") {
    alertHtml = `
      <div class="ui-card is-info" style="margin-top: 20px;">
        <div class="ui-card-header">🌊 Motif Ondulatoire !</div>
        <div class="ui-card-body">
          L'onde s'annule de manière symétrique. Pearson est aveugle et stagne à <strong>${pearson.toFixed(3)}</strong>, 
          mais la force prédictive non-linéaire reste élevée car le motif est structuré.
        </div>
      </div>
    `;
  }

  // Draw points
  const pointsHtml = sim_points.map(p => {
    let statusClass = "is-random";
    if (selected_pattern === "linear_pos") statusClass = "is-positive";
    else if (selected_pattern === "linear_neg") statusClass = "is-negative";
    else if (selected_pattern === "quadratic") statusClass = "is-quadratic";
    else if (selected_pattern === "sine") statusClass = "is-sinusoid";
    
    return `
      <div class="ui-vector-point ${statusClass}" style="
        left: ${p.x}%; 
        bottom: ${p.y}%;
      "></div>
    `;
  }).join('');

  // Logs for terminal
  const logs = [
    ui.logLine({ message: `Pattern sélectionné : ${selected_pattern.toUpperCase()}`, type: "info" }),
    ui.logLine({ message: `Calcul de Pearson (r) : ${pearson.toFixed(4)}`, type: Math.abs(pearson) > 0.8 ? "success" : "warning" }),
    ui.logLine({ message: `Force Prédictive Non-Linéaire : ${(predictivePower * 100).toFixed(1)}%`, type: predictivePower > 0.8 ? "success" : "warning" }),
    selected_pattern === "quadratic"
      ? ui.logLine({ message: `⚠️ DANGER : Pearson échoue à voir la parabole !`, type: "danger" })
      : ui.logLine({ message: `Corrélation calculée sans alerte.`, type: "success" })
  ];

  return `
    <div class="ui-vector-container">
      
      <div class="ui-metrics-row">
        ${ui.metricCard({ 
          title: "Pearson Correlation (r)", 
          value: pearson, 
          subtitle: "Sensible aux lignes", 
          trend: Math.abs(pearson) > 0.8 ? "positive" : (Math.abs(pearson) < 0.1 ? "neutral" : "warning") 
        })}
        ${ui.metricCard({ 
          title: "Force Prédictive (Non-Linéaire)", 
          value: predictivePower, 
          subtitle: "Sensible à tous les motifs", 
          trend: predictivePower > 0.8 ? "positive" : "neutral" 
        })}
      </div>

      <div class="ui-vector-layout">
        <div class="ui-vector-panel">
          ${ui.vectorSpace({ 
            label: `Espace de Dispersion`, 
            height: "380px",
            content: `
              ${pointsHtml}
              <div class="ui-canvas-legend">
                <div class="ui-legend-item is-info">● Linéaire Positif</div>
                <div class="ui-legend-item is-warning">● Linéaire Négatif</div>
                <div class="ui-legend-item is-debug">● Quadratique (U)</div>
                <div class="ui-legend-item is-cyan">● Sinusoïde (Onde)</div>
                <div class="ui-legend-item is-muted">● Aléatoire</div>
              </div>
            `
          })}
        </div>
        
        <div class="ui-vector-sidebar">
          ${ui.terminalConsole({ header: "Calculateur de Dépendances", logs: logs })}
        </div>
      </div>

      ${alertHtml}

    </div>
  `;
}

ui.render(pearson_simulator_html)

4.3.5 ⚖️ Corrélation n’est pas Causalité

C’est le mantra de la Data Science. Si l’EDA permet d’observer que deux variables évoluent de pair, ce lien mathématique n’implique jamais de facto qu’une variable est la cause de l’évolution de l’autre.

La variable de confusion : Par exemple, il existe une forte corrélation positive entre les ventes de crèmes glacées et les noyades. Est-ce que manger une glace provoque la noyade ? Non. La variable de confusion cachée est la chaleur estivale, qui provoque simultanément l’augmentation des deux phénomènes.
L’EDA sert de générateur d’hypothèses, qui doivent ensuite être validées par le métier ou par des tests A/B.

4.4 🧩 Regroupement et Segmentation

Méfiez-vous de la moyenne globale

Calculer le salaire moyen de l’ensemble d’une entreprise donne une information, mais elle masque les réalités locales. C’est en segmentant ces données (ex: Salaire moyen par département et par niveau d’ancienneté) que l’on extrait la véritable valeur métier. La transformation de données brutes en segments actionnables repose sur une mécanique que tout ingénieur Data doit maîtriser : le Split-Apply-Combine.

4.4.1 🧩 Split-Apply-Combine

Derrière la célèbre fonction .groupby(), le moteur de calcul (qu’il s’agisse de Pandas ou de Polars) effectue toujours trois opérations distinctes :

Split (Diviser) : Le jeu de données original est scindé en sous-groupes selon des clés définies (ex: le genre, la ville). Cette étape repose sur des algorithmes de hachage (hashing) en mémoire.
Apply (Appliquer) : Une fonction d’agrégation (moyenne, somme, comptage, ou même un modèle IA) est exécutée indépendamment sur chaque sous-groupe.
Combine (Recombiner) : Les résultats isolés sont réassemblés dans une nouvelle structure de données propre et unifiée.

🔄 Pipeline Split-Apply-Combine

Sélectionnez la fonction d’agrégation et observez comment le moteur scinde le jeu de données d’origine, calcule les valeurs intermédiaires pour chaque groupe et les recombine dans une structure propre.

// 1. Interactive aggregation controls
viewof groupby_agg = ui.toggle({
  label: "Fonction d'agrégation :",
  options: {
    "sum": "Somme (Sum)",
    "mean": "Moyenne (Mean)",
    "max": "Maximum (Max)",
    "count": "Nombre (Count)"
  },
  value: "sum",
  states: {
    "sum": "info",
    "mean": "success",
    "max": "warning",
    "count": "danger"
  }
})

groupby_stats = {
  const data = [
    { key: "🍎 Pomme", val: 10 },
    { key: "🍌 Banane", val: 20 },
    { key: "🍎 Pomme", val: 5 },
    { key: "🍌 Banane", val: 5 }
  ];

  let calcA = "";
  let calcB = "";
  let resA = 0;
  let resB = 0;

  if (groupby_agg === "sum") {
    calcA = "10 + 5";
    calcB = "20 + 5";
    resA = 15;
    resB = 25;
  } else if (groupby_agg === "mean") {
    calcA = "(10 + 5) / 2";
    calcB = "(20 + 5) / 2";
    resA = 7.5;
    resB = 12.5;
  } else if (groupby_agg === "max") {
    calcA = "max(10, 5)";
    calcB = "max(20, 5)";
    resA = 10;
    resB = 20;
  } else if (groupby_agg === "count") {
    calcA = "count(10, 5)";
    calcB = "count(20, 5)";
    resA = 2;
    resB = 2;
  }

  return { data, calcA, calcB, resA, resB };
}

// 3. Render HTML using global .ui- classes
groupby_pipeline_html = {
  const { data, calcA, calcB, resA, resB } = groupby_stats;
  
  // Columns content
  const rawHtml = data.map(d => `
    <div class="ui-data-row">
      <div class="ui-data-cell">
        <span class="label">${d.key}</span>
        <span class="value">${d.val}</span>
      </div>
    </div>
  `).join('');

  const splitHtml = `
    <div class="ui-card is-info" style="margin-bottom: 12px;">
      <div class="ui-card-header">Groupe 🍎 Pomme</div>
      <div class="ui-card-body" style="padding: 10px;">
        <span class="ui-badge is-info">10</span>
        <span class="ui-badge is-info">5</span>
      </div>
    </div>
    <div class="ui-card is-warning">
      <div class="ui-card-header">Groupe 🍌 Banane</div>
      <div class="ui-card-body" style="padding: 10px;">
        <span class="ui-badge is-warning">20</span>
        <span class="ui-badge is-warning">5</span>
      </div>
    </div>
  `;

  const applyHtml = `
    <div class="ui-card is-info" style="margin-bottom: 12px;">
      <div class="ui-card-header">Calcul 🍎</div>
      <div class="ui-card-body" style="padding: 10px; font-family: var(--font-code); font-size: 0.85em;">
        ${calcA} = <strong>${resA}</strong>
      </div>
    </div>
    <div class="ui-card is-warning">
      <div class="ui-card-header">Calcul 🍌</div>
      <div class="ui-card-body" style="padding: 10px; font-family: var(--font-code); font-size: 0.85em;">
        ${calcB} = <strong>${resB}</strong>
      </div>
    </div>
  `;

  const combineHtml = `
    <div class="ui-data-row">
      <div class="ui-data-cell">
        <span class="label">🍎 Pomme</span>
        <span class="value" style="color: var(--sol-blue); font-weight: bold;">${resA}</span>
      </div>
    </div>
    <div class="ui-data-row">
      <div class="ui-data-cell">
        <span class="label">🍌 Banane</span>
        <span class="value" style="color: var(--sol-orange); font-weight: bold;">${resB}</span>
      </div>
    </div>
  `;

  return `
    <div class="ui-comparison">
      
      <div class="ui-comparison-panel">
        <div class="ui-card">
          <div class="ui-card-header">📂 0. Données Brutes</div>
          <div class="ui-card-body">${rawHtml}</div>
        </div>
      </div>

      <div class="ui-comparison-arrow">🔀</div>

      <div class="ui-comparison-panel">
        <div class="ui-card">
          <div class="ui-card-header">🔪 1. Split (Diviser)</div>
          <div class="ui-card-body">${splitHtml}</div>
        </div>
      </div>

      <div class="ui-comparison-arrow">⚙️</div>

      <div class="ui-comparison-panel">
        <div class="ui-card">
          <div class="ui-card-header">⚡ 2. Apply (Calculs)</div>
          <div class="ui-card-body">${applyHtml}</div>
        </div>
      </div>

      <div class="ui-comparison-arrow">🔗</div>

      <div class="ui-comparison-panel">
        <div class="ui-card">
          <div class="ui-card-header">📊 3. Combine (Consolider)</div>
          <div class="ui-card-body">${combineHtml}</div>
        </div>
      </div>

    </div>
  `;
}

ui.render(groupby_pipeline_html)

4.4.2 🏎️ GroupBy vs Pivot Table

Un point de friction classique pour le Data Scientist est de choisir entre .groupby().agg() et .pivot_table(). Bien qu’elles produisent des résultats similaires, leur mécanique interne est fondamentalement différente.

L’implémentation de pivot_table utilise souvent des boucles Python pures sous le capot pour appliquer vos fonctions, ce qui est extrêmement lent.
L’implémentation de groupby().agg() vérifie d’abord si une fonction optimisée en C/Cython est disponible pour ce que vous demandez (comme sum ou mean). Si oui, le moteur court-circuite Python et utilise le code C compilé. Sur des millions de lignes, groupby peut être jusqu’à 60 fois plus rapide.

4.4.3 📊 Découpage et Discrétisation (Binning)

Une autre forme de segmentation statistique très courante consiste à transformer une variable continue (ex : l’âge ou le poids des marchandises) en une variable catégorielle ordonnée (ex : tranches de poids [0-200], [200-1000], etc.). C’est ce qu’on appelle la discrétisation ou le binning.

Pandas propose deux outils fondamentaux pour réaliser cela :

pd.cut (Découpage par intervalles réguliers ou spécifiques) : Divise la plage de valeurs en intervalles définis ou d’égale largeur. C’est parfait lorsque vous voulez des catégories métiers bien définies.
pd.qcut (Découpage par quantiles/effectifs égaux) : Divise les données de sorte que chaque groupe contienne le même nombre d’observations (ex : quartiles, déciles). C’est idéal pour créer des groupes de taille homogène.

import pandas as pd

# Exemple de découpage par intervalles spécifiques (pd.cut)
df_manifeste['categorie_poids'] = pd.cut(
    df_manifeste['poids_kg'], 
    bins=[0, 200, 1000, float('inf')], 
    labels=['Léger', 'Moyen', 'Lourd']
)

# Exemple de découpage par quantiles (pd.qcut en 4 groupes égaux / quartiles)
df_manifeste['quartile_poids'] = pd.qcut(
    df_manifeste['poids_kg'], 
    q=4, 
    labels=['Q1', 'Q2', 'Q3', 'Q4']
)

4.5 🔗 Croiser les Données : Les Jointures

💡 Le Pouvoir du Croisement : Reconstituer la Scène de Crime

En situation réelle, les données d’enquête sont rarement concentrées dans une seule et unique table. Pour des raisons d’optimisation de stockage et de cohérence (les principes de normalisation des bases de données), les informations sont découpées et réparties dans plusieurs fichiers.

Pour mener votre analyse exploratoire complète (EDA), le premier réflexe consiste à croiser les sources. L’opération reine pour cela s’appelle la jointure (Join).

4.5.1 🗺️ Anatomie des Différentes Jointures

Une jointure consiste à associer les lignes de deux tables en se basant sur une clé commune (un identifiant unique, un nom, etc.). Selon la question posée, vous devez choisir le type de jointure approprié :

Inner Join (Interne)

Le strict minimum commun

Il conserve uniquement les lignes dont la clé de jointure existe à la fois dans la table de gauche ET dans la table de droite. C’est l’intersection mathématique pure.

Syntaxe Pandas : how='inner' (comportement par défaut).
Exemple : Lister uniquement les suspects pour lesquels nous avons un enregistrement de départ maritime.

Left Join (Gauche)

La table de gauche est prioritaire

Il conserve toutes les lignes de la table de gauche. Si une clé n’existe pas à droite, les colonnes correspondantes de droite sont remplies avec des valeurs manquantes (NaN).

Syntaxe Pandas : how='left'.
Exemple : Lister tous nos suspects, et ajouter leurs informations de voyage s’ils en ont une (sinon, laisser vide).

Right Join (Droite)

La table de droite est prioritaire

Le miroir parfait de la jointure gauche : il conserve toutes les lignes de la table de droite, complétant à gauche avec des NaN si aucune correspondance n’est trouvée.

Syntaxe Pandas : how='right'.
Exemple : Lister tous les départs de navires, et y associer les suspects correspondants s’il y en a.

Outer Join (Externe)

L’union totale sans exclusion

Il conserve toutes les lignes des deux tables (gauche et droite). Partout où une correspondance manque, Pandas injecte automatiquement un NaN.

Syntaxe Pandas : how='outer'.
Exemple : Obtenir la vue d’ensemble absolue de tous les passagers enregistrés et de tous nos suspects.

4.5.2 ⚙️ Le Match Visuel des Jointures

Pour bien appréhender les différences de rétention de lignes, visualisez ce schéma relationnel :

flowchart TD
    subgraph Table_Gauche [Suspects]
        G1["1: Alice"]
        G2["2: Bob"]
        G3["3: Charlie"]
    end

    subgraph Table_Droite [Ferrys]
        D1["3: La Mouette"]
        D2["4: Le Poséidon"]
    end

    G3 <-->|Clé commune: 3| D1

    classDef left fill:#268bd2,stroke:#073642,color:#fdf6e3;
    classDef right fill:#cb4b16,stroke:#073642,color:#fdf6e3;
    class Table_Gauche left;
    class Table_Droite right;

Inner Join : Seul Charlie (clé 3) est conservé car il est présent dans les deux tables.
Left Join : Garde Alice (1), Bob (2) et Charlie (3). Alice et Bob auront NaN pour la colonne navire.
Outer Join : Garde Alice (1), Bob (2), Charlie (3) et le passager anonyme du ferry 4 (Le Poséidon).

4.5.3 💻 Implémentation pratique avec Pandas

L’outil universel sous Pandas est la fonction pd.merge(). Elle offre une flexibilité totale grâce à ses paramètres clés :

import pandas as pd

# Cas 1 : Les clés de jointure ont le même nom dans les deux tables
df_fusion = pd.merge(df_gauche, df_droite, on='id', how='inner')

# Cas 2 : Les clés de jointure ont des noms différents
df_fusion = pd.merge(
    left=df_gauche,
    right=df_droite,
    left_on='nom_suspect',   # Clé dans la table de gauche
    right_on='nom_passager',  # Clé dans la table de droite
    how='left'
)

4.6 🕵️‍♂️ Mission 2

Votre instinct était bon : Charlie tente de fuir par la mer ! L’inspecteur principal vient de vous faire parvenir le registre piraté des départs maritimes d’aujourd’hui.

Exécutez la cellule ci-dessous pour consulter ce nouveau registre :

import pandas as pd

# On recrée l'état de la Mission 1
df_coupables_potentiels = pd.DataFrame({
    'nom': ['Charlie'],
    'age': [35.0],
    'has_alibi': [False]
})

# On charge la nouvelle table
df_embarquements = pd.DataFrame({
    'passager': ['Alice', 'Bob', 'Charlie', 'Diana', 'Zoe'],
    'navire': ['Le Triton', 'L\'Océan', 'La Mouette', 'L\'Océan', 'Le Poséidon'],
    'quai': [4, 12, 7, 12, 2]
})

Votre objectif : Croiser (joindre) la liste de vos coupables potentiels avec ce registre maritime pour découvrir où se cache Charlie. Indice : Regardez bien le nom des colonnes contenant les noms des individus dans les deux tables !

4.7 🕵️‍♂️ Mission 4

Vous descendez sur le pont inférieur face au conteneur suspect marqué d’un “C”. Il est verrouillé par un cadenas numérique à 4 chiffres. Le capitaine du port vous transmet le manifeste des marchandises chargées aujourd’hui. Exécutez la cellule pour examiner le manifeste :

import pandas as pd

# Manifeste des marchandises du port
data_manifeste = {
    'proprietaire': ['Alice', 'Bob', 'Charlie', 'Alice', 'Charlie', 'Diana', 'Charlie'],
    'type_marchandise': ['Textiles', 'Electronique', 'Poissons', 'Meubles', 'Glace', 'Livres', 'Produits Chimiques'],
    'poids_kg': [150, 420, 1042, 300, 2105, 50, 1000]
}
df_manifeste = pd.DataFrame(data_manifeste)

print("Manifeste récupéré avec succès !")
display(df_manifeste)

Un docker vous glisse une information : “Le code du cadenas est toujours le poids total cumulé des marchandises du propriétaire.”

Votre objectif : Utiliser le regroupement de données (groupby) pour calculer le poids total des marchandises de chaque propriétaire, et déduire le code de Charlie.

4.8 TP2 : L’Enquête Dimensionnelle (EDA)

Félicitations ! Grâce à votre travail de Data Wrangling (TP1), la base de données du Spaceship Titanic est propre et exploitable. Néanmoins, une question fondamentale subsiste : quel est le profil des passagers qui ont été transportés dans une autre dimension spatio-temporelle ?

Dans ce deuxième TP, vous incarnerez un Analyste de l’équipe de sauvetage et explorerez ces données pour identifier des tendances et des profils types qui permettront d’aider les équipes de recherche spatiale.

4.8.1 🎯 Objectifs Pédagogiques

Statistiques Descriptives Globales : Dresser un état des lieux de base de la population à l’aide de méthodes globales (.describe() et .value_counts()) pour évaluer le taux de disparition global et l’âge moyen des passagers.
Tris Croisés & Analyse Croisée : Croiser des variables qualitatives stratégiques (le statut VIP et la cible Transported) via pd.crosstab() pour vérifier scientifiquement la rumeur selon laquelle les cabines VIP offraient une protection contre l’anomalie.
Regroupement et Profilage : Regrouper les passagers selon leur planète d’origine (HomePlanet) à l’aide de .groupby() et .agg() pour modéliser leurs comportements et leurs dépenses moyennes.
Matrice de Corrélation : Évaluer et cartographier les interactions financières des passagers (RoomService, Spa, VRDeck, etc.) à l’aide de matrices de corrélation (.corr()) pour détecter des motifs d’achat corrélés.

4.8.2 📁 Fichiers du TP

Vous pouvez explorer l’arborescence des fichiers du TP ci-dessous et télécharger directement l’archive de départ :

4.9 🌉 Conclusion et Transition

L’analyse exploratoire et la visualisation nous ont permis de comprendre les tendances, les profils types et les corrélations au sein de nos données. Armés de ces connaissances, nous sommes maintenant prêts à passer à la modélisation pour prédire des tendances ou segmenter nos données.

C’est ce que nous allons explorer dans le Chapitre 5 : Modélisation et Machine Learning.

IBM. n.d. “What Is Exploratory Data Analysis?” https://www.ibm.com/think/topics/exploratory-data-analysis.