La data science tire de données une réponse fiable à une question précise. Le machine learning (apprentissage automatique) en est l'outil de prédiction : au lieu d'écrire les règles, tu montres à un algorithme des exemples dont tu connais la réponse, et il ajuste un modèle qui répond sur des cas nouveaux. Exemple : nourri de milliers de mails déjà triés en « spam » ou « normal », le modèle apprend à trier le suivant. La méthode tient en quatre gestes : préparer les données, les couper en jeu d'entraînement et jeu de test, entraîner sur le premier, juger sur le second.
Apprendre à partir d'exemples
Pense à tes révisions sur des annales corrigées : tu fais l'exercice, puis tu compares au corrigé pour ajuster ta méthode. L'apprentissage supervisé marche pareil. Chaque exemple contient des entrées, notées $x$, et la bonne réponse $y$, appelée étiquette. Le modèle compare sa prédiction $\hat{y}$ à $y$ et corrige ses paramètres pour réduire l'écart.
Un modèle très simple estime le loyer d'un studio à partir de sa surface : $\hat{y} = ax + b$. Apprendre, c'est trouver les valeurs de $a$ et $b$ qui rendent l'erreur la plus petite sur les studios connus. Pour un nombre, on la mesure souvent par l'erreur quadratique moyenne (MSE) sur $n$ exemples :
$$\text{MSE} = \frac{1}{n}\sum_{i=1}^{n}\left(y_i - \hat{y}_i\right)^2$$
Le carré empêche les écarts positifs et négatifs de s'annuler, et punit plus fort les gros écarts.
La classification prédit une catégorie (spam ou non), la régression un nombre (un loyer). Sans étiquettes, l'apprentissage est dit non supervisé : l'algorithme cherche seul des groupes qui se ressemblent, par exemple des profils de clients, et c'est le partitionnement (clustering). L'apprentissage par renforcement, par essais et récompenses, forme une troisième famille.
Piège classique : une réponse écrite en chiffres n'est pas forcément un nombre. Prédire le département d'un client (59, 69 ou 75) est une classification : la « moyenne » de 59 et 75 ne veut rien dire.
Préparer les données
Les cases vides se traitent en supprimant les lignes concernées si elles sont rares, sinon en les remplaçant par la médiane de leur colonne : on dit imputer. Les valeurs absurdes, comme un âge de 250 ans, sautent aux yeux sur un histogramme ; les doublons se suppriment.
Une variable catégorielle, comme la ville, doit devenir des nombres. Le codage one-hot crée une colonne par ville, remplie de 0 et de 1, sans inventer d'ordre entre Lille et Lyon. Une surface en m² et un revenu en euros n'ont pas le même ordre de grandeur, ce qui gêne de nombreux modèles. La standardisation ramène chaque colonne à une moyenne de 0 et un écart type de 1 avec $z = \dfrac{x - \mu}{\sigma}$, où $\mu$ est la moyenne de la colonne et $\sigma$ son écart type.
Piège classique : standardiser tout le tableau, puis le couper en entraînement et test. La moyenne et l'écart type intègrent alors le jeu de test : c'est une fuite de données, et le score devient trop optimiste. La règle (documentation de scikit-learn) : couper d'abord, ajuster sur l'entraînement seul, appliquer au test.
Entraînement, test et surapprentissage
Noter un modèle sur ses exemples d'entraînement, c'est noter un élève sur des exercices dont il connaît le corrigé par cœur. On met donc de côté une partie des données, par exemple 20 %, que le modèle ne voit pas pendant l'apprentissage : le jeu de test. Son score sur ce jeu estime ce qu'il fera face à des données nouvelles.
Le surapprentissage (overfitting) guette le modèle qui colle trop à ses exemples, bruit compris (les variations dues au hasard) : il les récite sans faute et se trompe sur les cas nouveaux. Son signe : un score excellent à l'entraînement, nettement plus bas au test. À l'inverse, un modèle trop simple rate même ses exemples : c'est le sous-apprentissage.
Pour réduire le surapprentissage, simplifie le modèle ou ajoute des exemples. Pour comparer des réglages, utilise la validation croisée : l'entraînement est coupé en blocs, chacun sert d'évaluation à tour de rôle, et on fait la moyenne des scores. Le jeu de test, lui, ne sert qu'une fois, à la fin : s'il t'aide à régler le modèle, il ne mesure plus rien.
Évaluer au-delà de l'accuracy
Piège classique : l'accuracy (exactitude), la part de bonnes réponses, trompe dès qu'une classe est rare. Sur 1 000 transactions dont 10 frauduleuses, un modèle qui répond toujours « pas de fraude » obtient 99 % d'accuracy sans détecter une seule fraude.
On appelle positive la classe recherchée, ici la fraude, et on range les prédictions dans une matrice de confusion : vrais positifs (VP, fraudes détectées), faux positifs (FP, clients honnêtes bloqués), faux négatifs (FN, fraudes ratées) et vrais négatifs (VN).
Formule :
$$\text{précision} = \frac{VP}{VP + FP} \qquad \text{rappel} = \frac{VP}{VP + FN}$$
$$F_1 = \frac{2 \times \text{précision} \times \text{rappel}}{\text{précision} + \text{rappel}}$$
La précision dit quelle part des alertes est juste, le rappel quelle part des vrais cas est trouvée, et le $F_1$, leur moyenne harmonique, ne monte que si les deux sont bons (documentation de scikit-learn). Le modèle paresseux de la fraude a un rappel de $\dfrac{0}{0 + 10} = 0$.
Le bon choix dépend du coût de l'erreur. En dépistage médical, rater un malade coûte cher : on vise le rappel. Pour un filtre anti-spam, jeter un vrai mail agace : on soigne la précision.
Biais et enjeux éthiques
Un modèle apprend ce que contiennent ses données, injustices comprises. Entraîné sur un historique de recrutement qui favorisait un profil, il reproduira cette préférence avec l'air neutre d'un calcul. Un groupe peu présent dans l'entraînement risque aussi de subir plus d'erreurs. Compare donc les erreurs groupe par groupe, pas seulement le score global.
Pour les données personnelles, l'article 22 du règlement général sur la protection des données (RGPD) donne à chacun le droit de ne pas faire l'objet d'une décision fondée exclusivement sur un traitement automatisé qui produit des effets juridiques à son égard ou l'affecte de manière significative, sauf exceptions encadrées (texte publié par la CNIL).
Un premier modèle avec scikit-learn
Dans scikit-learn, bibliothèque Python de machine learning, les modèles suivent tous la même logique : fit pour entraîner, predict pour prédire. Ce code entraîne un classifieur sur un jeu fourni avec la bibliothèque : 569 tumeurs du sein décrites par 30 mesures, étiquetées maligne (classe 0) ou bénigne (classe 1).
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=0)
modele = make_pipeline(StandardScaler(), LogisticRegression())
modele.fit(X_train, y_train)
print(classification_report(y_test, modele.predict(X_test)))La régression logistique, malgré son nom, sert à classer : elle calcule la probabilité qu'un exemple appartienne à une classe. stratify=y garde la même part de tumeurs malignes dans les deux jeux, et random_state=0 rend le découpage reproductible. Le pipeline enchaîne standardisation et modèle : la moyenne et l'écart type sont calculés pendant fit, donc sur l'entraînement seul, sans fuite de données.
Le rapport donne précision, rappel et $F_1$ pour chaque classe. Lis d'abord le rappel de la classe 0, la part des tumeurs malignes trouvées : en rater une est l'erreur la plus grave.
Exercices corrigés
Exercice 1 : Un modèle estime le loyer mensuel de quatre studios (données fictives). Loyers réels : 520, 480, 610 et 450 €. Prédictions : 500, 500, 580 et 470 €. Calcule la MSE, puis la RMSE, sa racine carrée.
Correction :
Les écarts $y_i - \hat{y}_i$ valent $20$, $-20$, $30$ et $-20$ €. Leurs carrés font $400 + 400 + 900 + 400 = 2\,100$.
Donc $\text{MSE} = \dfrac{2\,100}{4} = 525$ €² et $\text{RMSE} = \sqrt{525} \approx 22{,}9$ €.
L'erreur typique est d'environ 23 € par studio, alors que la MSE, en euros au carré, se lit mal.
Exercice 2 : Un modèle de dépistage est testé sur 200 patients, dont 20 malades (données fictives). Il en signale 25 comme malades, dont 16 le sont vraiment. Calcule l'accuracy, la précision, le rappel et le $F_1$, puis dis ce qu'il faut améliorer en priorité.
Correction :
On a $VP = 16$, $FP = 25 - 16 = 9$, $FN = 20 - 16 = 4$ et $VN = 200 - 16 - 9 - 4 = 171$.
Accuracy : $\dfrac{16 + 171}{200} = 0{,}935$, soit 93,5 %. Précision : $\dfrac{16}{25} = 0{,}64$. Rappel : $\dfrac{16}{20} = 0{,}8$. Enfin $F_1 = \dfrac{2 \times 0{,}64 \times 0{,}8}{0{,}64 + 0{,}8} = \dfrac{1{,}024}{1{,}44} \approx 0{,}71$.
Malgré 93,5 % d'accuracy, 4 malades sur 20 passent à travers : pour un dépistage, c'est le rappel qu'il faut améliorer d'abord.
Exercice 3 : Léa entraîne un modèle très complexe : 100 % de bonnes réponses sur l'entraînement, 71 % sur le test. Avant de couper ses données, elle avait standardisé tout le tableau. Trouve les deux problèmes et ce qu'elle doit changer.
Correction :
L'écart entre 100 % et 71 % signe un surapprentissage : elle doit simplifier le modèle ou ajouter des données.
Standardiser avant de couper crée une fuite de données : ses 71 % sont peut-être trop optimistes. Elle doit couper d'abord, puis tout ajuster dans un pipeline, sur l'entraînement seul.
À retenir
À retenir :
- Classification pour une catégorie, régression pour un nombre, non supervisé sans étiquettes.
- Couper en entraînement et test avant toute transformation ; le test ne sert qu'à juger.
- Excellent à l'entraînement, faible au test : surapprentissage.
- Classe rare : l'accuracy trompe, regarde précision, rappel et $F_1$.
- Un modèle reproduit les biais de ses données.
Sources
- Documentation de scikit-learn : fuite de données, mesures d'évaluation, jeu de données sur le cancer du sein.
- Règlement général sur la protection des données, article 22 : texte publié par la CNIL.