Comparer deux modèles avant d'ouvrir le test

Tu veux prévoir si les frais de port d'un article Olist atteindront 20 BRL à partir de son poids. Deux modèles donnent des réponses différentes. Lire leur résultat sur le test puis retenir le meilleur transformerait ce test en outil de choix. Il ne mesurerait plus une décision prise sans connaître ses lignes.

Cette expérience réutilise exprès le petit échantillon pédagogique de Préparer les données et séparer l'entraînement du test. Elle ajoute un ensemble de validation, c'est-à-dire des lignes réservées au choix entre des modèles déjà entraînés. La commande de comparaison n'affiche pas le score du test avant que ce choix soit terminé. Comme ces lignes ont déjà servi dans la fiche précédente, elles ne forment pas un test inédit à l'échelle du parcours : le protocole devra être repris sur des données encore intactes dans un projet.

Exécuter l'expérience sans ouvrir le test

Télécharge dans un même dossier fret_comparaison.csv et comparer_modeles.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. Le script demande Python 3.9 ou une version plus récente et aucun paquet externe. Dans PowerShell, lance :

py comparer_modeles.py observer

Si py n'existe pas mais que python fonctionne, remplace py par python dans les commandes.

La source contient 80 articles, répartis exprès en 40 frets sous le seuil et 40 frets au seuil ou au-dessus. Cet équilibre sert l'exercice ; il ne décrit pas la fréquence réelle chez Olist. Chaque article est identifié par le couple order_id, order_item_id, qui ne sert jamais de variable au modèle. Chaque clé va dans un seul ensemble : 48 pour l'entraînement, 16 pour la validation et 16 pour le test. Les trois chevauchements affichés valent zéro. L'union des trois ensembles retrouve les 80 clés de la source.

Si tu essaies un autre fichier, le script exige au moins 17 lignes par classe : huit pour le test, huit pour la validation et au moins une pour l'entraînement. L'entraînement doit aussi contenir au moins autant de lignes que le nombre de voisins demandé, et deux poids différents pour apprendre une coupure. Le script signale le contrôle qui échoue au lieu de comparer des candidats inexécutables. Ces minima rendent cet exemple calculable ; ils ne prouvent pas qu'un échantillon suffit pour mesurer une performance métier.

Les deux modèles utilisent seulement poids_g :

l'arbre à une coupure apprend un seuil et donne une classe de chaque côté ;
les trois voisins cherchent les trois poids d'entraînement les plus proches et prennent leur classe majoritaire.

Avant de comparer les scores, prends un nouvel article de 1 250 g dont le fret réel est encore inconnu. Parmi les 48 lignes d'entraînement, ses trois voisines les plus proches sont ci-dessous. La classe 1 signifie que le fret atteint au moins 20 BRL ; la classe 0 signifie qu'il reste sous 20 BRL.

Poids connu	Distance à 1 250 g	Classe connue
1 300 g	50 g	1
1 300 g	50 g	1
1 182 g	68 g	0

Cache la suite et calcule le vote : quelle classe les trois voisins prédisent-ils ? L'arbre a appris le seuil 2 800 g et prédit la classe 0 sous ce seuil. Quelle classe donne-t-il pour le même article ? Vérifie ensuite tes deux réponses avec les fonctions du script :

py -c "import comparer_modeles as m; e,_,_,a,*_=m.preparer(); x={'id':-1,'poids_g':1250}; print(m.predire_voisins(e,x),m.predire_arbre(a,x))"

La sortie 1 0 confirme que les voisins votent 1 par deux voix contre une, tandis que l'arbre prédit 0. Ce sont deux prédictions. La valeur réelle du nouvel article n'a pas été donnée, donc cet exemple ne permet pas de dire laquelle est correcte ni quel modèle gagnera sur les 16 lignes de validation.

Avant la commande suivante, prédis quel modèle aura la meilleure justesse de validation. La justesse est la part de prédictions correctes. La règle de choix est fixée avant les scores : la meilleure justesse gagne et, en cas d'égalité, l'arbre est retenu.

py comparer_modeles.py comparer

Le script affiche 0,625 pour l'arbre et 0,438 pour les voisins, puis retient l'arbre. Le dernier message, TEST : NON CONSULTÉ, est un contrôle : ces scores portent sur la validation. Le test ne sert ni à apprendre le seuil, ni à choisir la famille.

Demande à ChatGPT :

Suis les arguments des fonctions dans ce script. Quelles lignes choisissent le seuil, lesquelles choisissent la famille, et où le test est-il absent ?

Vérifie sa réponse dans preparer et main. Le nom d'une variable ne suffit pas : relève l'appel qui calcule chaque score.

Modifier un candidat sans toucher au test

Dans le haut du script, remplace VOISINS = 3 par VOISINS = 5. Prédis si ce changement peut modifier le score des voisins, celui de l'arbre et les trois effectifs. Relance seulement comparer.

Le nombre de voisins est un hyperparamètre : une valeur fixée avant l'entraînement qui change le fonctionnement du modèle. Tu peux le comparer sur la validation. Le score de l'arbre et les effectifs doivent rester identiques. Le score des voisins peut changer. Pour vérifier ton exécution, avec cinq voisins il passe ici à 0,500 et reste inférieur à 0,625. Note le résultat réellement obtenu, puis choisis entre l'arbre et cette nouvelle version sans lancer tester.

Ouvrir le test après le choix

Écris avant l'exécution le nom du modèle retenu et la raison : son score de validation, avec la règle prévue en cas d'égalité. Garde exactement les réglages qui ont produit cette comparaison : tester refait les calculs avec le script tel qu'il est au moment du lancement. Lance ensuite une seule fois :

py comparer_modeles.py tester

Avec le script initial, le modèle choisi est l'arbre et sa justesse finale vaut 0,688 sur 16 lignes de test. Ce nombre n'annule pas le choix si la validation était meilleure ou moins bonne. Sur un si petit échantillon équilibré, quelques lignes suffisent à déplacer fortement le score ; cette expérience ne prouve pas la performance future sur toutes les commandes Olist. Elle ne constitue pas non plus une nouvelle évaluation indépendante de la fiche de séparation, puisque les mêmes 16 lignes de test y ont déjà été observées. Les 64 autres lignes sont ici redécoupées en 48 lignes d'entraînement et 16 de validation.

Si tu changes maintenant de modèle parce que tu as vu 0,688, il faut réserver un nouveau test encore intact avant d'annoncer une nouvelle mesure finale.

Transférer la méthode à une autre prédiction

Une équipe veut comparer ces deux familles pour prévoir un retour avant expédition. Sans reprendre le code de la fiche, prépare son protocole :

définis la cible et le moment de prédiction ;
choisis une variable disponible à ce moment ;
indique quelles lignes entraînent les deux modèles ;
indique quelles lignes choisissent la famille et la valeur du nombre de voisins ;
écris la règle d'égalité avant tout score ;
précise quand le test sera ouvert et ce que l'équipe fera si son résultat déçoit.

Ton protocole est vérifiable s'il attribue un seul rôle à chaque ensemble et ne réutilise pas le même test pour choisir un nouveau réglage ou annoncer une évaluation indépendante. Tu peux examiner ses erreurs pour préparer un prochain essai, mais il faudra alors un nouveau test intact. Les types d'erreurs demandent une analyse distincte, qui n'est pas réalisée ici.

Sources

Scikit-learn, validation et test : choisir avec une validation puis réserver le test à l'évaluation finale.
Scikit-learn, voisins les plus proches : la classe est décidée à partir des voisins d'entraînement.
Scikit-learn, fuites de données : les données réservées ne participent pas à l'apprentissage.