2  🧹 Data Wrangling (Nettoyage et Préparation)

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

2.1 🔍 Valeurs Manquantes

💡 Concept Clé : Le Mythe du Dataset Parfait

Dans l’investigation numérique, le Data Wrangling est le socle de l’intégrité du verdict. Le premier défi est la donnée manquante (NaN). Avant de “boucher un trou”, l’enquêteur doit se demander : “Pourquoi cet indice a-t-il été effacé ?”

2.1.1 🕳️ La Typologie du Vide : L’Absence comme Information

Avant de chercher à combler ou supprimer les données manquantes, le premier réflexe de l’enquêteur doit être de comprendre ce que ce “vide” cherche à lui dire.

🕵️‍♂️ Concept Clé : L’Absence est une Preuve

En Data Science, l’absence de donnée est en soi une donnée. Elle porte en elle une information cruciale. Exemples :

• Dans une table de clients, l’absence de Date_De_Depart n’est pas un oubli : cela signifie simplement que le client est toujours actif !
• Dans un questionnaire, l’absence de réponse pour la variable Salaire trahit souvent un refus volontaire de répondre lié à des revenus très élevés ou très bas (biais de désirabilité sociale).
• En médecine, l’absence de diagnostic de maladie pulmonaire dans un dossier suggère par défaut que le patient est en bonne santé.

Comme le disait Sherlock Holmes dans l’enquête de Silver Blaze, la clé du mystère résidait dans le fait que le chien n’aboyait pas pendant la nuit : l’absence de signal était le signal le plus bruyant.

💻 Les Représentations en Mémoire

Pour manipuler le vide en Python et Pandas, vous rencontrerez plusieurs visages techniques de l’absence, chacun ayant ses propres spécificités physiques en RAM :

1. None (L’Objet Python) :
   • Signification : Le type vide standard de Python (NoneType).
   • Mémoire : C’est un pointeur vers un objet générique en RAM.
   • Danger : Si vous insérez None dans une colonne de nombres en Pandas, toute la colonne perd son type numérique rapide (int/float) et est convertie en type object. Cela détruit instantanément la vectorisation et ralentit vos calculs par 100 !
2. NaN (Not a Number - IEEE 754) :
   • Signification : La norme standard des flottants pour représenter une valeur indéterminée.
   • Mémoire : Physiquement, NaN est un float (float64).
   • ⚠️ Le Piège Historique : Comme NaN est un flottant, Pandas (dans ses anciennes versions ou sans typage explicite) convertit automatiquement toute colonne d’entiers contenant une valeur manquante en colonne de floats. Votre identifiant client 42 devient soudainement 42.0 !
3. NaT (Not a Time) :
   • Signification : Le cousin de NaN dédié exclusivement aux dates et heures.
   • Mémoire : Permet de conserver le type temporel optimisé de la colonne tout en marquant les dates absentes.
4. <NA> (L’Absence Native Moderne - Arrow/Pandas Extension) :
   • Signification : Le type vide moderne introduit pour résoudre les limites historiques de NaN.
   • Mémoire : Utilise un Bitmask (masque de bits). La colonne conserve son type primitif exact (ex: entiers Int64 ou booléens boolean), tandis qu’un tableau de bits invisible en RAM (un masque de 0 et de 1) indique si la valeur de chaque ligne est présente ou manquante. C’est l’approche la plus propre et performante !

🕵️‍♂️ Attention : Le Danger des Vides Masqués (Valeurs Arbitraires)

Les types NaN et <NA> sont faciles à repérer car ils déclenchent les fonctions standard comme df.isna(). Cependant, le véritable cauchemar du Data Scientist réside dans les valeurs manquantes arbitraires ou masquées, qui passent sous le radar des outils de détection automatiques :

1. Les Chiffres Sentinelles (0, -1, -999) :
   • Le Danger : Les vieux systèmes informatiques ou certains capteurs physiques écrivent souvent -999, -1 ou 0 pour signifier “mesure impossible”.
   • Pourquoi c’est difficile : Ce sont des nombres tout à fait valides pour la machine ! Si vous calculez la moyenne d’une variable comme le Salaire ou l’Age sans nettoyer ces -999, vos statistiques seront totalement aberrantes, sans que Python ne lève la moindre erreur.
2. Les Chaînes Vides ("" ou " ") :
   • Le Danger : Un utilisateur laisse un champ vide dans un formulaire web, ce qui crée une chaîne de caractères de longueur zéro.
   • Pourquoi c’est difficile : Pour Pandas, une chaîne vide ou composée d’espaces reste du texte valide (string). Elle n’est pas détectée comme un NaN !
3. Les Chaînes de Texte Trompeuses ("null", "NULL", "None", "N/A", "nan", "?") :
   • Le Danger : Lors d’une exportation précédente d’une base de données, les valeurs manquantes ont été écrites en texte brut dans le fichier d’échange.
   • Pourquoi c’est difficile : Pandas interprète ces valeurs comme du vrai texte. "N/A" n’est pas reconnu comme du vide, c’est traité comme une chaîne valide de 3 caractères !

💡 L’Astuce de l’Enquêteur : Pensez à utiliser le paramètre na_values=['', ' ', '-999', 'null', 'NULL', '?'] dès la lecture de votre fichier avec pd.read_csv() pour forcer Pandas à traduire ces intrus en véritables NaN exploitables de manière préventive !

2.1.2 🕵️‍♂️ Mécanismes de l’Absence

La stratégie de traitement dépend de la nature statistique de l’absence :

MCAR
Missing Completely At Random
(Complètement au Hasard)

Aléatoire Pur L’absence est le fruit d’un pur hasard physique, indépendant de toutes les autres variables et de la valeur elle-même.

• Exemple : Une goutte de café sur un formulaire papier rend l’âge d’un suspect illisible.

MAR
Missing At Random
(Aléatoire Conditionnel)

Aléatoire Conditionnel L’absence dépend d’une autre variable connue et observée dans le jeu de données, mais pas de la valeur manquante elle-même.

• Exemple : Un capteur omet d’enregistrer le rythme cardiaque uniquement lorsque la variable Activité vaut Sommeil.

MNAR
Missing Not At Random
(Non Aléatoire)

Non Aléatoire L’absence dépend directement de la valeur manquante elle-même. C’est le cas le plus complexe et critique.

• Exemple : Les suspects aux revenus très élevés refusent systématiquement de déclarer leur salaire. L’absence est un indice majeur en soi.

2.1.3 🛠️ Stratégies de Traitement

Suppression (Naïve)

# ❌ Suppression des lignes avec au moins un NaN
df_clean = df.dropna()

# ❌ Suppression d'une colonne trop vide
df_clean = df.drop(columns=['Variable_Inutile'])

Verdict : À n’utiliser que si le manque est MCAR et représente moins de 5% du total. Risque majeur de perte d’information.

Imputation (Statistique)

# ✅ Remplissage par la Médiane (Robuste aux outliers)
df['Salaire'] = df['Salaire'].fillna(df['Salaire'].median())

# ✅ Remplissage par le Mode (Pour le qualitatif)
df['Ville'] = df['Ville'].fillna(df['Ville'].mode()[0])

Verdict : Préserve la taille du dataset, mais réduit la variance globale.

Imputation (Prédictive / MICE)

from sklearn.impute import IterativeImputer

# 🚀 Utilise l'IA pour "deviner" les valeurs manquantes
imputer = IterativeImputer(max_iter=10, random_state=42)
df_impute = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)

Verdict : La méthode la plus rigoureuse. Utilise les corrélations entre variables pour estimer l’absence.

⚠️ Danger : Ignorer le MNAR (Missing Not At Random)

MNAR (Non-Aléatoire) : L’absence d’une donnée est directement corrélée à la valeur de la donnée manquante elle-même.

• Exemple industriel : Un capteur thermique industriel surchauffe et plante dès que la température dépasse 150^\circ\text{C}. Toutes les mesures de surchauffe sont donc manquantes.
• Le Risque : Si vous imputez naïvement ces trous par la température moyenne (70^\circ\text{C}), vous dissimulez complètement les alertes de sécurité. Votre modèle d’IA conclura faussement que la machine est parfaitement stable alors qu’elle est en train de fondre !

🛠️ L’Arme Secrète en Pratique : La Colonne Indicateur Binaire

Pour préserver l’information cruciale portée par un manque MNAR tout en permettant à vos algorithmes de s’entraîner sans planter, la meilleure pratique industrielle est de créer une colonne binaire d’indicateur d’absence (ex: Salaire_Est_Manquant ou Temp_Est_Manquante) :

1. Création du Flag : Vous ajoutez une nouvelle colonne booléenne (0 si la donnée originale est présente, 1 si elle est absente).
2. Imputation Sécurisée : Vous “bouchez” ensuite la colonne originale avec une imputation standard (comme la médiane) pour éliminer les valeurs nulles.

Pourquoi c’est une idée de génie en Machine Learning ?

• Préservation du Signal : Les modèles de Machine Learning modernes (comme les Forêts Aléatoires ou XGBoost) excellent pour détecter les interactions. En voyant le flag à 1, le modèle comprend instantanément : “Attention, cette valeur de température à 70^\circ\text{C} est artificielle, il s’agit en réalité d’une surchauffe masquée !”.
• Ajustement des Poids : L’algorithme peut apprendre des règles de décision spécifiques aux cas d’absence (ex: “Si Temp_Est_Manquante == 1, alors probabilité de panne = 99%”). Sans ce flag binaire, l’information MNAR est perdue à jamais, noyée dans l’imputation !

🎒 Astuce Pro : Séries Temporelles

Pour les flux chronologiques (Bourse, IoT), utilisez la méthode LOCF (Last Observation Carried Forward) : df.fillna(method='ffill').

2.2 🕵️‍♂️ Mission 1

L’inspecteur principal vous a transmis un dossier contenant les données de toutes les personnes présentes sur les lieux. Voici comment la base a été constituée :

import pandas as pd
import numpy as np

data = {
    'nom': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'age': [25, np.nan, 35, 42, np.nan],
    'has_alibi': [True, False, False, True, False]
}
df_suspects = pd.DataFrame(data)

Cependant, la base est bruitée. Votre premier objectif : nettoyer les valeurs manquantes et filtrer les suspects qui ont un alibi (colonne has_alibi).

Complétez le code ci-dessous pour démasquer les coupables potentiels.

2.3 🧹 Harmonisation & Correction

L’enfer des données saisies manuellement

L’hétérogénéité des formats est un obstacle majeur au traitement algorithmique automatisé. Un algorithme de Machine Learning est d’une bêtise absolue concernant la sémantique : pour lui, “Homme”, “homme” et “H” (avec un espace à la fin) sont trois catégories totalement distinctes. L’uniformité est la règle d’or pour éviter la dilution de la puissance statistique de votre modèle.

L’harmonisation est une étape de nettoyage stricte visant à unifier le “grain” de la donnée. Elle repose sur deux piliers principaux : le traitement du texte libre et la standardisation temporelle.

2.3.1 🔤 Nettoyage Typographique

Les données issues de formulaires ou de saisies manuelles sont systématiquement polluées par des erreurs typographiques. Les corriger nécessite une approche industrielle.

Les Règles d’Or de la Typographie :

1. La Casse Unifiée : Tout convertir en minuscules (ou majuscules) pour regrouper les variations d’une même entité.
2. Le Trim (Élagage) : Supprimer les espaces invisibles en début et fin de chaîne.
3. Le Remplacement (Regex) : Utiliser les expressions régulières pour supprimer les caractères spéciaux indésirables ou extraire des motifs précis.

import pandas as pd

# ❌ Avant : ['  Homme', 'homme', 'H', 'Femme ', 'nb', 'non communiqué']
df['Genre'] = df['Genre'].str.lower()       # Étape 1 : Tout en minuscules -> ['  homme', 'homme', 'h', 'femme ', 'nb', 'non communiqué']
df['Genre'] = df['Genre'].str.strip()       # Étape 2 : Enlever les espaces -> ['homme', 'homme', 'h', 'femme', 'nb', 'non communiqué']
df['Genre'] = df['Genre'].replace({
    'h': 'homme', 
    'f': 'femme', 
    'nb': 'non-binaire', 
    'na': 'non-communique'
}) # Étape 3 : Mapping inclusif et standardisé
# ✅ Après : ['homme', 'homme', 'homme', 'femme', 'non-binaire', 'non-communique']

2.3.2 ⏱️ Standardisation Temporelle

Des dates saisies sous des formats multiples (12/04/2026, 2026-04-12, 12 April 26) empêchent toute agrégation cohérente et ruinent les modèles de séries temporelles.

Le Standard Industriel : ISO 8601

L’imposition du format standard international AAAA-MM-JJ (Année-Mois-Jour) garantit une manipulation sans erreur par toutes les bibliothèques logicielles (Python, SQL, Spark).

De plus, il est souvent critique d’extraire des Features (Caractéristiques) Temporelles à partir d’une date (comme le jour de la semaine ou le mois) car l’algorithme ne “comprend” pas une date brute.

# Convertir une colonne hétérogène en un objet Datetime standardisé
df['Date_Achat'] = pd.to_datetime(df['Date_Achat'], format='mixed')

# Extraction d'informations temporelles (Feature Engineering de base)
df['Annee'] = df['Date_Achat'].dt.year
df['Mois'] = df['Date_Achat'].dt.month
df['Est_Weekend'] = df['Date_Achat'].dt.dayofweek > 4 # Retourne un booléen

2.3.3 🕰️ Les Pièges des UNIX Timestamps & L’Éternel Janvier 1970

En informatique et en Data Engineering, le temps est mesuré à partir de l’Epoch UNIX : le 1er Janvier 1970 à 00:00:00 UTC. Le temps écoulé est alors stocké sous forme d’un nombre entier représentant les secondes (ou millisecondes) passées depuis cet instant originel.

Lors de la manipulation de ces UNIX Timestamps, trois pièges redoutables attendent les développeurs non avertis :

1. L’Erreur d’Unité : Secondes vs Millisecondes

C’est le bug le plus fréquent.

• Les systèmes UNIX traditionnels (et Python) comptent le temps en secondes (nombre à 10 chiffres, ex: 1716032400 \rightarrow 18 Mai 2024).
• Les bases de données modernes et JavaScript comptent le temps en millisecondes (nombre à 13 chiffres, ex: 1716032400000).

Le Symptôme :

• Si vous essayez de lire des millisecondes comme si c’étaient des secondes dans Pandas sans spécifier l’unité, la date sera projetée dans un futur lointain (au-delà de l’an 50 000 !).
• Si vous lisez des secondes comme des millisecondes, le nombre est divisé virtuellement par 1000. Par conséquent, Pandas calculera une date extrêmement proche du 1er Janvier 1970 (ex: 1970-01-20). Si vous observez une avalanche d’événements datant de janvier 1970 dans votre jeu de données, cherchez une erreur de division par 1000 !

# ❌ ERREUR : Pandas suppose par défaut des nanosecondes ou des secondes
df['Date_Brute'] = pd.to_datetime(df['Timestamp_Java']) 
# -> Retourne l'an 56000+ !

# ✅ RECTIFICATION : Préciser explicitement l'unité de mesure en RAM
df['Date_Propre'] = pd.to_datetime(df['Timestamp_Java'], unit='ms')
# -> Retourne la bonne date contemporaine !

2. Le Piège des Valeurs Nulles / 0

Si une transaction n’a pas de date valide et que le système remplit par défaut ce champ avec la valeur entière 0 ou null mal interprété, toute conversion temporelle naïve va traduire cette valeur par 1970-01-01 00:00:00. Un bon analyste doit immédiatement suspecter toute date correspondant exactement au premier jour de l’an 1970 comme étant une valeur manquante déguisée !

3. Les Fuseaux Horaires (Timezones)

Une date sans fuseau horaire associé est appelée date naive (ex: 2026-05-18 13:44:00). C’est une bombe à retardement. Si un serveur de collecte est basé à Paris (UTC+2) et que votre pipeline de calcul tourne sur un conteneur cloud configuré en UTC, vous aurez un décalage systématique de 2 heures. Certaines transactions nocturnes changeront ainsi carrément de jour !

💡 La Règle d’Or : Stockez et traitez toujours vos timestamps en UTC (Timezone-Aware). Convertissez-les en heure locale (ex: Europe/Paris) uniquement au moment de l’affichage final pour l’utilisateur.

# Standardiser en UTC
df['Date_UTC'] = pd.to_datetime(df['Date_Achat'], utc=True)

# Convertir au fuseau horaire local de l'enquête
df['Date_Paris'] = df['Date_UTC'].dt.tz_convert('Europe/Paris')

🛡️ Concept Clé : Qu’est-ce que le Domaine de Définition ?

La dernière barrière de sécurité avant d’envoyer vos données dans un modèle d’IA est la Validation de Domaine. Pour comprendre son importance, vous devez savoir distinguer quatre dimensions fondamentales souvent confondues par les débutants :

ui.domainValidationInspector()

⚠️ Pourquoi le Type et l’Unité ne Suffisent Pas ?

Imaginez que vous analysiez les dossiers médicaux d’une clinique. Vous rencontrez une ligne avec un âge égal à -45 ou 250 :

• La Nature est respectée (c’est bien un nombre).
• Le Type est respecté (c’est bien un entier int en RAM).
• L’Unité est respectée (ce sont bien des années).
• Le Domaine est violé ! Un âge de -45 ou de 250 ans est physiquement et biologiquement impossible pour un être humain vivant.

Sans validation de domaine, ces intrus passeraient inaperçus, s’infiltreraient dans vos modèles de Machine Learning et fausseraient dramatiquement toutes vos prédictions (ex: accorder un prêt bancaire à un bébé fictif de -45 ans !).

2.4 📈 Transformation et Normalisation

Le problème des échelles disparates

Imaginez que vous prédisiez le prix d’une maison avec deux variables : le Nombre de chambres (entre 1 et 5) et le Prix du terrain (entre 10 000 et 1 000 000 €). Pour un algorithme mathématique (comme un réseau de neurones), la variable avec les plus grands nombres va “écraser” l’autre lors du calcul des gradients, la rendant virtuellement invisible. La transformation numérique ramène tout le monde sur un pied d’égalité.

Il existe deux grandes approches pour résoudre ce problème, avec des formules et des cas d’usage très différents.

2.4.1 📏 Normalisation (Min-Max)

La normalisation compresse (ou étire) les données pour qu’elles s’insèrent exactement dans une plage définie, généralement entre 0 et 1.

La mathématique (Formule LaTeX) : X_{norm} = \frac{X - X_{min}}{X_{max} - X_{min}}

• Avantage : Maintient toutes les données dans des limites strictes.
• Le Piège : Comme elle utilise le X_{min} et le X_{max}, elle est extrêmement vulnérable aux valeurs aberrantes (Outliers). Si une seule maison coûte 1 milliard d’euros (une erreur de saisie), toutes les autres maisons seront écrasées autour de 0.001.

2.4.2 🎯 Standardisation (Z-Score)

La standardisation ne fixe pas de limites strictes. Elle décale les données pour que la distribution soit centrée sur une moyenne (\mu) de 0, avec un écart-type (\sigma) de 1.

La mathématique : Z = \frac{X - \mu}{\sigma}

• Avantage : Elle gère globalement mieux les variations naturelles et ne fige pas les données. Elle est indispensable lorsque les données sont collectées sous des conditions variables (ex: variations d’éclairage pour des images).
• Alternative pour les extrêmes : S’il y a trop de valeurs aberrantes, on utilise le Robust Scaler. Au lieu de la moyenne, il centre sur la médiane et divise par l’écart interquartile (IQR).

📊 Confrontation Interactive : Normalisation (Min-Max) vs Standardisation (Z-Score)

Manipulez le curseur ci-dessous pour insérer une valeur extrême (outlier) dans le jeu de données saines [10, 15, 20, 25]. Observez en temps réel l’effet destructeur de tassement sur la Normalisation Min-Max, tandis que la Standardisation Z-Score conserve l’espacement et la structure des données saines :

ui.scalingSimulator()

Déterminez par vous-même la sensibilité de chaque méthode grâce au simulateur vectoriel interactif ci-dessous :

🧼 Nettoyage Vectoriel

Ajustez la méthode de détection et le seuil de tolérance pour analyser en temps réel l’impact de l’exclusion des valeurs aberrantes sur notre jeu de données.

viewof selected_method = ui.toggle({
  label: "Méthode d'analyse :", 
  options: ["Z-Score", "IQR"], 
  value: "Z-Score",
  states: { "Z-Score": "info", "IQR": "success" }
})
viewof selected_threshold = Inputs.range([0.5, 4.0], { value: 2.5, step: 0.1, label: "Seuil de tolérance :" })

data_points = {
  const pts = [];
  // 80 normal points clustered around (50, 50) using Box-Muller transform
  for(let i = 0; i < 80; i++) {
    let u = 1 - Math.random(); let v = Math.random();
    let zx = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
    let zy = Math.sqrt(-2.0 * Math.log(u)) * Math.sin(2.0 * Math.PI * v);
    pts.push({
      x: Math.min(88, Math.max(12, 50 + zx * 7.5)),
      y: Math.min(88, Math.max(12, 50 + zy * 7.5))
    });
  }
  // 12 extreme anomalies scattered on the outer edges (inscribed safely inside bounds)
  for(let i = 0; i < 12; i++) {
    pts.push({
      x: Math.random() > 0.5 ? 8 + Math.random() * 10 : 82 + Math.random() * 10,
      y: Math.random() > 0.5 ? 8 + Math.random() * 10 : 82 + Math.random() * 10
    });
  }
  return pts;
}

// 3. Calcul des statistiques et des frontières
clean_stats = {
  const xs = data_points.map(d => d.x).sort((a,b) => a-b);
  const ys = data_points.map(d => d.y).sort((a,b) => a-b);
  let bounds = {};

  if (selected_method === "Z-Score") {
    const meanX = xs.reduce((a,b)=>a+b)/xs.length;
    const meanY = ys.reduce((a,b)=>a+b)/ys.length;
    const stdX = Math.sqrt(xs.reduce((sq, n) => sq + Math.pow(n - meanX, 2), 0) / xs.length);
    const stdY = Math.sqrt(ys.reduce((sq, n) => sq + Math.pow(n - meanY, 2), 0) / ys.length);
    bounds = {
      type: "Z-Score",
      cx: meanX, cy: meanY,
      xMin: Math.max(0, meanX - selected_threshold * stdX), 
      xMax: Math.min(100, meanX + selected_threshold * stdX),
      yMin: Math.max(0, meanY - selected_threshold * stdY), 
      yMax: Math.min(100, meanY + selected_threshold * stdY)
    };
  } else { // IQR
    const q1X = xs[Math.floor(xs.length * 0.25)];
    const q3X = xs[Math.floor(xs.length * 0.75)];
    const iqrX = q3X - q1X;
    const q1Y = ys[Math.floor(ys.length * 0.25)];
    const q3Y = ys[Math.floor(ys.length * 0.75)];
    const iqrY = q3Y - q1Y;
    bounds = {
      type: "IQR",
      xMin: Math.max(0, q1X - selected_threshold * iqrX), 
      xMax: Math.min(100, q3X + selected_threshold * iqrX),
      yMin: Math.max(0, q1Y - selected_threshold * iqrY), 
      yMax: Math.min(100, q3Y + selected_threshold * iqrY),
      innerX1: q1X, innerX2: q3X,
      innerY1: q1Y, innerY2: q3Y
    };
  }

  // Filter points based on boundaries
  const processed = data_points.map((d, index) => {
    const isOutlier = d.x < bounds.xMin || d.x > bounds.xMax || d.y < bounds.yMin || d.y > bounds.yMax;
    let status = isOutlier ? "Anomalie" : "Conservé";
    if (selected_method === "IQR" && !isOutlier) {
      const isCore = d.x >= bounds.innerX1 && d.x <= bounds.innerX2 && d.y >= bounds.innerY1 && d.y <= bounds.innerY2;
      if (isCore) status = "Cœur";
    }
    return { ...d, id: index, status };
  });

  const total = processed.length;
  const anomalies = processed.filter(d => d.status === "Anomalie").length;
  const kept = total - anomalies;

  return { bounds, processed, total, kept, anomalies };
}

// 4. HTML Generation using Core Reusable Atomic Design Classes
clean_simulator_html = {
  const { bounds, processed, total, kept, anomalies } = clean_stats;
  
  // Draw boundary safety box using global design systems
  const boundaryHtml = `
    <div class="ui-boundary-box" style="
      left: ${bounds.xMin}%; 
      bottom: ${bounds.yMin}%; 
      width: ${bounds.xMax - bounds.xMin}%; 
      height: ${bounds.yMax - bounds.yMin}%;
    "></div>
  `;

  // Draw IQR core box or mean centerlines
  let innerHtml = "";
  if (selected_method === "IQR") {
    innerHtml = `
      <div class="ui-iqr-box" style="
        left: ${bounds.innerX1}%; 
        bottom: ${bounds.innerY1}%; 
        width: ${bounds.innerX2 - bounds.innerX1}%; 
        height: ${bounds.innerY2 - bounds.innerY1}%;
      ">
        <span class="ui-iqr-label">BOÎTE IQR (Q1-Q3)</span>
      </div>
    `;
  } else {
    // Standard deviation crosshair (Mean lines)
    innerHtml = `
      <div class="ui-crosshair-x" style="left: ${bounds.cx}%;"></div>
      <div class="ui-crosshair-y" style="bottom: ${bounds.cy}%;"></div>
      <span class="ui-crosshair-label" style="
        left: ${bounds.cx + 2.5}%; 
        bottom: ${bounds.cy + 2.5}%;
      ">Moyenne (μ)</span>
    `;
  }

  // Draw vectorized data points
  const pointsHtml = processed.map(p => {
    let statusClass = "is-clean";
    if (p.status === "Anomalie") {
      statusClass = "is-anomaly";
    } else if (p.status === "Cœur") {
      statusClass = "is-core";
    }
    
    return `
      <div class="ui-vector-point ${statusClass}" style="
        left: ${p.x}%; 
        bottom: ${p.y}%;
      " title="Point ${p.id} (X: ${p.x.toFixed(1)}, Y: ${p.y.toFixed(1)}) - ${p.status}">
      </div>
    `;
  }).join('');

  // Generate real-time logging records
  const logs = [
    ui.logLine({ message: `Méthode activée : ${selected_method}`, type: "info" }),
    ui.logLine({ message: `Seuil d'exclusion : ${selected_threshold.toFixed(2)}`, type: "info" }),
    selected_method === "Z-Score"
      ? ui.logLine({ message: `Statistiques : μ_x=${bounds.cx.toFixed(1)}%, μ_y=${bounds.cy.toFixed(1)}%`, type: "info" })
      : ui.logLine({ message: `Interquartiles : X=[${bounds.innerX1.toFixed(1)}% - ${bounds.innerX2.toFixed(1)}%], Y=[${bounds.innerY1.toFixed(1)}% - ${bounds.innerY2.toFixed(1)}%]`, type: "info" }),
    ui.logLine({ message: `Détecté : ${anomalies} anomalie(s) exclue(s) (${kept} points sains restants)`, type: anomalies > 0 ? "warning" : "success" })
  ];

  // Assemble Core UI structures
  return `
    <div class="ui-vector-container">
      
      <div class="ui-metrics-row">
        ${ui.metricCard({ title: "Données propres", value: kept, trend: "positive" })}
        ${ui.metricCard({ title: "Anomalies", value: anomalies, trend: anomalies > 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: `Espace Vectoriel (${selected_method})`, 
            height: "380px",
            content: `
              ${boundaryHtml}
              ${innerHtml}
              ${pointsHtml}
              <div class="ui-canvas-legend">
                <div class="ui-legend-item is-info">● Valeur saine</div>
                <div class="ui-legend-item is-danger">● Outlier (Aberrant)</div>
                ${selected_method === "IQR" 
                  ? '<div class="ui-legend-item is-success">● Cœur (Q1-Q3)</div>' 
                  : '<div class="ui-legend-item is-success">- - Centre (μ)</div>'}
              </div>
            `
          })}
        </div>
        
        <div class="ui-vector-sidebar">
          ${ui.terminalConsole({ header: "Pipeline d'Analyse Vectorielle", logs: logs })}
        </div>
      </div>

    </div>
  `;
}

ui.render(clean_simulator_html)

⚖️ Z-Score vs IQR : Quelle différence sur le terrain ?

Bien que ces deux méthodes cherchent à identifier ou gérer les valeurs extrêmes, elles reposent sur des philosophies mathématiques opposées :

• Z-Score (Le Centre Statistique) : Il s’appuie sur la Moyenne (\mu) et l’Écart-type (\sigma).
  • Le Problème : Si une erreur est gigantesque (ex: un salaire saisi à 10 000 000 € au lieu de 1 000 €), elle va “tirer” la moyenne vers elle et gonfler l’écart-type. Cela décale la frontière de sécurité et masque d’autres anomalies réelles.
  • Formule : Z = \frac{x - \mu}{\sigma}
• IQR (Le Cœur des Données / Robust) : Il s’appuie sur la Médiane et la Boîte Interquartile (Q3 - Q1, qui contient les 50 % des données les plus centrales).
  • L’Avantage : L’IQR est robuste aux extrêmes. Même si vous introduisez une anomalie à des milliards de kilomètres, la médiane et la boîte interquartile resteront fixes. Le seuil de sécurité reste parfaitement en place !

💡 En résumé : Utilisez la standardisation classique (Z-Score) pour des distributions symétriques sans anomalies sauvages (courbe de Gauss). Optez pour le Robust Scaler / IQR dès que vos variables sont asymétriques ou polluées par des erreurs extrêmes.

2.4.3 ⚠️ Impact selon l’Algorithme

C’est ici que l’ingénieur se distingue du débutant. Faut-il toujours “scaler” ses données ? Non. Cela dépend de l’algorithme choisi.

• 🟢 Indispensable (Distance & Gradients) : Pour les modèles basés sur le calcul de distances géométriques (K-Nearest Neighbors, SVM) ou sur la descente de gradient (Réseaux de Neurones, Régression Logistique). Une variable sur une grande échelle dominerait les plus petites et ralentirait dramatiquement la convergence.
• 🔴 Inutile (Modèles basés sur les Arbres) : Pour les algorithmes d’ensemble (Arbres de Décision, Random Forest, XGBoost, LightGBM). Ces modèles divisent les données grâce à des comparaisons de seuils logiques (Si \, X > 10). Les transformations (Z-score ou Min-Max) sont dites monotones : elles préservent l’ordre absolu. Que le seuil soit 10 ou 0.85, la coupure de l’arbre sera mathématiquement identique.

Focus Deep Learning : Batchnorm et CMN

Pour des architectures IA complexes, on intègre cette mise à l’échelle directement dans le modèle. Par exemple, la Batchnorm (Normalisation par lots) stabilise l’apprentissage à chaque couche d’un réseau de neurones. En analyse audio (reconnaissance vocale type LibriSpeech), on utilise la CMN (Cepstral Mean Normalization) pour gommer les distorsions liées au bruit ambiant.

2.5 🏷️ Encodage des Variables

La barrière de la langue algorithmique

Le Machine Learning est une discipline purement mathématique : il calcule des gradients, des distances et des probabilités. Par conséquent, il ne peut traiter nativement que des nombres. Si vous lui donnez une colonne “Ville” avec “Paris”, “Lyon” et “Marseille”, il plantera. La conversion des variables catégorielles (textuelles) en format numérique est donc une étape obligatoire.

L’expert doit arbitrer entre plusieurs techniques d’encodage selon la nature des catégories et leur cardinalité (le nombre de valeurs uniques).

2.5.1 🧮 Méthodes Classiques

• Le Label Encoding (Étiquettes) : Attribue simplement un nombre entier unique à chaque catégorie (ex: Paris=1, Lyon=2, Marseille=3).
  • Le Piège : Cette méthode introduit un “ordre artificiel” (2 est plus grand que 1). Si la variable est nominale (sans ordre), le modèle peut déduire à tort que Lyon est supérieur à Paris.
  • Quand l’utiliser ? Uniquement pour les variables ordinales (ex: Tailles de vêtement S=1, M=2, L=3).
• Le One-Hot Encoding (Binaire) : Crée une nouvelle colonne binaire (0 ou 1) pour chaque modalité possible de la variable catégorielle.
  • L’Avantage : Parfait pour éviter un ordre artificiel sur des variables nominales.
  • Le Piège : Si vous avez une variable “Code Postal” (36 000 valeurs), vous allez créer 36 000 nouvelles colonnes ! C’est ce qu’on appelle le fléau de la dimensionnalité, qui sature la RAM et provoque du surapprentissage (Overfitting).

2.5.2 🚀 Méthodes Avancées

Quand le One-Hot Encoding fait exploser votre mémoire, il faut ruser. L’industrie utilise souvent la bibliothèque category_encoders pour cela.

• Le Target Encoding (Moyenne Cible) : Substitue une catégorie par une statistique tirée de la variable cible (ce qu’on cherche à prédire). Par exemple, on remplace “Paris” par le taux de fraude moyen observé à Paris sur l’ensemble d’entraînement.
  • Avantage : Ne crée aucune nouvelle colonne, très performant pour les modèles basés sur les arbres (XGBoost).
  • Danger (Target Leakage) : Risque majeur de “fuite de la cible”. Si on calcule la moyenne en incluant la ligne en cours, le modèle prend par cœur le résultat au lieu de le prédire. Il faut appliquer un “lissage” ou calculer la moyenne en excluant la ligne actuelle (Leave-one-out).
• Le Hashing Encoder (Hachage) : Projette les catégories dans un espace fini (un nombre défini de colonnes, ex: 8 bits) via une fonction de hachage (comme MD5), sans jamais stocker le dictionnaire d’origine.
  • Avantage : Empreinte mémoire minuscule et constante. Accepte de nouvelles catégories “inconnues” en production sans planter.
  • Inconvénient : Accepte les “collisions” (deux mots différents peuvent être hachés dans la même colonne), ce qui entraîne une légère perte d’information au profit de la vitesse.

📊 Schéma Interactif : Les Mécanismes d’Encodage sur les Séries Catégorielles

Sélectionnez le mode d’encodage dans les onglets ci-dessous pour voir comment une série catégorielle de départ est physiquement projetée sous forme de série(s) ou matrice numérique en sortie :

ui.encodingVisualizer()

2.5.3 💻 Implémentation en Python

import pandas as pd
from category_encoders import TargetEncoder, HashingEncoder

# 1. One-Hot Encoding natif avec Pandas (pour faible cardinalité)
df_onehot = pd.get_dummies(df, columns=['Genre'], drop_first=True)

# 2. Target Encoding (Scikit-learn Contrib)
# On encode la variable "Ville" en fonction de la variable cible "A_Fraude"
target_enc = TargetEncoder(smoothing=10) # Le smoothing évite le Target Leakage
df['Ville_Encoded'] = target_enc.fit_transform(df['Ville'], df['A_Fraude'])

# 3. Hashing Encoder (Pour les très hautes cardinalités comme "ID_Produit")
# On force le résultat sur seulement 8 colonnes (n_components=8)
hash_enc = HashingEncoder(cols=['ID_Produit'], n_components=8)
df_hashed = hash_enc.fit_transform(df)

2.6 TP1 : Le Titanic (Wrangling)

Dans ce premier Travail Pratique, vous allez mettre en pratique les techniques fondamentales de Data Wrangling sur le célèbre jeu de données du Spaceship Titanic. L’objectif est d’effectuer un nettoyage complet pour restaurer une base de données corrompue afin de la rendre exploitable pour les étapes futures.

2.6.1 🎯 Objectifs Pédagogiques

• Audit de Qualité : Explorer un jeu de données brut pour dresser un bilan des anomalies physiques, des doublons et des incohérences de typage.
• Gestion des Valeurs Manquantes : Concevoir et appliquer des stratégies d’imputation adaptées (imputation par la médiane pour l’âge, par la valeur par défaut pour le statut VIP).
• Feature Engineering Initial : Apprendre à combiner et agréger des variables corrélées en créant une nouvelle caractéristique de synthèse (Total_Spent représentant la somme des dépenses individuelles).
• Export Propre : Sauvegarder vos résultats dans un format structuré et standardisé pour garantir la reproductibilité.

2.6.2 📁 Fichiers du TP

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

Dataset du Titanic ZIP

• tp1.ipynb (Notebook d’exploration et de nettoyage à compléter)
• train.csv (Jeu de données brut de l’équipage et des passagers)

2.7 🌉 Conclusion et Transition

Vos données sont maintenant propres et prêtes à être analysées. L’étape suivante consiste à apprendre à les visualiser pour mieux les comprendre et les explorer.

C’est ce que nous allons voir dans le Chapitre 3 : Visualisation des Données.