1 📥 Acquisition et Compréhension des Données

1.1 🗂️ Types de Données

💡 Concept Clé : La Taxonomie des Données

Avant d’écrire la moindre ligne de code, l’enquêteur doit classifier ses pièces à conviction. Cette taxonomie dicte les futures décisions d’encodage et la structure même de votre futur modèle prédictif (Chugh 2025).

L’univers des données se divise en deux grandes familles imposant des contraintes techniques distinctes.

1.1.1 ⚖️ Les Deux Grandes Familles

Données Qualitatives

Catégorielles Représentent des étiquettes ou caractéristiques non mathématiques.

Nominales : Sans hiérarchie (ex: Code pays, Couleur).
Ordinales : Avec une logique de rang (ex: Niveau de satisfaction, Tailles S/M/L).

Données Quantitatives

Numériques Représentent des quantités mesurables supportant les opérations mathématiques.

Discrètes : Valeurs entières dénombrables (ex: Nb d’enfants).
Continues : Valeurs décimales mesurables (ex: Température, Salaire).

1.1.2 ⚠️ Impact sur l’Algorithme

Pourquoi passer du temps sur cette classification ? Parce qu’elle modifie radicalement votre matrice en mémoire :

Le Piège des Données Nominales : Une forte cardinalité (ex: Code Postal) peut faire exploser la RAM lors de l’encodage et risquer le Surapprentissage (Overfitting).
La Perte du Rang : Traiter une donnée ordinale comme nominale détruit l’information de hiérarchie indispensable aux arbres de décision.

🎒 Astuce Pro : Validation Continue

Utilisez des outils comme Pandera pour sanctuariser le typage dès l’entrée du pipeline. Un enquêteur ne travaille jamais sur des preuves dont le type est incertain.

💡 Concept Clé : Cardinalité

Nombre de valeurs uniques dans une variable. Une cardinalité trop élevée sur des données nominales est un signal d’alerte pour l’architecte de données.

🕵️‍♂️ Atelier Pratique : Qualifiez vos preuves

Une bombe statistique est sur la scène du crime. Saurez-vous classifier correctement ces variables avant de les intégrer à votre modèle pour la désamorçer ?

viewof classification_game = ui.cablingExercise({
  title: "PANNEAU DE BRASSAGE DES INDICES",
  instructions: "Reliez chaque pièce à conviction de gauche à sa catégorie de données logique de droite en cliquant d'abord sur la fiche de gauche puis sur la prise femelle de droite.",
  leftItems: [
    { id: "postal", label: "Le code postal du suspect (ex: 75001)", match: "nominale" },
    { id: "salaire", label: "Le salaire annuel en euros (ex: 45200.50)", match: "continue" },
    { id: "mention", label: "La mention au bac (Passable, Bien, Très Bien)", match: "ordinale" },
    { id: "fraud", label: "Le nombre de transactions frauduleuses", match: "discrete" }
  ],
  rightItems: [
    { id: "nominale", label: "Nominale" },
    { id: "ordinale", label: "Ordinale" },
    { id: "discrete", label: "Discrète" },
    { id: "continue", label: "Continue" }
  ],
  feedbacks: {
    postal: "Le code postal est bien nominal. Même s'il s'agit de chiffres, leur somme, leur moyenne ou leur comparaison n'a aucun sens mathématique.",
    salaire: "Le salaire est quantitatif continu. Il s'exprime sur une échelle infinie de valeurs décimales mesurables.",
    mention: "La mention au bac est qualitative ordinale. Ce sont des catégories textuelles, mais dotées d'une hiérarchie stricte indiscutable.",
    fraud: "Le nombre de transactions est quantitatif discret. On dénombre des unités entières distinctes (pas de demi-transaction)."
  },
  successMessage: "Excellent ! Tous les signaux sont parfaitement synchronisés. Votre diagnostic d'expert des données est validé !",
  errorMessage: "Alerte : Des courts-circuits subsistent dans votre brassage de signal. Relisez attentivement la nature de chaque indice."
})

🔎 Simulateur de Sanity Check : L’Impact d’un Outlier

Observez la distribution de l’âge de nos suspects. À l’état brut, le graphique est illisible. Pourquoi ? Parce qu’une erreur de saisie s’est glissée dans le fichier CSV. Activez le filtre pour nettoyer la donnée et révéler la véritable distribution.

normal_ages = Array.from({length: 100}, () => Math.round(Math.random() * 40 + 20))
brut_ages = [...normal_ages, 455]

viewof filter_selection = ui.toggle({
  label: "Nettoyage des Données :",
  options: {
    "brut": "Données Brutes (Avec Outlier) ⚠️",
    "clean": "Sanity Check (Âge < 120) 🧹"
  },
  value: "brut",
  states: {
    "brut": "warning",
    "clean": "success"
  }
})

apply_filter = filter_selection === "clean"

current_ages = apply_filter ? normal_ages : brut_ages
current_mean = (current_ages.reduce((a, b) => a + b, 0) / current_ages.length).toFixed(1)

// BLOC 2 : Rendu DOM (Métriques)
ui.render(`
  <div class="ui-metrics-row">
    ${ui.metricCard({ 
      title: "Âge Moyen Calculé", 
      value: current_mean + " ans", 
      trend: apply_filter ? "positive" : "danger", 
      subtitle: apply_filter ? "Moyenne représentative" : "Moyenne faussée par l'anomalie" 
    })}
  </div>
`)

// BLOC 3 : Rendu DOM (Graphique Plotly)
ui.plotlyWrapper({
  title: "Boîte à Moustaches (Boxplot) de l'Âge",
  height: "250px",
  data: [
    {
      x: current_ages,
      type: 'box',
      name: 'Suspects',
      marker: { color: apply_filter ? ui.colors.green : ui.colors.orange }, // Zéro couleur hardcodée
      boxpoints: 'all',
      jitter: 0.3,
      pointpos: 0
    },
    ...(apply_filter ? [] : [
      // Halo externe de l'aura
      {
        x: [455],
        y: ['Suspects'],
        mode: 'markers',
        type: 'scatter',
        name: 'Outlier Aura 1',
        showlegend: false,
        marker: {
          symbol: 'circle',
          size: 38,
          color: ui.rgba(ui.colors.orange, 0.15),
          line: {
            color: ui.rgba(ui.colors.orange, 0.3),
            width: 1.5
          }
        }
      },
      // Halo intermédiaire
      {
        x: [455],
        y: ['Suspects'],
        mode: 'markers',
        type: 'scatter',
        name: 'Outlier Aura 2',
        showlegend: false,
        marker: {
          symbol: 'circle',
          size: 22,
          color: ui.rgba(ui.colors.orange, 0.25),
          line: {
            color: ui.rgba(ui.colors.orange, 0.6),
            width: 1.5,
            dash: 'dash'
          }
        }
      },
      // Point central surbrillant
      {
        x: [455],
        y: ['Suspects'],
        mode: 'markers',
        type: 'scatter',
        name: 'Outlier Aura 3',
        showlegend: false,
        marker: {
          symbol: 'circle',
          size: 8,
          color: ui.colors.orange,
          line: {
            color: ui.colors.base3,
            width: 1
          }
        }
      }
    ])
  ],
  layout: {
    xaxis: { title: 'Âge enregistré', range: [0, apply_filter ? 100 : 500] },
    yaxis: { showticklabels: false },
    margin: { t: 40, r: 20, b: 40, l: 20 },
    annotations: apply_filter ? [] : [
      {
        x: 455,
        y: 'Suspects',
        xref: 'x',
        yref: 'y',
        text: '⚠️ Outlier : Suspect de 455 ans !',
        showarrow: true,
        arrowhead: 2,
        ax: -70,
        ay: -50,
        arrowcolor: ui.colors.orange,
        font: {
          color: ui.colors.orange,
          size: 11,
          family: '"Recursive", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
          weight: 'bold'
        },
        bgcolor: ui.rgba(ui.colors.base03, 0.95),
        bordercolor: ui.colors.orange,
        borderwidth: 1.5,
        borderpad: 5
      }
    ]
  }
})

1.2 🧱 Anatomie du DataFrame

💡 Concept Clé : Au-delà du tableau Excel

Un DataFrame n’est pas qu’un simple tableau visuel. Pour le raffineur de données, c’est un agencement complexe en mémoire vive (RAM) dont la structure physique dicte la vitesse de vos calculs. Passer d’un code “qui marche” à un code industriel demande de comprendre comment ces données sont stockées.

1.2.1 🏗️ L’Anatomie du DataFrame

Un DataFrame moderne est composé de trois briques fondamentales qui collaborent pour optimiser l’accès aux données (The pandas development team 2026) :

L’Index (La Colonne Vertébrale) : Structure de hachage optimisée. Il permet de passer d’une recherche lente (parcours complet) à une recherche instantanée en O(1).
Les Séries (Series) : Chaque colonne est une Series. En science des données, on considère la colonne comme l’unité atomique de calcul.
Le Backend (Le Moteur) : Gère réellement les octets en RAM. Historiquement NumPy, aujourd’hui Apache Arrow pour plus de performance.

1.2.2 ⚡ La Révolution Columnar (Stockage Colonnaire)

La grande différence entre une base de données classique (SQL) et un DataFrame réside dans l’organisation des données en mémoire.

Stockage par lignes (Transactionnel) : Idéal pour modifier un utilisateur précis.
Stockage par colonnes (Analytique/IA) : Idéal pour calculer la moyenne d’un million de prix.

🎒 Astuce Pro : Pourquoi le format colonnaire ?

En stockant les données d’une même colonne côte à côte en mémoire, le processeur peut utiliser des instructions SIMD (Single Instruction Multiple Data). Cela permet d’appliquer une opération sur un vecteur entier en un seul cycle d’horloge. C’est l’essence même de la performance en Data Science (Bato 2026).

1.2.3 🏎️ Eager vs Lazy

Exécution Immédiate (Eager - Pandas) : Chaque instruction est exécutée dès qu’elle est lue. Intuitif, mais génère souvent des copies inutiles en RAM.
Exécution Différée (Lazy - Polars) : Le moteur construit un plan d’optimisation (Query Plan) et ne calcule le résultat qu’au dernier moment, permettant d’ignorer les données inutiles dès la source.

🧠 Simulateur : La Mémoire RAM en action

Observez comment le processeur accède aux données selon le type de stockage. Le format colonnaire est le secret de la rapidité des enquêteurs modernes.

viewof storageMode = ui.toggle({
  label: "Structure en RAM :",
  options: {
    "ligne": "Orienté Ligne (CSV, Pandas)",
    "colonne": "Orienté Colonne (Parquet, Polars, Arrow)"
  },
  value: "ligne",
  states: {
    "ligne": "danger",
    "colonne": "success"
  }
})

viewof queryCol = ui.toggle({
  label: "Simuler une requête d'analyse sur :",
  options: ["Aucune", "Âge", "Salaire"],
  value: "Aucune",
  states: {
    "Aucune": "info",
    "Âge": "warning",
    "Salaire": "warning"
  }
})

tableData = [
  { ID: "A1", Âge: 25, Salaire: "50k" },
  { ID: "B2", Âge: 30, Salaire: "60k" },
  { ID: "C3", Âge: 28, Salaire: "55k" }
]

colors = ({ ID: ui.colors.blue, Âge: ui.colors.green, Salaire: ui.colors.orange })

// 3. Logique de rendu via le composant réutilisable ramPathSimulator
ui.render(ui.ramPathSimulator({
  storageMode: storageMode,
  queryCol: queryCol,
  tableData: tableData,
  colors: colors,
  arcMultiplier: 0.95 // Arcs majestueux pour des sauts bien visibles (30% plus hauts !)
}))

💡 Concept Clé : SIMD

Capacité d’un processeur à effectuer la même opération sur plusieurs données simultanément. Essentiel pour le traitement massif de données.

⚠️ Danger : Copie de Données

Évitez de multiplier les copies de DataFrames intermédiaires. En mode “Eager”, chaque copie consomme une portion précieuse de votre RAM.

💡 Concept Clé : Évaluation Paresseuse (Lazy Evaluation)

Évaluation Paresseuse (Lazy Evaluation) : Stratégie consistant à attendre le dernier moment pour calculer un résultat, permettant d’optimiser l’ensemble des étapes de calcul.

1.3 📥 Ingestion des Données

💡 Concept Clé : L’Optimisation à la Source

L’optimisation d’un projet IA commence à l’octet près lors de la lecture du disque. Charger l’intégralité d’un énorme fichier CSV avec les paramètres par défaut est une erreur d’amateur qui peut saturer la mémoire vive (RAM) instantanément.

1.3.1 📂 Structure des Dossiers

Avant d’ingérer, un bon enquêteur organise ses dossiers. Voici la structure attendue pour vos projets :

1.3.2 📥 Ingestion Multi-Format

Le Standard Industriel : Apache Parquet

Pour l’IA moderne, le format Apache Parquet est le roi. Orienté colonne et fortement compressé, il préserve le typage des données et réduit drastiquement l’empreinte disque.

Pandas (Eager)
Polars (Lazy)

import pandas as pd

# ✅ L'approche industrielle (Optimisation à la lecture)
colonnes_utiles = ['ID', 'Age', 'Score_Credit']
types_optimises = {'ID': 'int32', 'Age': 'int8', 'Score_Credit': 'float32'}

df = pd.read_csv(
    "data/raw/clients.csv", 
    usecols=colonnes_utiles, # Sélection sélective
    dtype=types_optimises    # Downcasting préventif
)

import polars as pl

# 🚀 Lecture Lazy (Planification sans exécution)
q = (
    pl.scan_csv("data/raw/clients.csv")
    .filter(pl.col("Age") > 18) # Filtre appliqué à la source
    .select(["ID", "Age"])
)

# .collect() déclenche le calcul multi-threadé
df = q.collect()

⚠️ Danger : Surcharge de RAM

Si votre fichier dépasse votre capacité RAM, utilisez le Chunking (chunksize en Pandas) ou passez en mode Streaming avec Polars. Ne laissez jamais un fichier saturer votre établi.

1.3.3 🔎 Le Sanity Check

Une donnée ingérée n’est pas une donnée fiable. Implémentez un protocole systématique pour détecter les anomalies :

Audit de Mémoire : Utilisez df.info(memory_usage='deep') pour voir la consommation réelle (incluant les textes).
Typologie du Vide : Identifiez les NaN (flottants), None (objets) et NaT (dates).
Distribution Statistique : Utilisez .describe() pour repérer immédiatement les valeurs aberrantes (ex: un âge négatif).

🎒 Astuce Pro : Le Sanity Check

Automatisez ces vérifications avec des bibliothèques comme Great Expectations. Une preuve dont la structure change en cours de route peut invalider toute votre enquête.

1.4 🌉 Conclusion et Transition

Maintenant que nous savons comment acquérir des données et les structurer dans des DataFrames, nous allons voir comment les nettoyer pour les rendre exploitables.

C’est l’objectif du Chapitre 2 : Data Wrangling (Nettoyage et Préparation).

Bato. 2026. “Pandas 3.0’s PyArrow String Revolution: A Deep Dive into Memory and Performance.” DEV Community. February 2026.

Chugh, Vidhi. 2025. “Tutoriel Python Pandas : Le Guide Ultime Pour Les Débutants.” DataCamp. February 2025.

The pandas development team. 2026. Pandas 3.0.3 Documentation. PyData. https://pandas.pydata.org/docs/.