Données d’entraînement: Validation et test
Imagine que tu prépares un examen de fin d’année. Tu as tes cours pour apprendre la théorie, des interros régulières pour vérifier que tu comprends, et l’examen final qui détermine ta note. L’IA fonctionne exactement pareil.
Un modèle de machine learning apprend sur des données d’entraînement comme toi tu études tes cours. Ensuite, on lui fait passer des interros avec les données de validation pour voir s’il progresse bien. Enfin, l’examen final se fait sur les données de test qu’il n’a jamais vues.
Cette séparation des données est absolument critique en IA. Sans ça, tu peux créer un modèle qui semble fantastique mais qui plante complètement en conditions réelles. C’est comme étudier par cœur toutes les réponses de l’examen de l’année dernière : tu peux cartonner si le prof repose exactement les mêmes questions, mais dès qu’il change un truc, c’est mort.
Le problème du “par cœur”
Tu connais ce pote qui apprend tout par cœur avant un exam ? Il cartonne sur les exercices qu’il a déjà vus mais plante complètement sur les nouveaux. C’est exactement ce qui arrive à un modèle IA si on lui donne accès à toutes nos données d’un coup. Le modèle va mémoriser les réponses au lieu de comprendre les patterns. Du coup, dès qu’il voit de nouvelles données, il crash complètement. En IA, on appelle ça l’overfitting ou sur-apprentissage.
Prenons un exemple concret. Un modèle d’IA qui diagnostique une pneumonie à partir de radiographies pulmonaires. Si on lui montres 1000 radios d’entraînement avec les diagnostics, il va peut-être mémoriser que “les radios prises à l’hôpital A avec le logo en haut à droite = pneumonie” et “les radios de l’hôpital B avec le logo en bas à gauche = normal”, simplement parce que l’hôpital A reçoit les cas graves et l’hôpital B fait de la médecine préventive. Du coup, sur de nouvelles radios d’un hôpital C, il sera complètement paumé et se basera sur la position du logo plutôt que sur les opacités pulmonaires réelles.
C’est pour ça qu’on divise nos données en trois paquets bien distincts, comme trois tiroirs séparés qu’on ouvre à des moments précis.
Les trois splits
Données d’entraînement (Training Set)
C’est le gros du dataset, généralement 80% de tes données. Le modèle passe son temps dessus, il apprend les patterns, ajuste ses paramètres internes. C’est comme réviser tes cours pendant des semaines. Le modèle va voir ces données des centaines, voire des milliers de fois. Il va ajuster ses “neurones” (si c’est un réseau de neurones) ou ses règles de décision (si c’est un arbre de décision) pour minimiser ses erreurs sur ce dataset.
Exemple : Si on a 1000 photos de chats et chiens, on en prend 800 pour l’entraînement. Le modèle va analyser ces 800 photos encore et encore, en essayant de trouver les caractéristiques qui différencient un chat d’un chien.
Données de validation (Validation Set)
Environ 15% des données. C’est les interros qu’on fait passer au modèle pendant l’entraînement. Le modèle ne s’entraîne pas dessus, mais on regarde ses performances pour voir s’il progresse bien. Pendant l’entraînement, on surveille deux courbes :
- Les performances sur les données d’entraînement (qui s’améliorent normalement)
- Les performances sur les données de validation (qui doivent aussi s’améliorer)
Si les performances sur la validation commencent à se dégrader alors que celles sur l’entraînement continuent de s’améliorer, c’est le signal d’alarme : le modèle commence à apprendre par cœur.
Exemple : Sur nos 1000 photos, on en garde 150 pour la validation. Toutes les 10 étapes d’entraînement, on teste le modèle sur ces 150 photos pour voir s’il progresse. Si au début il reconnaît 60% des animaux correctement, puis 70%, puis 75%, c’est bon signe. Si ça commence à redescendre, on arrête l’entraînement.
Données de test (Test Set)
Généralement les 5% restants. C’est sacré, on n’y touche JAMAIS pendant l’entraînement. Le modèle découvre ces données seulement à la fin, pour l’évaluation finale. Parfois cette partie du dataset n’est pas fournie publiquement, parfois on utilise un dataset complètement différent pour cette évaluation – tout ce qui compte, c’est que ce soient des données réelles, différentes de l’entraînement et proches de ce qu’on veut analyser dans la vraie vie. C’est notre seul moyen de savoir si le modèle marche vraiment sur du jamais vu. Le test set simule les conditions réelles : dans la vraie vie, ton modèle va recevoir des données qu’il n’a jamais vues, et le test set te donne une estimation honnête de ses performances futures.
Exemple : Les 50 dernières photos restent dans un dossier qu’on n’ouvre qu’à la toute fin. Une fois que le modèle est complètement entraîné et qu’on a choisi tous nos paramètres, on teste sur ces 50 photos pour avoir le verdict final.
Proportions concrètes et exemples
Sur un dataset de 1000 exemples, les proportions classiques donnent : 800 pour l’entraînement (80%), 150 pour la validation (15%), 50 pour le test (5%). Ces proportions peuvent varier selon ton contexte :
- Beaucoup de données (100 000+ exemples) : On peut se permettre 90/5/5 parce que même 5% te donnent 5000 exemples de test, largement suffisant pour une évaluation fiable.
- Peu de données (moins de 1000 exemples) : Mieux vaut 60/20/20 pour avoir assez d’exemples dans chaque split et une évaluation plus robuste.
Petits datasets – Projets étudiants et prototypes
- MNIST (chiffres manuscrits) : 60 000 images d’entraînement, 10 000 de test. Proportion 85/15, parfait pour débuter en vision par ordinateur.
- Titanic : 891 passagers. Proportion 80/20, idéal pour apprendre les bases.
Gros datasets – Industrie et recherche
- ImageNet (reconnaissance d’objets) : 14 millions d’images, 1000 classes différentes. Les entreprises utilisent 95/2.5/2.5 parce que même 2.5% donnent 350 000 images de test.
- COCO (détection d’objets) : 330 000 images avec objets annotés. Truc marrant : en 2014, ils utilisaient 80/10/10, mais en 2017 ils sont passés à 95/2.5/2.5 parce qu’ils se sont rendu compte qu’ils gaspillaient trop de données en validation au lieu de les utiliser pour entraîner.
- Common Crawl (texte web) : Des milliards de pages web pour entraîner les LLM comme ChatGPT. Proportion 99/0.5/0.5 parce qu’ils ont tellement de données.
- Sentiment140 (analyse de sentiments Twitter) : 1.6 million de tweets classés positifs/négatifs. Les boîtes qui font de l’analyse social media utilisent 90/5/5.
Plus il y a de données, plus on peut se permettre de mettre un petit pourcentage dans validation et test. Avec 10 millions d’exemples, même 1% de test donne 100 000 exemples, largement assez pour une évaluation solide.
Cas pratique: le Titanic
Prenons le fameux dataset Titanic pour voir comment ça marche en vrai. On a les infos de 891 passagers du Titanic et on veut prédire s’ils ont survécu au naufrage.
Étape 1 : Chargement et exploration des données
import pandas as pd
from sklearn.model_selection import train_test_split
# Chargement des données depuis un fichier CSV
# CSV = Comma Separated Values, un format de fichier très courant
data = pd.read_csv('/mnt/ch1/titanic.csv')
# Premier aperçu rapide
print(f"Dataset shape: {data.shape}") # Nous dit combien de lignes et colonnes
print(f"Taux de survie global: {data['Survived'].mean():.2%}") # Pourcentage de survivants
print(data.head()) # Affiche les 5 premières lignes
Le .shape donne (nombre_lignes, nombre_colonnes). Si ça affiche (891, 12), on a 891 passagers avec 12 informations chacun. Le data['Survived'].mean() calcule la moyenne de la colonne Survived. Comme cette colonne contient des 0 (mort) et des 1 (vivant), la moyenne te donne directement le taux de survie.
Étape 2 : Retirer la colonne des réponses
# X = toutes les informations sur les passagers SAUF si ils ont survécu
X = data.drop('Survived', axis=1)
# y = juste la colonne qui dit s'ils ont survécu (0 = mort, 1 = vivant)
y = data['Survived']
print(f"Infos sur les passagers: {X.shape}")
print(f"Résultats de survie: {y.shape}")
Pourquoi on fait ça ? Le modèle doit deviner si quelqu’un a survécu. Si on lui donne déjà la réponse dans les données, il va juste retenir “passager numéro 1 = survécu” au lieu d’apprendre les vrais patterns. Il ne fera pas de vraie prédiction, juste de la mémorisation bête. Le .drop('Survived', axis=1) enlève la colonne Survived du tableau. axis=1 veut dire “enlever une colonne” (axis=0 enlèverait une ligne).
Étape 3 : Séparer pour l’entraînement et le test
# On divise nos données en deux : 80% pour apprendre, 20% pour tester
X_train, X_test, y_train, y_test = train_test_split(
X, y, # Toutes nos données
test_size=0.2, # 20% pour le test
random_state=42 # Pour avoir les mêmes résultats à chaque fois
)
print(f"Données pour apprendre: {len(X_train)} passagers")
print(f"Données pour tester: {len(X_test)} passagers")
train_test_split mélange tes données et les sépare. random_state=42 fixe le mélange. Sans ça, chaque fois qu’on relance le code, on aurait des groupes différents. Avec 42 (ou n’importe quel chiffre), on aura toujours le même mélange. C’est la seed.
Étape 4 : Vérification des groupes
# Vérifions que nos groupes sont équilibrés
print("=== VÉRIFICATION ===")
print(f"Survivants dans l'entraînement: {y_train.mean():.1%}")
print(f"Survivants dans le test: {y_test.mean():.1%}")
# Vérifions aussi les tailles
total_passagers = len(X_train) + len(X_test)
print(f"\nTotal passagers: {total_passagers}")
print(f"Pour l'entraînement: {len(X_train)/total_passagers:.0%}")
print(f"Pour le test: {len(X_test)/total_passagers:.0%}")
Cette vérification est importante. Si les pourcentages de survivants sont très différents, il y a un problème. Les deux groupes doivent avoir à peu près les mêmes proportions de survivants.
Les pièges à éviter : le dataset déséquilibré
Cette vérification est importante. Si les pourcentages de survivants sont très différents, il y a un problème. Les deux groupes doivent avoir à peu près les mêmes proportions de survivants.
# ❌ PROBLÈME - Split déséquilibré
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"Survivants train: {y_train.mean():.1%}") # Pourrait être 60%
print(f"Survivants test: {y_test.mean():.1%}") # Pourrait être 25%
# Le modèle va galérer !
# ✅ SOLUTION - Équilibrer avec stratify
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
print(f"Survivants train: {y_train.mean():.1%}") # Sera ~38%
print(f"Survivants test: {y_test.mean():.1%}") # Sera ~38% aussi
stratify=y force à garder les mêmes proportions partout. Si 38% des gens ont survécu au total, on aura environ 38% de survivants dans l’entraînement ET dans le test. Une fois qu’on a fait les groupes, on n’y touches plus ! Le test set reste caché jusqu’à la fin. Si on regardes dedans pour ajuster le modèle, c’est fini, l’évaluation ne vaut plus rien.
Exercice
Le dataset /mnt/ch1/diabetes.csv provient de l’Institut National du Diabète et contient des informations sur des femmes d’au moins 21 ans d’origine amérindienne. L’objectif est de prédire si une patiente développera un diabète basé sur ses mesures diagnostiques comme la glycémie, la pression artérielle ou l’IMC.
- Commencez par ouvrir le fichier diabetes.csv et examiner sa structure. Combien de patientes contient-il ? Quelles colonnes d’informations médicales avez-vous ?
- Calculez le taux de diabète général dans la population étudiée. Ensuite, séparez les informations médicales de la colonne qui indique si la patiente a le diabète – cette colonne sera votre cible à prédire.
- Créez ensuite vos groupes d’entraînement et de test avec une proportion 80/20, en utilisant la stratification pour maintenir les mêmes proportions de diabétiques dans chaque groupe.
- Vérifiez que le taux de diabète reste identique dans vos deux groupes après la division.
En résumé
La séparation des données constitue le fondement de tout projet d’intelligence artificielle. Cette division suit un principe rigoureux : les données d’entraînement permettent au modèle d’apprendre les patterns, tandis que les données de test évaluent sa capacité de généralisation sur des exemples inédits. La proportion standard de 80/20 entre entraînement et test offre un équilibre optimal pour la plupart des projets. L’aspect critique réside dans la stratification : chaque groupe doit conserver les mêmes proportions de classes que le dataset original, garantissant ainsi une évaluation équitable. Cette approche en deux groupes constitue la base méthodologique. Les projets avancés nécessiteront l’ajout d’un troisième groupe de validation, mais cette fondation permet déjà de maîtriser les concepts essentiels de séparation et d’évaluation en machine learning.