Un premier modèle honnête sur un nouveau projet : OLS ou régression logistique, coupe figée, modèle naïf et métrique défendable

Prouver la méthode d'abord sur le modèle le plus simple

Un modèle simple sur une coupe propre dit quelque chose de vrai sur vos données, alors qu'un modèle puissant sur une coupe viciée dit seulement à quel point il a appris le vice.

L'ordre compte. Les équipes qui commencent par un gradient boosting découvrent souvent, des semaines plus tard, que la coupe fuyait ou que la métrique répondait à une question que personne ne posait. Un modèle linéaire s'ajuste vite, s'inspecte facilement et se laisse mal flatter : ses erreurs désignent les données et le montage plutôt que les réglages. Si la tuyauterie est juste pour une OLS ou une régression logistique, ajouter une forêt plus tard coûte une ligne de plus dans la comparaison ; si elle est fausse, aucun modèle ne la sauvera.

Le point de départ est le cahier des charges (scope document) écrit au premier jalon : la décision que le modèle éclaire, la question, la cible, deux métriques et un garde-fou sur ce que le modèle ne doit jamais décider seul. Tout ce qui suit en découle. Le fil rouge du cours, un score de défaut de crédit construit dans le jalon de la baseline, a déjà enseigné les trois réflexes qui se transportent : une coupe figée, une référence naïve et un seuil de décision. Le deuxième jalon les déplace sur les données de l'équipe.

Les six pièces d'un premier modèle honnête

1. Une coupe figée. Apprentissage, validation et un test qui reste scellé jusqu'au rendu final, sans que rien ne fuie de l'un à l'autre.
2. Une référence naïve. Calculée sur les seules lignes d'apprentissage, elle ignore toutes les variables.
3. Un seul modèle appris. Une OLS pour une cible continue, une régression logistique pour une cible binaire.
4. Une métrique justifiée. Une phrase la rattache à la décision écrite dans le cahier des charges.
5. Résultats de validation et limites. Le modèle contre la référence naïve, lu honnêtement, et là où il cesse de valoir.
6. La reproductibilité. Une commande reconstruit chaque chiffre depuis un clone neuf du dépôt.

Retour au sommaire.

La cible choisit le modèle, la référence et la métrique

Ajuster une régression linéaire ou logistique n'est pas une préférence : cela découle de la nature de la cible, et la référence naïve et la métrique en découlent aussi.

Lisez la cible dans le cahier des charges, et le reste suit. Une cible continue, un montant, une durée, un comptage assez grand pour être traité comme une quantité, appelle les moindres carrés ordinaires (ordinary least squares, OLS), traités dans moindres carrés et régression linéaire. Une cible binaire appelle une régression logistique (logistic regression) ajustée par maximum de vraisemblance, traitée dans maximum de vraisemblance et régression logistique.

Pour une régression, exprimez la métrique dans l'unité de la cible, parce qu'un décideur peut agir sur « on se trompe d'environ deux heures par réparation » et ne peut rien faire d'un $R^2$. Pour une cible binaire, la décision repose en général sur une probabilité et un coût, et le seuil qui minimise le coût attendu est le sujet de la fiche sur le seuil de décision. Les cibles à plusieurs classes, ordonnées ou fortement temporelles suivent le même principe, mais le choix de modélisation et sa raison entrent dans le journal de décisions (decision log) avant le premier calcul, pas après les résultats.

Retour au sommaire.

Une coupe figée qui ne peut pas fuir

Coupez les données avant tout calcul, apprenez chaque étape de prétraitement sur les seules lignes d'apprentissage, et consignez la coupe pour que personne ne la refasse en douce.

Couper d'abord, avant toute moyenne, toute imputation, tout graphique qui oriente un choix. Trois parties : le jeu d'apprentissage (training set), où le modèle apprend ; le jeu de validation (validation set), où l'on mesure et décide ; le jeu de test (test set), qui reste fermé jusqu'au rendu final. Quand les lignes sont datées, coupez par date, pour que le modèle apprenne sur le passé et soit jugé sur l'avenir, comme il servira. Quand un même client, patient ou équipement revient sur plusieurs lignes, coupez par groupe, pour qu'il ne se trouve jamais des deux côtés.

Ensuite, tout ce qui apprend des données, imputation, standardisation, encodage, sélection de variables, s'ajuste sur les seules lignes d'apprentissage. Le plus sûr est un Pipeline scikit-learn, doublé d'un test unitaire qui vérifie par exemple que la moyenne retenue par le scaler est celle de l'apprentissage. Enfin, figez : l'empreinte du fichier brut, une seule graine dans config.yaml et la liste des identifiants de chaque partie, le tout commité. C'est ce qu'on appelle une coupe figée (frozen split). L'esquisse ci-dessous écrit les trois parties une fois, puis ajuste une régression logistique qui ne voit jamais le fichier de test.

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# split.py, lancé une fois : coupe par date, trois fichiers, empreintes au journal
df = pd.read_csv("data/raw.csv", parse_dates=["decided_on"])
parts = {"train": df.decided_on < "2024-01-01",
         "valid": (df.decided_on >= "2024-01-01") & (df.decided_on < "2024-07-01"),
         "test": df.decided_on >= "2024-07-01"}
for name, mask in parts.items():
    df[mask].to_csv(f"data/{name}.csv", index=False)

# fit.py : ne lit que train et valid, toute statistique s'apprend sur train
train, valid = pd.read_csv("data/train.csv"), pd.read_csv("data/valid.csv")
prep = ColumnTransformer([
    ("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), NUM),
    ("cat", OneHotEncoder(handle_unknown="ignore"), CAT),
])
model = Pipeline([("prep", prep), ("clf", LogisticRegression(max_iter=1000))])
model.fit(train[NUM + CAT], train["y"])

Retour au sommaire.

Une référence naïve et une métrique défendable

Tout résultat a besoin d'une référence qui n'utilise aucune variable, et d'une métrique choisie à cause de la décision, sinon un beau chiffre peut ne rien vouloir dire.

Le modèle de référence naïf (naive baseline) ne regarde aucune variable. Pour une régression, il prédit pour chaque ligne la moyenne de la cible sur l'apprentissage, ou la médiane si la métrique est l'erreur absolue moyenne, puisque c'est la médiane qui la minimise. Pour une cible binaire, il prédit pour tout le monde le taux de base d'apprentissage $\pi$. Ses scores sont les chiffres à battre, et ils sont souvent plus durs à battre qu'il n'y paraît.

Un exemple chiffré avec un taux de base de 0,20

1. Score de Brier. $0{,}20 \times 0{,}80 = 0{,}16$ : un modèle dont le score de Brier (Brier score) dépasse cette valeur fait moins bien que la simple connaissance du taux de base.
2. Log-loss. $-(0{,}20 \ln 0{,}20 + 0{,}80 \ln 0{,}80) \approx 0{,}500$, le chiffre qu'une régression logistique doit faire baisser.
3. Exactitude. Répondre non pour tout le monde est juste 80 % du temps, ce qui explique pourquoi l'exactitude seule flatte un modèle inutile quand les classes sont déséquilibrées.

La métrique se justifie ensuite en une phrase qui part de la décision écrite dans le cahier des charges, jamais de l'habitude. Par exemple : « nous mesurons la log-loss parce que les planificateurs de maintenance agissent sur une probabilité, et le coût attendu au seuil retenu parce qu'une panne manquée coûte bien plus qu'une inspection inutile ». L'exactitude survit rarement à cette phrase quand les classes sont déséquilibrées. Pour une régression, la RMSE convient quand les grosses erreurs font disproportionnément mal, la MAE quand chaque unité d'erreur coûte autant.

Retour au sommaire.

Des résultats sur la validation, le test toujours scellé

Donnez le modèle contre la référence naïve sur la validation, avec une idée de l'incertitude, et gardez le test fermé pour le verdict final.

Le cœur du livrable est un petit tableau, et chacun de ses chiffres est écrit par le code dans un fichier de résultats comme metrics.json, jamais tapé à la main. Au moins deux lignes, la référence naïve et le modèle appris, et une colonne pour l'écart entre les deux. Tout se mesure sur le jeu de validation (validation set) : les scores d'apprentissage sont optimistes par construction, et ceux du jeu de test (test set), une fois regardés, ne peuvent plus servir de verdict sans biais.

import numpy as np
from sklearn.metrics import brier_score_loss, log_loss

y = valid["y"].to_numpy()
p_naive = np.full(len(y), train["y"].mean())   # taux de base d'apprentissage
p_model = model.predict_proba(valid[NUM + CAT])[:, 1]

def gap(i):  # log-loss du modèle moins log-loss de la référence naïve
    return log_loss(y[i], p_model[i], labels=[0, 1]) - log_loss(y[i], p_naive[i], labels=[0, 1])

rng = np.random.default_rng(SEED)              # l'unique graine de config.yaml
boot = [gap(rng.integers(0, len(y), len(y))) for _ in range(2000)]
print(f"Brier naïf {brier_score_loss(y, p_naive):.3f}, modèle {brier_score_loss(y, p_model):.3f}")
print(f"écart {gap(np.arange(len(y))):.3f}, intervalle à 95 % {np.percentile(boot, [2.5, 97.5]).round(3)}")

L'intervalle de l'écart vient d'un bootstrap des lignes de validation ; avec plusieurs plis ordonnés dans le temps, la dispersion entre plis rend le même service. Il répond à la première question d'un lecteur : l'amélioration dépasse-t-elle ce que le seul rééchantillonnage produirait ? Un écart de $-0{,}045$ dont l'intervalle reste nettement sous zéro est un résultat ; un écart de $-0{,}004$ dont l'intervalle chevauche zéro n'en est pas encore un.

Lire les coefficients

Un modèle linéaire mérite aussi sa place parce qu'il se lit. En OLS, $\hat\beta_j$ est la variation de la cible prédite, dans sa propre unité, quand $x_j$ augmente d'une unité, les autres variables restant fixes ; si le pipeline standardise les entrées, l'unité est un écart-type, et la note doit le dire. En régression logistique, $\beta_j$ déplace le logarithme des cotes, et $e^{\beta_j}$ est le rapport de cotes (odds ratio) : un coefficient de 0,4 par écart-type multiplie les cotes par environ 1,49. Deux précautions. Des variables corrélées se partagent le mérite, si bien qu'un signe peut s'inverser quand on ajoute une voisine. Et un coefficient décrit une association dans ces données, pas l'effet d'une intervention sur la variable.

Retour au sommaire.

Des limites écrites et une reconstruction en une commande

Les limites sont des phrases précises sur les cas où le modèle ne vaut pas, et la reproductibilité veut dire qu'une autre équipe retrouve vos chiffres exacts depuis un clone neuf, en une commande.

Les limites ne sont pas un paragraphe de courtoisie. Cinq lignes précises suffisent quand chacune apporte une information dont un décideur peut se servir.

• Population et période. Qui et quand les données décrivent, donc pour qui le modèle ne dit rien.
• La cible. Ce qu'elle mesure mal ou laisse de côté.
• Variables écartées. Ce qui a été mis de côté par crainte de fuite ou par principe, et ce que cela coûte.
• Taille de la validation. Si un écart de 0,01 peut se distinguer du bruit avec ce nombre de lignes.
• Usages interdits. Ce que le modèle ne doit jamais décider seul, repris des garde-fous du cahier des charges.

La reproductibilité (reproducibility) est une condition, pas un bonus : une autre équipe clone le dépôt, lance make reproduce dans le conteneur de développement et obtient le même metrics.json, avec une intégration continue au vert sur le dernier commit. Si les données ne peuvent pas être publiées, le README explique comment un auditeur les obtient, ou le dépôt fournit un échantillon anonymisé qui fait tourner la chaîne de bout en bout. Le lecteur trouve alors, dans un ordre prévisible, une courte note écrite (coupe et fuites, référence naïve, métrique, tableau de résultats, limites), le code et ses tests, le fichier de résultats, le cahier des charges mis à jour si le problème a bougé, et le journal avec une annexe sur l'usage des outils d'IA.

Huit vérifications avant de rendre

1. La coupe. Données hachées, une seule graine, identifiants de chaque partie commités.
2. Le pipeline. Aucune étape de prétraitement n'est ajustée en dehors.
3. Le test scellé. Une recherche dans le code montre qu'aucun script de cette étape ne lit le fichier de test.
4. La référence naïve. Sa ligne figure dans le fichier de résultats, à côté du modèle.
5. La métrique. Justifiée en une phrase qui part de la décision.
6. Les limites. Cinq, chacune assez précise pour qu'on puisse agir.
7. Le clone neuf. La reconstruction tourne depuis un dossier temporaire, pas depuis le portable de l'auteur.
8. Les responsables. Chaque partie a un responsable nommé, capable de l'expliquer.

Retour au sommaire.

Entraînement facultatif : répéter la comparaison du champion

Sur un jeu public de défaut de crédit, on peut déjà répéter la comparaison des familles de modèles que demandera le rendu final, sans aucun enjeu.

Le cours garde l'ancien sujet, plus ambitieux, comme entraînement facultatif sur le fil rouge, les données UCI Default of Credit Card Clients (Yeh et Lien, 2009) présentées dans le projet de score de défaut de crédit. C'est la répétition générale de la comparaison de modèles que le rendu final demande sur les données de l'équipe, et un bon endroit pour se tromper sans conséquence.

• Une commande de comparaison : une régression logistique L1 comme référence, une forêt aléatoire, un gradient boosting et un modèle à noyau, sur trois graines et cinq plis, hyperparamètres réglés par validation croisée imbriquée, le test laissé de côté.
• Des intervalles corrigés : les plis se recouvrent, la variance brute des scores par pli est donc trop petite, et la correction de Nadeau et Bengio ci-dessous la gonfle.
• Une règle du champion écrite avant les résultats, déposée en issue horodatée, pour que le critère ne puisse pas être choisi au vu du tableau.
• Une fiche de modèle avec un audit d'équité qui ne s'arrête pas au retrait de la colonne sensible : un test de variable relais, puis des métriques par groupe avec intervalles.
• Trois algorithmes écrits à la main, gradient boosting, kernel ridge et un EM en une dimension, chacun vérifié contre scikit-learn par un test automatique.

Avec $J = 15$ mesures et des plis de mesure quatre fois plus petits que la partie d'apprentissage, le facteur vaut $1/15 + 1/4$ au lieu de $1/15$ : la variance est multipliée par 4,75. Le verdict se lit ensuite sur la différence appariée entre un challenger et la référence : si son intervalle corrigé contient zéro, le gain n'est pas établi et le modèle le plus simple reste en place. Les méthodes de cet entraînement sont traitées dans forêts aléatoires et gradient boosting et SHAP, équité, ACP et clustering.

Retour au sommaire.

À retenir

1. Prouver la méthode d'abord sur un modèle simple : un modèle linéaire sur une coupe propre vaut plus qu'un boosting sur une coupe qui fuit.
2. La cible décide : OLS pour une quantité, régression logistique pour un oui ou un non, et la référence naïve comme la métrique découlent du même choix.
3. Couper avant tout calcul, ajuster chaque prétraitement sur l'apprentissage dans un pipeline, et figer la coupe par une empreinte, une graine et les identifiants.
4. Une référence naïve qui ignore toutes les variables est la première ligne du tableau ; avec un taux de base de 0,20, son score de Brier vaut déjà 0,16.
5. Justifier la métrique en une phrase qui part de la décision, mesurer sur la validation avec un intervalle sur l'écart, et garder le test scellé.
6. Cinq limites précises et une reconstruction en une commande depuis un clone neuf font d'un chiffre un résultat auquel un autre peut se fier.

Glossaire

moindres carrés ordinaires (ordinary least squares, OLS)

Régression linéaire dont les coefficients minimisent la somme des carrés des résidus.

régression logistique (logistic regression)

Modèle de la probabilité d'une issue binaire par une fonction linéaire du logarithme des cotes, ajusté par maximum de vraisemblance.

modèle de référence naïf (naive baseline)

Prédiction de référence qui ignore toutes les variables : moyenne, médiane ou taux de base de l'apprentissage.

fuite de données (data leakage)

Information utilisée par le modèle qui ne serait pas disponible au moment de la décision, ou qui vient des lignes d'évaluation.

coupe figée (frozen split)

Partition apprentissage, validation et test fixée une fois, consignée par une empreinte, une graine et des identifiants, jamais refaite pour améliorer un résultat.

jeu d'apprentissage (training set)

Lignes sur lesquelles le modèle et tout le prétraitement apprennent.

jeu de validation (validation set)

Lignes qui servent à mesurer les modèles et à faire des choix, distinctes de l'apprentissage.

jeu de test (test set)

Lignes gardées scellées jusqu'au verdict final, utilisées une seule fois.

score de Brier (Brier score)

Moyenne des carrés des écarts entre la probabilité prédite et l'issue observée, 0 ou 1.

log-loss

Entropie croisée moyenne, l'opposé de la log-vraisemblance moyenne des issues observées sous les probabilités prédites.

rapport de cotes (odds ratio)

Facteur qui multiplie les cotes p/(1 − p) quand une variable augmente d'une unité, l'exponentielle d'un coefficient logistique.

bootstrap

Rééchantillonnage des lignes avec remise pour estimer la variabilité d'une statistique.

reproductibilité (reproducibility)

Une autre personne obtient les mêmes chiffres avec le même code et les mêmes données, en une seule commande.

cahier des charges (scope document)

L'énoncé écrit de la décision, de la cible, des métriques et des garde-fous sur lesquels repose un projet.

journal de décisions (decision log)

Entrées datées qui consignent chaque choix, l'option écartée et la preuve qui l'appuie.

Les autres fiches du cours

Un résumé public par deck, dans l'ordre du cours.

Précédent : SHAP, équité, ACP et partitionnementSuivant : Réseaux de neurones, dérive, prédiction conforme

1. IntroductionHivers de l'IA, emploi et méthode
2. OutilsKaggle, GitHub, Python : les outils
3. Séance 1Cadrage de projet et moindres carrés
4. Séance 2Vraisemblance et régression logistique
5. Séance 3Descente de gradient, ridge et lasso
6. Séance 4Seuil de décision et ML reproductible
7. DevoirCadrer un projet ML : le cahier des charges
8. Séance 5Noyaux, SVM et arbres de décision
9. Séance 6Forêts, boosting, comparaison honnête
10. Séance 7SHAP, équité, ACP et partitionnement
11. DevoirUn modèle simple, une méthode complète
12. Séance 8Réseaux de neurones, dérive, prédiction conforme
13. DevoirUn projet de machine learning livré
14. Séance 9Soutenir un projet de machine learning
15. RéférenceProjet de score de défaut de crédit
16. RéférenceRendements boursiers : XGBoost et sentiment
17. RéférenceLe code Python de chaque modèle
18. RéférenceDeep learning, l'essentiel
19. RéférenceDonnées ouvertes et projets par secteur
20. RéférenceManuel de l'expert data et IA
21. RéférenceData engineering, SRE et cloud
22. RéférencePanorama des modèles de machine learning

Toutes les fiches, en liste de lecture

L'attention et le transformer, pas à pas

À propos de ces fiches

Écrites par l'enseignant à partir des slides du deck, comme un résumé public : les idées clés, les formules et un exemple calculé. Les exercices, leurs corrigés, les contrôles et la notation restent dans le deck, pour les élèves du cours.

Révision : 16 octobre 2026.