🤖 Data Engineering for AI
Module : Data Engineering for AI
1. Introduction : Data-Centric AI
Durée estimée : 1-2 heures
Prérequis : Aucun (module de découverte)
📍 Où en es-tu dans le parcours ?
DONNÉES BRUTES DATASET PRÊT
(chaos) (training-ready)
│ ▲
│ Module 2 Module 3 Module 4 Module 5 │
│ ────────── ────────── ────────── ────────── │
│ │
▼ │
┌─────────┐ ┌─────────────┐ ┌──────────┐ ┌────────┴───────┐
│ │ │ │ │ │ │ │
│ STOCKER │─────▶│ TRANSFORMER │─────▶│ ENRICHIR │─────▶│ AUTOMATISER & │
│ │ │ │ │ │ │ VERSIONNER │
│ │ │ │ │ │ │ │
└─────────┘ └─────────────┘ └──────────┘ └────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ MODULE 1 : INTRODUCTION — Tu comprends le POURQUOI avant le COMMENT │
└─────────────────────────────────────────────────────────────────────────┘
🎯 Question centrale de ce module
Pourquoi la qualité des données est-elle plus importante que le modèle lui-même ?
📦 Ce que tu vas maîtriser
À la fin de ce module, tu sauras :
- Expliquer l'approche Data-Centric AI et pourquoi elle domine aujourd'hui
- Différencier ML, Deep Learning et IA Générative
- Comprendre ce qu'est le training et pourquoi les données sont critiques
- Citer des exemples réels de Garbage In, Garbage Out
- Décrire le rôle du Data Engineer dans une équipe IA
- Visualiser le parcours complet qu'on va suivre ensemble
🛠️ Ce que tu vas apprendre
| Concept | Pourquoi c'est important | Section |
|---|---|---|
| Data-Centric AI | Comprendre l'approche moderne | 1.0 |
| ML / DL / GenAI | Différencier les types d'IA | 1.1 |
| Le training | Comprendre comment un modèle apprend | 1.2 |
| Ratio 80/20 | Pourquoi les données dominent | 1.3 |
| GIGO | Les conséquences des mauvaises données | 1.4 |
| Rôle du DE | Ta place dans l'équipe | 1.5 |
| Stack technique | Les outils qu'on va utiliser | 1.6 |
💡 Ce module est théorique — pas de code à écrire. L'objectif est de comprendre le "pourquoi" avant le "comment".
🎯 La question centrale de ce module
┌─────────────────────────────────────────────────────────────────────────────────┐
│ │
│ COMMENT PRÉPARER DES DONNÉES DE QUALITÉ POUR ENTRAÎNER UN MODÈLE D'IA ? │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
Que tu veuilles :
- Fine-tuner un LLM (comme GPT ou Llama) sur tes documents d'entreprise
- Entraîner un modèle de génération d'images (comme Stable Diffusion)
- Créer un système de reconnaissance d'images pour ton métier
- Construire un chatbot spécialisé sur ton domaine
Tu auras besoin d'un dataset de qualité. Et c'est là qu'intervient le Data Engineer.
💡 Ce module t'apprend les compétences Data Engineering nécessaires pour travailler dans une équipe IA/ML.
📍 Le parcours : de données brutes à dataset training-ready
DONNÉES BRUTES DATASET PRÊT
(chaos) (training-ready)
│ ▲
│ Module 2 Module 3 Module 4 Module 5 │
│ ────────── ────────── ────────── ──────── │
│ │
▼ │
┌─────────┐ ┌─────────────┐ ┌──────────┐ ┌────────┴───────┐
│ │ │ │ │ │ │ │
│ STOCKER │─────▶│ TRANSFORMER │─────▶│ ENRICHIR │─────▶│ AUTOMATISER & │
│ │ │ │ │ │ │ VERSIONNER │
│ │ │ │ │ │ │ │
└─────────┘ └─────────────┘ └──────────┘ └────────────────┘
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────────┐ ┌──────────┐ ┌────────────────┐
│• MinIO │ │• Spark │ │• CLIP │ │• Airflow │
│• Parquet│ │• Pydantic │ │• Chroma │ │• DVC │
│• WebData│ │• Quality │ │• Explore │ │• MLflow │
└─────────┘ └─────────────┘ └──────────┘ └────────────────┘
│
▼
┌──────────────┐
│ Module 6 │
│ PROJET │
│ INTÉGRATION │
└──────────────┘
Chaque module répond à une question concrète
| Module | Question | Ce que tu apprendras | Livrable |
|---|---|---|---|
| 1. Introduction | Pourquoi le DE est critique pour l'IA ? | Contexte, enjeux, architecture | Compréhension du problème |
| 2. Stockage | Où stocker des millions de fichiers ? | MinIO, Parquet, WebDataset | Bucket organisé + catalogue |
| 3. Transformation | Comment transformer à grande échelle ? | Spark, validation, qualité | Données uniformisées |
| 4. Enrichissement | Comment enrichir et explorer ? | CLIP, Chroma, embeddings | Données vectorisées |
| 5. Automatisation | Comment automatiser et versionner ? | Airflow, DVC, MLflow | Pipeline reproductible |
| 6. Projet | Comment tout assembler ? | Intégration complète | Dataset training-ready |
🎯 À la fin de ce module, tu sauras prendre n'importe quelle source de données brutes et la transformer en un dataset de qualité, prêt à être utilisé pour entraîner un modèle d'IA.
1.0 Le paradigme Data-Centric AI
L'ancien monde vs le nouveau monde
Pendant des années, l'approche dominante en IA était model-centric : on fixait les données et on améliorait le modèle.
┌─────────────────────────────────────────────────────────────────────────────────┐
│ ÉVOLUTION DES APPROCHES EN IA │
├─────────────────────────────────────────────────────────────────────────────────┤
│ │
│ MODEL-CENTRIC (hier) DATA-CENTRIC (aujourd'hui) │
│ ──────────────────── ────────────────────────── │
│ │
│ • Données = fixées • Données = variable principale │
│ • Focus = architecture modèle • Focus = qualité des données │
│ • Itérer sur les hyperparamètres • Itérer sur les données │
│ • "Plus de données = mieux" • "Meilleures données = mieux" │
│ │
│ Le Data Engineer était Le Data Engineer est │
│ un fournisseur de données un architecte critique │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
Pourquoi ce changement ?
Andrew Ng (co-fondateur de Google Brain, Coursera) a popularisé ce concept :
"Instead of focusing on the code/model, focus on the data. It's the most efficient way to improve AI systems."
Les modèles modernes (GPT, Stable Diffusion, etc.) sont déjà très performants. Ce qui fait la différence, c'est la qualité des données qu'on leur donne.
La donnée est le code du modèle
Pense à un modèle d'IA comme un programme :
| Programmation classique | Machine Learning |
|---|---|
| Tu écris le code | Tu fournis les données |
| Le code définit le comportement | Les données définissent le comportement |
| Bug = erreur dans le code | Bug = erreur dans les données |
| Debug = lire le code | Debug = analyser les données |
┌─────────────────────────────────────────────────────────────────────────────────┐
│ │
│ Programmation classique : Règles écrites + Données → Résultat │
│ (par le dev) │
│ │
│ Machine Learning : Données + Algo → Règles │
│ (par le DE) (fixe) (apprises) │
│ │
│ 💡 En ML, les données SONT le programme. │
│ │
└─────────────────────────────────────────────────────────────────────────────────┘
Conséquence directe : la qualité de ton modèle dépend directement de la qualité de ton travail de Data Engineer.
1.1 Rappels : ML, Deep Learning, IA Générative
Si tu es déjà à l'aise avec ces concepts, passe à la section 1.2.
La hiérarchie des concepts
┌─────────────────────────────────────────────────────────────┐
│ INTELLIGENCE ARTIFICIELLE │
│ Tout système qui simule l'intelligence humaine │
│ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ MACHINE LEARNING │ │
│ │ Systèmes qui apprennent à partir de données │ │
│ │ │ │
│ │ ┌───────────────────────────────────────┐ │ │
│ │ │ DEEP LEARNING │ │ │
│ │ │ ML avec réseaux de neurones profonds│ │ │
│ │ │ │ │ │
│ │ │ ┌───────────────────────────┐ │ │ │
│ │ │ │ IA GÉNÉRATIVE │ │ │ │
│ │ │ │ DL qui génère du contenu │ │ │ │
│ │ │ │ (texte, images, audio) │ │ │ │
│ │ │ └───────────────────────────┘ │ │ │
│ │ └───────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
| Concept | Ce que ça fait | Exemples |
|---|---|---|
| Machine Learning | Apprend des patterns pour prédire | Spam filter, recommandations |
| Deep Learning | ML avec réseaux de neurones profonds | Reconnaissance faciale, traduction |
| IA Générative | Crée du nouveau contenu | ChatGPT, Stable Diffusion, Sora |
Comment fonctionne l'entraînement d'un modèle
Quel que soit le type d'IA, le principe est le même :
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ DONNÉES │────────▶│ MODÈLE │────────▶│ RÉSULTAT │
│ (dataset) │ Training│ (patterns) │Inférence│ (prédiction) │
│ │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
Exemples de datasets d'entraînement :
| Modèle | Dataset d'entraînement | Ce qu'il produit |
|---|---|---|
| GPT-4 / Claude | Textes du web (pétaoctets) | Conversations, code, analyses |
| Stable Diffusion | 5 milliards de paires image-texte | Images à partir de descriptions |
| Whisper | 680K heures d'audio | Transcription de la parole |
| ResNet | 14 millions d'images labellisées | Classification d'images |
💡 Point clé : Plus le modèle est puissant, plus il a besoin de données de qualité. Et c'est là que le Data Engineer intervient.
1.2 C'est quoi le training ?
On parle de "training" partout en IA. Mais c'est quoi exactement ?
L'analogie : apprendre à reconnaître des chats
┌─────────────────────────────────────────────────────────────────────────────┐
│ COMMENT UN HUMAIN APPREND │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Enfant voit: Parent dit: Enfant apprend: │
│ ──────────── ─────────── ─────────────── │
│ │
│ 🐱 (photo 1) → "C'est un chat" → "Ah, ça c'est un chat" │
│ 🐱 (photo 2) → "C'est un chat" → "Ça aussi" │
│ 🐕 (photo 3) → "C'est un chien" → "Ça c'est différent" │
│ 🐱 (photo 4) → "C'est un chat" → "Je commence à voir le pattern" │
│ ... │
│ │
│ Après 100 exemples: "Je sais reconnaître un chat !" │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
Le training en IA : exactement pareil
┌─────────────────────────────────────────────────────────────────────────────┐
│ COMMENT UN MODÈLE APPREND │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ IMAGE ────────────▶│ MODÈLE │────────────▶ PRÉDICTION │
│ (input) │ (réseau de │ (output) │
│ │ neurones) │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ LABEL ────────────▶│ COMPARER │────────────▶ ERREUR │
│ (vérité) │ (loss func) │ (à corriger) │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ AJUSTER │ ◄── C'est ça le "training" ! │
│ │ les poids │ │
│ └─────────────┘ │
│ │
│ Répéter des millions de fois jusqu'à ce que l'erreur soit minimale │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
Les composants du training
| Composant | C'est quoi | Exemple |
|---|---|---|
| Dataset | Les exemples pour apprendre | 1 million d'images de chats/chiens avec labels |
| Modèle | Le "cerveau" à entraîner | Réseau de neurones (des millions de paramètres) |
| Loss function | Mesure de l'erreur | "Tu as dit chien, c'était un chat" → erreur = 1 |
| Optimizer | Comment corriger | "Ajuste ce paramètre de +0.001" |
| Epoch | 1 passage sur tout le dataset | "J'ai vu les 1M d'images une fois" |
| Batch | Groupe d'images traitées ensemble | 32 images à la fois (plus efficace) |
Le cycle du training
┌─────────────────────────────────────────────────────────────────────────────┐
│ CYCLE D'UNE EPOCH │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Dataset: 1,000,000 images │
│ Batch size: 32 │
│ → 31,250 batches par epoch │
│ │
│ Pour chaque batch: │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 1. FORWARD : Image → Modèle → Prédiction │ │
│ │ 2. LOSS : Comparer prédiction vs label → Erreur │ │
│ │ 3. BACKWARD : Calculer comment corriger (gradients) │ │
│ │ 4. UPDATE : Ajuster les poids du modèle │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ Répéter pour 10-100 epochs jusqu'à convergence │
│ │
│ Temps total: heures → jours → semaines (selon la taille) │
│ Coût GPU: $100 → $10,000 → $1,000,000+ (pour les gros modèles) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
Pourquoi les données sont CRITIQUES pour le training
Le modèle apprend uniquement ce qu'on lui montre. Il ne peut pas inventer.
┌─────────────────────────────────────────────────────────────────────────────┐
│ DONNÉES → MODÈLE → COMPORTEMENT │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Ce que tu montres Ce que le modèle apprend │
│ ────────────────── ──────────────────────── │
│ │
│ Que des chats blancs → "Chat = blanc" (échoue sur chats noirs) │
│ Photos floues → "Flou = normal" (produit du flou) │
│ Labels incorrects → Comportement aléatoire │
│ Beaucoup de duplicatas → Mémorise au lieu d'apprendre │
│ Tailles incohérentes → Impossible de faire des batches │
│ │
│ ════════════════════════════════════════════════════════════════════ │
│ │
│ Données propres, diverses → Modèle qui généralise bien │
│ Labels corrects → Comportement prévisible │
│ Pas de duplicatas → Pas de mémorisation │
│ Format uniforme → Training efficace │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
| Problème de données | Impact sur le training | Impact sur le modèle final |
|---|---|---|
| Tailles variables | Pas de batching → 100x plus lent | Aucun (si on gère) |
| Images corrompues | Crash en plein training | Training échoue |
| Duplicatas | Overfitting | Mémorise, ne généralise pas |
| Biais (ex: que des hommes) | Training OK | Discrimine les femmes |
| Labels faux | Loss ne descend pas | Comportement erratique |
💡 C'est pour ça qu'on fait ce bootcamp : Préparer des données "training-ready" = données que le modèle peut consommer efficacement et dont il peut apprendre correctement.
Types de training
| Type | Données nécessaires | Exemple |
|---|---|---|
| Supervisé | Images + Labels | "Cette image est un chat" |
| Non-supervisé | Images seules | "Trouve des patterns" (clustering) |
| Auto-supervisé | Images seules, labels générés | "Prédit la partie masquée" (BERT, GPT) |
| Par renforcement | États + Récompenses | "Tu as gagné la partie" (AlphaGo) |
┌─────────────────────────────────────────────────────────────────────────────┐
│ SUPERVISÉ vs AUTO-SUPERVISÉ │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ SUPERVISÉ (classification) AUTO-SUPERVISÉ (LLM, CLIP) │
│ ───────────────────────── ────────────────────────── │
│ │
│ Image → "C'est un chat" Texte: "Le chat dort sur le ___" │
│ (label fourni par humain) Label: "canapé" (généré auto) │
│ │
│ Coûteux en annotation Pas besoin d'annotation │
│ (humains = $$$) (données internet = gratuit) │
│ │
│ ImageNet: 14M images GPT-4: trillions de tokens │
│ annotées à la main récupérés du web │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
🎯 Dans ce bootcamp, on prépare des données pour du training supervisé (images + métadonnées/labels) et auto-supervisé (données texte-image comme CLIP).
1.3 Le ratio 80/20 : pourquoi 80% du travail c'est la data
Le vrai ratio d'un projet IA
┌─────────────────────────────────────────────────────────────────┐
│ EFFORT DANS UN PROJET IA │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ████████████████████████████████████████████████░░░░░░░░░░░░ │
│ ◄──────────── 80% DATA ─────────────►◄─── 20% MODÈLE ────► │
│ │
│ • Collecte • Architecture │
│ • Nettoyage • Entraînement │
│ • Transformation • Évaluation │
│ • Qualité • Optimisation │
│ • Stockage │
│ • Versioning │
│ │
└─────────────────────────────────────────────────────────────────┘
Ce n'est pas un bug, c'est une réalité : les data scientists passent 80% de leur temps sur les données, pas sur les modèles.
Pourquoi c'est encore plus vrai pour l'IA générative
| Facteur | Impact |
|---|---|
| Volume | Des milliards d'exemples nécessaires |
| Qualité | Une seule donnée toxique peut polluer le modèle |
| Diversité | Éviter les biais demande une curation attentive |
| Format | Les modèles attendent des formats très spécifiques |
| Coût | Ré-entraîner coûte des millions → la data doit être parfaite |
Où passe le temps d'un Data Scientist ?
Selon le CrowdFlower Data Science Report 2016 (PDF disponible ici) :
┌─────────────────────────────────────────────────────────────────┐
│ TEMPS PASSÉ PAR TÂCHE (Data Scientists, 2016) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Nettoyer/Organiser données █████████████████████████ 60% │ ← Tâche #1 !
│ Collecter les données ████████░░░░░░░░░░░░░░░░░ 19% │
│ Mining data for patterns ████░░░░░░░░░░░░░░░░░░░░░ 9% │
│ Refining algorithms ██░░░░░░░░░░░░░░░░░░░░░░░ 4% │
│ Building training sets █░░░░░░░░░░░░░░░░░░░░░░░░ 3% │
│ Other ██░░░░░░░░░░░░░░░░░░░░░░░ 5% │
│ │
└─────────────────────────────────────────────────────────────────┘
79% du temps est passé sur les données (collecte + nettoyage), contre 21% sur l'analyse et les modèles.
💡 Le Data Engineer libère le Data Scientist des tâches de collecte, nettoyage et organisation. C'est un rôle stratégique.
1.4 Garbage In, Garbage Out — Exemples réels
Le principe fondamental
┌─────────────────────────────────────────────────────────────────┐
│ │
│ GARBAGE IN = GARBAGE OUT │
│ │
│ Si tu donnes de mauvaises données à un modèle, │
│ tu obtiendras un mauvais modèle. │
│ │
│ Aucune architecture de modèle, aussi sophistiquée soit-elle, │
│ ne peut compenser des données de mauvaise qualité. │
│ │
└─────────────────────────────────────────────────────────────────┘
Types de problèmes dans les données
| Problème | Impact sur le modèle | Exemple |
|---|---|---|
| Duplicatas | Overfitting, mémorisation | Le modèle récite au lieu de généraliser |
| Labels incorrects | Comportement erratique | Chat labellisé "chien" → confusion |
| Biais dans le dataset | Discrimination | Visages surtout blancs → mauvais sur autres ethnies |
| Données corrompues | Crash ou résultats absurdes | Image tronquée → erreur de training |
| Résolution incohérente | Artefacts, qualité dégradée | Mélange 64px et 4K → modèle confus |
| Données toxiques | Comportement dangereux | Texte haineux → modèle toxique |
Cas réel #1 : LAION-5B et Stable Diffusion
Le contexte :
- LAION-5B = dataset de 5 milliards de paires image-texte
- Utilisé pour entraîner Stable Diffusion
- Collecté automatiquement depuis le web
Les problèmes découverts :
| Problème | Détails |
|---|---|
| Contenu illégal (CSAM) | Images d'abus sur mineurs dans le dataset |
| Millions de duplicatas | Même image présente des milliers de fois |
| Descriptions incorrectes | "Photo de chat" associée à une image de voiture |
| Contenu toxique | Images violentes, pornographiques, haineuses |
Conséquences :
- Dataset retiré temporairement
- Mois de travail de nettoyage
- Problèmes légaux pour les utilisateurs
- Stable Diffusion génère parfois du contenu problématique
⚠️ Leçon : Un dataset mal curé peut détruire un projet, même avec des milliards de données.
Cas réel #2 : Biais dans les systèmes de reconnaissance faciale
Le contexte :
- Systèmes de reconnaissance faciale déployés par la police
- Entraînés sur des datasets majoritairement composés de visages blancs
Les problèmes :
┌─────────────────────────────────────────────────────────────────┐
│ TAUX D'ERREUR PAR GROUPE DÉMOGRAPHIQUE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Hommes blancs ██░░░░░░░░░░░░░░░░░░░░░░░░ 0.8% │
│ Femmes blanches ████░░░░░░░░░░░░░░░░░░░░░░ 1.5% │
│ Hommes noirs ████████████░░░░░░░░░░░░░░ 5.0% │
│ Femmes noires ██████████████████████████ 34.7% ← !!! │
│ │
│ Source: Gender Shades (MIT Media Lab, 2018) │
│ │
└─────────────────────────────────────────────────────────────────┘
Conséquences réelles :
- Arrestations injustifiées
- Discrimination systémique amplifiée par la technologie
- Procès et interdictions dans certaines villes
⚠️ Leçon : Le biais dans les données devient du biais dans le modèle. Le DE a une responsabilité éthique.
1.5 Le rôle du Data Engineer dans une équipe IA
Qui fait quoi ?
┌─────────────────────────────────────────────────────────────────────────────┐
│ ÉQUIPE IA TYPIQUE │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ DATA ENGINEER DATA SCIENTIST ML ENGINEER │
│ ───────────── ────────────── ─────────── │
│ │
│ • Collecte • Exploration • Entraînement │
│ • Stockage • Feature engineering • Optimisation │
│ • Transformation • Expérimentation • Déploiement │
│ • Qualité • Évaluation • Monitoring │
│ • Pipelines • Sélection modèle • Scaling │
│ │
│ "Je prépare les données" "Je trouve le modèle" "Je le mets en prod" │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
Les responsabilités du Data Engineer pour l'IA
| Tâche | Description | Impact |
|---|---|---|
| Collecter | Scraping, APIs, partenariats | Données disponibles |
| Stocker | Data lakes, object storage | Accès rapide et scalable |
| Transformer | Nettoyage, preprocessing | Données utilisables |
| Valider | Quality checks, tests | Pas de garbage in |
| Servir | Formats optimisés pour training | Training efficace |
| Versionner | Tracer les changements | Reproductibilité |
| Automatiser | Pipelines, orchestration | Scalabilité |
Le cycle de vie des données pour l'IA
┌─────────────────────────────────────────────────────────────────────────────┐
│ CYCLE DE VIE D'UN PROJET IA │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ COLLECTER│───▶│ STOCKER │───▶│TRANSFORMER───▶│ SERVIR │ │
│ │ │ │ │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │ │ │
│ ┌────┴───────────────┴───────────────┴───────────────┴────┐ │
│ │ DATA ENGINEER │ │
│ │ Pipelines • Qualité • Scalabilité • Monitoring │ │
│ └─────────────────────────────┬───────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ ENTRAÎNER│───▶│ ÉVALUER │───▶│ DÉPLOYER │───▶│SURVEILLER│ │
│ │ │ │ │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ ML ENGINEER / DATA SCIENTIST │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
💡 Tu n'as pas besoin de savoir entraîner un modèle. Ton job, c'est de fournir des données parfaites à ceux qui le font.
1.6 Le parcours et la stack technique
Les outils que tu vas maîtriser
| Catégorie | Outil | Pourquoi cet outil |
|---|---|---|
| Stockage | MinIO | Compatible S3, gratuit, local ou cloud |
| Formats | Parquet, WebDataset | Standards industrie pour ML |
| Cataloguing | DuckDB | SQL sur fichiers, léger, rapide |
| Processing | Spark | Distribué, scalable, standard |
| Validation | Pydantic, Pandera | Schema enforcement |
| Embeddings | CLIP | État de l'art, open source |
| Vector DB | Chroma | Simple, efficace, local |
| Orchestration | Airflow | Standard industrie, tu le connais déjà |
| Versioning | DVC | Git pour les données |
| Tracking | MLflow | Traçabilité des expériences |
| Labelling | Label Studio | Human-in-the-loop |
Architecture cible du module
┌─────────────────────────────────────────────────────────────────────────────┐
│ ARCHITECTURE DU MODULE │
└─────────────────────────────────────────────────────────────────────────────┘
SOURCES PROCESSING SERVING
───────── ──────────── ─────────
┌─────────────┐ ┌──────────────────┐ ┌────────────────┐
│ Local │ │ │ │ │
│ Files │─────────────▶│ Spark + MinIO │────────▶│ Parquet │
└─────────────┘ │ │ │ (métadonnées) │
│ ┌────────────┐ │ └────────────────┘
┌─────────────┐ │ │ Validation │ │ │
│ APIs │─────────────▶│ │ (Pydantic) │ │ ▼
│ (HF, etc) │ │ └────────────┘ │ ┌────────────────┐
└─────────────┘ │ │ │ WebDataset │
│ ┌────────────┐ │ │ (training) │
┌─────────────┐ │ │ Enrichment │ │ └────────────────┘
│ Web │─────────────▶│ │ (CLIP) │ │ │
│ Scraping │ │ └────────────┘ │ ▼
└─────────────┘ │ │ ┌────────────────┐
└──────────────────┘ │ TRAINING │
│ │ (PyTorch) │
▼ └────────────────┘
┌──────────────────┐
│ Airflow │
│ (orchestration) │
└──────────────────┘
│
┌────────┴────────┐
▼ ▼
┌──────────┐ ┌──────────┐
│ DVC │ │ MLflow │
│(version) │ │(tracking)│
└──────────┘ └──────────┘
Environnement de travail : tout en Docker
Pourquoi Docker ?
| Avantage | Description |
|---|---|
| Reproductibilité | Même environnement pour tout le monde |
| Isolation | Pas de pollution de ton système |
| Proche de la prod | C'est comme ça en entreprise |
| Facile à nettoyer | docker-compose down -v et c'est fini |
Ce dont tu as besoin :
- Docker Desktop (Windows/Mac) ou Docker Engine (Linux)
- 8 Go de RAM minimum (16 Go recommandé)
- 20 Go d'espace disque
- GPU optionnel (utile pour CLIP, mais pas obligatoire)
pythonVoir le code
# Vérification de ton environnement
import sys
import subprocess
def check_environment():
"""Vérifie que l'environnement est prêt pour le module."""
print("🔍 Vérification de l'environnement")
print("=" * 50)
# Python
py_version = sys.version_info
py_ok = py_version >= (3, 9)
print(f"{'✅' if py_ok else '❌'} Python >= 3.9: {py_version.major}.{py_version.minor}.{py_version.micro}")
# Docker
try:
result = subprocess.run(["docker", "--version"], capture_output=True, text=True)
docker_ok = result.returncode == 0
version = result.stdout.strip() if docker_ok else "Non trouvé"
print(f"{'✅' if docker_ok else '❌'} Docker: {version}")
except FileNotFoundError:
print("❌ Docker: Non installé")
docker_ok = False
# Docker Compose
try:
result = subprocess.run(["docker", "compose", "version"], capture_output=True, text=True)
compose_ok = result.returncode == 0
version = result.stdout.strip() if compose_ok else "Non trouvé"
print(f"{'✅' if compose_ok else '❌'} Docker Compose: {version}")
except:
print("❌ Docker Compose: Non trouvé")
compose_ok = False
print("=" * 50)
if py_ok and docker_ok:
print("\n🎉 Tu es prêt pour le module !")
else:
print("\n⚠️ Installe les éléments manquants avant de continuer.")
print(" Docker: https://www.docker.com/products/docker-desktop/")
check_environment()🎯 Checkpoint — Quiz
Teste tes connaissances ! Réponds aux questions, puis déroule pour voir les réponses.
Question 1 : Qu'est-ce que l'approche Data-Centric AI ?
A) On améliore le modèle en gardant les données fixes
B) On améliore les données en gardant le modèle fixe
C) On utilise uniquement des données structurées
D) On entraîne le modèle sans données
📖 Voir la réponse
Réponse : B
L'approche Data-Centric considère que les modèles actuels sont déjà très bons. Ce qui fait la différence, c'est la qualité des données.
- Model-Centric (ancien) : On fixe les données, on améliore le modèle
- Data-Centric (nouveau) : On fixe le modèle, on améliore les données
Andrew Ng : "La donnée est le nouveau code"
Question 2 : Quel est le ratio temps données vs temps modèle dans un projet IA ?
A) 20% données, 80% modèle
B) 50% données, 50% modèle
C) 80% données, 20% modèle
D) 100% modèle, 0% données
📖 Voir la réponse
Réponse : C
Selon l'étude CrowdFlower (2016), les Data Scientists passent 80% de leur temps sur les données :
- Collecte
- Nettoyage
- Transformation
- Validation
Et seulement 20% sur le modèle (architecture, entraînement, évaluation).
Question 3 : C'est quoi le "training" d'un modèle ?
A) Télécharger le modèle depuis internet
B) Ajuster les poids du modèle en comparant ses prédictions aux labels corrects
C) Compresser le modèle pour qu'il soit plus rapide
D) Convertir le modèle en API
📖 Voir la réponse
Réponse : B
Le training est un cycle répété des millions de fois :
- Forward : Image → Modèle → Prédiction
- Loss : Comparer prédiction vs label → Erreur
- Backward : Calculer comment corriger (gradients)
- Update : Ajuster les poids du modèle
Le modèle "apprend" en réduisant son erreur à chaque itération.
Question 4 : Qu'est-ce qu'un "batch" en training ?
A) Une erreur dans le code
B) Un groupe d'images traitées ensemble
C) Le fichier de sauvegarde du modèle
D) La version du dataset
📖 Voir la réponse
Réponse : B
Au lieu de traiter les images une par une (lent), on les regroupe en batches (ex: 32 images).
Avantages :
- Utilise le GPU à 100%
- Gradients plus stables
- Training plus rapide
C'est pour ça qu'on a besoin d'images de taille uniforme (pour faire des batches).
Question 5 : "Garbage In, Garbage Out" — que se passe-t-il si on entraîne avec des labels incorrects ?
A) Le modèle corrige automatiquement les erreurs
B) Le modèle apprend les mauvaises associations
C) Le modèle refuse de s'entraîner
D) Rien, ça n'a pas d'impact
📖 Voir la réponse
Réponse : B
Le modèle apprend exactement ce qu'on lui montre. Si tu labels un chien comme "chat", il apprendra que ce chien est un chat.
Exemple réel : LAION-5B contenait des millions d'images mal décrites → les modèles entraînés dessus reproduisaient ces erreurs.
Question 6 : Quelle est la différence entre Data Engineer et Data Scientist ?
A) C'est le même métier
B) Le DE prépare les données, le DS explore et modélise
C) Le DS prépare les données, le DE modélise
D) Le DE travaille uniquement avec Excel
📖 Voir la réponse
Réponse : B
| Rôle | Responsabilité | Phrase clé |
|---|---|---|
| Data Engineer | Collecte, stockage, transformation, qualité | "Je prépare les données" |
| Data Scientist | Exploration, feature engineering, modélisation | "Je trouve le bon modèle" |
| ML Engineer | Entraînement, déploiement, monitoring | "Je le mets en production" |
➡️ Prochaine étape
Module 2 : Stocker les données
Tu vas :
- Installer MinIO en local avec Docker
- Créer ton premier bucket et uploader des fichiers
- Découvrir les formats Parquet et WebDataset
- Construire un catalogue de métadonnées avec DuckDB
Module Data Engineering for AI — From Zero to Hero Bootcamp