Préparer les données et séparer l'entraînement du test

Avant que le prix du transport soit calculé, tu dois estimer si les frais de port d'un article Olist atteindront 20 réaux brésiliens (BRL). Tu disposes du poids et du volume du produit. Si le modèle apprend aussi sur les articles qui servent à le tester, son résultat ne décrit plus sa réaction face à un article inédit.

Cette expérience te permet d'observer quelles lignes servent à apprendre et lesquelles servent au test. Elle entraîne un modèle, sans décider à elle seule s'il est utile au métier : il faudrait aussi examiner les erreurs et leurs conséquences.

Observer avant de choisir les colonnes

Télécharge fret_olist.csv et modele_fret.py. Si un lien affiche le texte du fichier, fais un clic droit sur le lien puis choisis « Enregistrer le lien sous… ». Garde les extensions .csv et .py, sans ajouter .txt.

Place les deux fichiers dans le même dossier. Le script ne demande aucun paquet externe, mais il requiert Python 3.9 ou une version plus récente. Sous Windows, ouvre ce dossier dans PowerShell et lance :

py modele_fret.py observer

Si la commande py n'existe pas mais que python fonctionne dans ton terminal, remplace py par python dans toute la fiche.

Avant de lire la suite, réponds à trois questions à partir de la sortie :

quelle colonne est la cible à prédire ?
quelles colonnes pourraient être connues avant la cotation du fret ?
combien de lignes appartiennent à chaque valeur de la cible ?

Tu dois voir 80 lignes : 40 avec fret_eleve = 0 et 40 avec fret_eleve = 1. Chaque ligne représente un article de commande, identifié par le couple order_id, order_item_id dans le CSV. L'échantillon a été équilibré exprès pour l'exercice ; il ne mesure donc pas la fréquence réelle du fret élevé chez Olist. Ces deux colonnes identifient les lignes ; elles ne sont jamais données au modèle comme variables d'entrée.

La cible est la réponse que le modèle apprend à prédire. Ici, fret_eleve vaut 1 quand le fret réel atteint 20 BRL, 0 sinon. Une variable d'entrée est une information donnée au modèle pour produire cette prédiction. Le poids et le volume sont les deux candidates.

Le montant réel du fret serait une fuite de données : cette information permet de reconstruire directement la cible, alors qu'elle n'est pas disponible au moment annoncé pour la prédiction. Un score obtenu avec elle ne répondrait pas au problème posé.

Réserver des lignes inédites

Ouvre modele_fret.py et repère la fonction separer. Elle mélange séparément les deux classes avec une graine fixe, puis réserve huit lignes de chaque classe au test.

Le script refuse une cible différente de 0 ou 1, ainsi qu'une source qui ne laisse aucune ligne d'une classe pour l'entraînement après ce prélèvement. Avec huit lignes réservées au test, il faut donc au moins neuf lignes de chaque classe pour exécuter cet exemple. Ce minimum empêche un ensemble privé d'une classe ; il ne garantit pas qu'un échantillon suffit pour un projet réel. Si le fichier fourni déclenche une de ces erreurs, compare-le à la copie reçue avant de modifier une valeur ou le nombre de lignes de test.

L'ensemble d'entraînement sert à choisir les règles du modèle. L'ensemble de test reste à l'écart pendant ce choix et sert ensuite à observer le modèle sur des lignes inédites. La graine fixe le tirage aléatoire pour obtenir la même séparation lors de deux exécutions.

Avant de lancer l'entraînement, prédis les trois valeurs suivantes : nombre de lignes d'entraînement, nombre de lignes de test et nombre de lignes présentes dans les deux ensembles.

py modele_fret.py

Tu dois obtenir 64 lignes d'entraînement, 16 de test, un chevauchement nul et une union de 80 clés article. Vérifie aussi que 64 + 16 redonne les 80 lignes observées. Ces contrôles portent sur les couples order_id, order_item_id et détectent une ligne perdue ou une même clé placée dans deux ensembles.

La règle de travail est : séparer d'abord, appeler entrainer uniquement avec l'ensemble d'entraînement, puis calculer la justesse du test sans réentraîner. La documentation de scikit-learn donne la même règle : aucune opération fit ne doit apprendre sur le test. Une justesse est la part de prédictions correctes ; elle sert ici seulement à vérifier que les deux ensembles passent dans le programme. Son interprétation métier vient plus tard.

Lire le modèle réellement appris

Le script entraîne un arbre de décision à une coupure : il essaie plusieurs seuils sur les variables autorisées et conserve celui qui classe le plus de lignes d'entraînement correctement. Le seuil affiché n'est donc pas écrit à l'avance dans le code.

Dans la sortie, lis la ligne Modèle appris. Écris-la en français sous cette forme :

Le modèle a choisi la colonne ..., le seuil ..., puis prédit un fret élevé lorsque ...

Cherche ensuite les deux appels à justesse. Le premier reçoit entrainement, le second reçoit test. Si tu vois entrainer(test) ou un appel qui choisit le seuil avant la séparation, arrête : le test a participé à l'apprentissage.

Provoquer une fuite sur une copie

Duplique modele_fret.py sous le nom modele_fret_fuite.py. Ne modifie pas le script original. Dans la copie seulement, remplace :

modele = entrainer(entrainement)

par :

modele = entrainer(entrainement + test)

Avant de lancer la copie, prédis ce qui changera parmi les deux effectifs, le chevauchement affiché, le seuil appris et les deux justesses. Exécute ensuite py modele_fret_fuite.py et note la comparaison réelle avec ta première sortie.

Les tailles et le chevauchement affichés restent identiques sur ce jeu : ils décrivent les ensembles construits par separer, pas l'argument réellement passé à entrainer. Le seuil et la justesse du test changent ici. Cela ne prouve pas qu'une fuite améliore toujours un score ; cela prouve que le test a participé au choix du modèle sans que le contrôle de chevauchement le signale.

Supprime la copie, puis relance le script original et vérifie que sa sortie retrouve la première. Cette restauration protège le fichier de travail, mais elle ne rend pas le test inédit : tu as déjà consulté son résultat pendant la démonstration. N'utilise donc pas cette comparaison pour choisir un modèle.

Ajouter le volume, modification guidée

Dans le haut du script, remplace :

COLONNES_ENTREE = ["poids_g"]

par :

COLONNES_ENTREE = ["poids_g", "volume_cm3"]

Avant d'exécuter, prédis ce qui peut changer parmi la taille des ensembles, la colonne choisie, le seuil appris et la définition de la cible. Puis relance le script et compare à ta prédiction. Cette comparaison de deux configurations est prévue pour observer le mécanisme ; elle ne sert pas à retenir celle qui obtient le meilleur score de test.

Pour vérifier ta modification : les effectifs et le chevauchement doivent rester identiques. La colonne ou le seuil peuvent changer, car l'entraînement dispose d'une candidate supplémentaire. La cible ne change pas.

Si plusieurs variables, seuils ou modèles sont réellement en concurrence, choisis-les avec une validation interne à l'ensemble d'entraînement. Une fois que tu as lu le score du test pour guider un choix, ce test n'est plus une évaluation finale neuve : réserve alors un autre ensemble, encore jamais consulté, pour la mesure finale.

Tu peux demander à ChatGPT d'expliquer une ligne du script, par exemple :

Dans cette fonction Python, montre précisément quelles lignes sont utilisées pour choisir le seuil. Ne réécris pas le programme. Donne-moi ensuite un contrôle que je peux exécuter pour vérifier ta lecture.

Compare sa réponse aux arguments réellement passés à entrainer et aux trois effectifs affichés. Une explication plausible ne remplace pas cette lecture.

Transfert autonome

Une équipe veut maintenant prédire un retour produit avant l'expédition. Elle propose les colonnes suivantes : catégorie, poids, ville du client, commentaire du retour et remboursement versé.

Sans modifier le script, produis une note de préparation d'une page :

définis la cible et le moment exact de la prédiction ;
classe chaque colonne en disponible ou indisponible à ce moment, avec ta raison ;
nomme les colonnes que tu conserverais comme entrées ;
décris l'ordre des opérations, depuis les lignes brutes jusqu'au premier calcul sur le test ;
propose une clé stable et décris les contrôles à faire quand les données seront disponibles : unicité de cette clé, absence de clé commune entre entraînement et test, puis union égale aux clés des données préparées ;
indique quelle partie des données l'appel d'entraînement devra recevoir et comment tu vérifieras qu'il ne reçoit jamais le test.

Ce scénario ne fournit ni fichier de retours ni script à exécuter. Ta note prépare les contrôles et leurs résultats attendus ; elle ne doit pas les présenter comme réalisés.

Le commentaire du retour et le remboursement sont créés après le moment de prédiction annoncé. Si tu les gardes, ta note doit signaler que le problème doit être reformulé ; elle ne peut pas les déclarer disponibles par commodité.

Sources

Requête d'extraction du jeu de 80 articles : elle sélectionne dans Olist 40 articles de chaque classe de façon reproductible, puis retire le montant réel du fret du fichier d'apprentissage.
Scikit-learn, pièges courants et fuite de données : séparer avant tout apprentissage de préparation et ne jamais appeler fit sur le test.
Scikit-learn, train_test_split : rôle de la taille de test, de la graine et de la stratification.
Scikit-learn, régression logistique : exemple d'un modèle de classification réellement ajusté ; le script de l'exercice utilise un arbre plus petit pour rester exécutable sans dépendance.