scikit-learn

À quoi ça sert

Dès que tu veux entraîner un modèle de machine learning sur des données tabulaires — prédire un prix, classer un email en spam, regrouper des clients par profil — scikit-learn est le point de départ par défaut. C'est l'écosystème ML classique : régression linéaire, arbres de décision, random forests, SVM, k-means, etc.

Sa grande force, c'est l'API unifiée : que tu utilises une régression linéaire ou un random forest, le code reste le même. Tu peux changer de modèle en remplaçant une seule ligne.

• Apprentissage supervisé — régression (prédire un nombre) et classification (prédire une catégorie).
• Apprentissage non supervisé — clustering (k-means, DBSCAN), réduction de dimension (PCA).
• Prétraitement — normalisation, encodage des variables catégorielles, gestion des valeurs manquantes.
• Pipelines — enchaîner prétraitement et modèle dans un seul objet, ce qui évite les fuites de données.
• Évaluation — split train/test, validation croisée, métriques (accuracy, RMSE, F1, etc.).

Un exemple d'usage

Tu as un dataset de logements (surface, nombre de pièces, quartier…) et tu veux prédire leur prix. Le workflow standard en sklearn :

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error

# 1. Charger les données
df = pd.read_csv("logements.csv")
X = df[["surface", "pieces", "age"]]
y = df["prix"]

# 2. Séparer train / test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Choisir un modèle et l'entraîner
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Prédire et évaluer
y_pred = model.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
print(f"Erreur moyenne : {mae:.0f}€")

Quatre étapes, toujours les mêmes : charger → splitter → fit → predict + évaluer. Changer de modèle ne demande de changer qu'une ligne — remplace RandomForestRegressor par LinearRegression ou GradientBoostingRegressor, et tout le reste fonctionne pareil.

How-to : installer et utiliser scikit-learn

1. Installer scikit-learn

   Comme pandas, dépendance principale (cf. UV) :

   bash Copier

   uv add scikit-learn

   En Python, l'import s'appelle sklearn (pas scikit-learn) — un piège classique :

   python Copier

   from sklearn.linear_model import LinearRegression
   from sklearn.ensemble import RandomForestClassifier

2. L'API universelle : fit, predict, score

   Tous les modèles sklearn suivent la même interface. Apprends-la une fois, elle marche partout :

   python Copier

   model = Modele(hyperparams…)
   
   model.fit(X_train, y_train)        # entraîner
   y_pred = model.predict(X_test)      # prédire
   score = model.score(X_test, y_test) # évaluer (R² ou accuracy)
   
   # Pour la classification, on a aussi les probabilités
   proba = model.predict_proba(X_test)

3. Séparer train et test

   Règle absolue : n'évalue jamais ton modèle sur les données d'entraînement. train_test_split garde une portion à l'écart pour mesurer la vraie performance.

   python Copier

   from sklearn.model_selection import train_test_split
   
   X_train, X_test, y_train, y_test = train_test_split(
       X, y,
       test_size=0.2,       # 20% pour le test
       random_state=42,    # reproductibilité
       stratify=y          # utile en classif déséquilibrée
   )

4. Choisir un modèle

   Quelques modèles à connaître pour démarrer :

   python Copier

   # Régression (prédire un nombre)
   from sklearn.linear_model import LinearRegression, Ridge
   from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
   
   # Classification (prédire une catégorie)
   from sklearn.linear_model import LogisticRegression
   from sklearn.ensemble import RandomForestClassifier
   from sklearn.svm import SVC
   from sklearn.neighbors import KNeighborsClassifier
   
   # Clustering (regrouper sans étiquettes)
   from sklearn.cluster import KMeans, DBSCAN
   
   # Réduction de dimension
   from sklearn.decomposition import PCA

   Par où commencer ?

   Pour un problème tabulaire, un RandomForest est un excellent baseline : pas de prétraitement obligatoire, peu d'hyperparamètres critiques, performances honnêtes presque partout. Si ça marche bien, essaie ensuite GradientBoosting (souvent un peu meilleur).

5. Prétraiter les données

   La plupart des modèles attendent des données numériques propres. sklearn a tout un module preprocessing :

   python Copier

   from sklearn.preprocessing import StandardScaler, OneHotEncoder
   from sklearn.impute import SimpleImputer
   
   # Normaliser les colonnes numériques (moyenne 0, écart-type 1)
   scaler = StandardScaler()
   X_train_scaled = scaler.fit_transform(X_train)
   X_test_scaled = scaler.transform(X_test)   # PAS de fit ici
   
   # Encoder les variables catégorielles
   encoder = OneHotEncoder(sparse_output=False)
   X_cat = encoder.fit_transform(X_train[["quartier"]])
   
   # Remplir les valeurs manquantes
   imputer = SimpleImputer(strategy="median")
   X_train = imputer.fit_transform(X_train)

   fit_transform sur train, transform sur test

   Toujours fit_transform sur les données d'entraînement et transform (sans fit) sur celles de test. Sinon, le scaler apprend les stats du test ⇒ fuite de données ⇒ tu surestimes ta performance.

6. Encapsuler tout dans un Pipeline

   Plutôt que d'appliquer prétraitement puis modèle séparément, Pipeline les enchaîne dans un seul objet. Avantage : le fit ne touche que les données train, et le pipeline entier peut être sauvegardé d'un coup.

   python Copier

   from sklearn.pipeline import Pipeline
   from sklearn.preprocessing import StandardScaler
   from sklearn.linear_model import LogisticRegression
   
   pipe = Pipeline([
       ("scaler", StandardScaler()),
       ("model", LogisticRegression()),
   ])
   
   pipe.fit(X_train, y_train)
   pipe.predict(X_test)

7. Évaluer correctement (cross-validation et métriques)

   python Copier

   from sklearn.model_selection import cross_val_score
   from sklearn.metrics import (
       accuracy_score, f1_score, confusion_matrix,
       mean_absolute_error, mean_squared_error, r2_score
   )
   
   # Cross-validation : 5 splits, on regarde la moyenne
   scores = cross_val_score(pipe, X, y, cv=5, scoring="accuracy")
   print(scores.mean(), scores.std())
   
   # Classification
   accuracy_score(y_test, y_pred)
   f1_score(y_test, y_pred, average="weighted")
   confusion_matrix(y_test, y_pred)
   
   # Régression
   mean_absolute_error(y_test, y_pred)
   r2_score(y_test, y_pred)

8. Sauvegarder un modèle entraîné

   python Copier

   import joblib
   
   # Sauver
   joblib.dump(pipe, "model.joblib")
   
   # Recharger plus tard (dans une API, un script…)
   pipe = joblib.load("model.joblib")
   pipe.predict(nouvelles_donnees)

   joblib est livré avec sklearn et gère mieux les gros tableaux NumPy que pickle standard.

Aide-mémoire

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = RandomForestClassifier().fit(X_train, y_train)
accuracy_score(y_test, model.predict(X_test))

from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer

from sklearn.pipeline import Pipeline
pipe = Pipeline([("scaler", StandardScaler()), ("model", LogisticRegression())])
pipe.fit(X_train, y_train); pipe.predict(X_test)

from sklearn.model_selection import GridSearchCV
grid = GridSearchCV(model, {"n_estimators": [50, 100, 200]}, cv=5)
grid.fit(X, y); grid.best_params_, grid.best_score_

scikit-learn et le reste de l'écosystème

• pandas / Polars — les DataFrames sont le format d'entrée naturel. sklearn accepte directement un DataFrame pandas, ou un array NumPy. Avec Polars, on convertit en pandas juste avant le fit.
• matplotlib — tracer la loss en cours d'entraînement, la matrice de confusion, l'importance des features. sklearn fournit même ConfusionMatrixDisplay qui rend une figure matplotlib en une ligne.
• MLflow — l'outil naturel pour suivre tes expériences sklearn. mlflow.sklearn.log_model(pipe, "model") sauvegarde le pipeline entier (prétraitement + modèle), prêt à être resservi par MLflow comme une API REST.
• FastAPI — pour exposer un modèle sklearn comme service web. Tu charges le pipeline au démarrage (joblib.load), et chaque requête appelle pipe.predict.
• Prefect — orchestrer un pipeline d'entraînement périodique : charger les données fraîches, re-fit le modèle, logger dans MLflow, déployer la nouvelle version.

Pour aller plus loin

• Site officiel : scikit-learn.org
• Tutoriel « Getting started » : scikit-learn.org/stable/getting_started.html
• Choisir le bon estimateur (flowchart) : scikit-learn.org/stable/machine_learning_map.html
• User Guide complet : scikit-learn.org/stable/user_guide.html