Aide-mémoire scikit-learn (sklearn)
Dernière mise à jour
Charger et découper les données
Mets un jeu de test de côté avant toute chose, et ne le regarde qu'à la toute fin.
| Tâche | Code |
|---|---|
| Importer la fonction de découpage | from sklearn.model_selection import train_test_split |
| Features et cible depuis un DataFrame | X = df.drop(columns="target")
y = df["target"] |
| Jeu de données intégré en pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Données synthétiques pour expérimenter | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| Découpage train/test 80/20 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Garder les proportions des classes des deux côtés | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Train, validation et test (60/20/20) | X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, random_state=0) |
Prétraiter les features
Ajuste un transformer sur les données d'entraînement uniquement, puis transforme les deux jeux. L'ajuster sur les données de test provoque une fuite d'information.
| Tâche | Code |
|---|---|
| Imports | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Centrer-réduire (moyenne 0, écart-type 1) | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Mettre à l'échelle entre 0 et 1 | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| Encodage one-hot des catégories | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Encoder des catégories ordonnées en nombres | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Remplir les valeurs manquantes | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Features polynomiales et d'interaction | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| Récupérer des DataFrames plutôt que des tableaux | scaler.set_output(transform="pandas") |
| Libellés texte en entiers | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Choisir un modèle
Commence simple et garde le modèle simple comme score à battre.
| Problème | Commencer par | Puis essayer |
|---|---|---|
| Prédire un nombre (régression) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Prédire une classe (classification) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Peu de données, points proches de même classe | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Des règles lisibles | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Grouper des lignes sans étiquettes | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Moins de features, pour visualiser ou accélérer | PCA(n_components=2) | TSNE(n_components=2) |
| Repérer les lignes atypiques | IsolationForest(random_state=0) | LocalOutlierFactor() |
Entraîner un modèle
Chaque estimateur suit le même schéma : crée-le avec ses paramètres, puis appelle fit.
| Tâche | Code |
|---|---|
| Le schéma de tout modèle | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Régression linéaire | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Régression linéaire régularisée | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Régression logistique (classification) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k plus proches voisins | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Arbre de décision | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Forêt aléatoire | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient boosting, rapide sur de gros volumes | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Machine à vecteurs de support (SVM) | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naive Bayes | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Baseline qui prédit toujours la classe majoritaire | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Prédire et inspecter
| Tâche | Code |
|---|---|
| Prédire des classes ou des valeurs | y_pred = model.predict(X_test) |
| Probabilité de la classe positive | model.predict_proba(X_test)[:, 1] |
| Score rapide : accuracy ou R² | model.score(X_test, y_test) |
| Coefficients d'un modèle linéaire | model.coef_, model.intercept_ |
| Importance des features d'un modèle à arbres | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Importance par permutation de chaque feature | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Classes connues du modèle | model.classes_ |
| Lire et modifier les paramètres | model.get_params(), model.set_params(C=0.5) |
| Dessiner un arbre de décision | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Métriques de classification
L'accuracy seule masque les erreurs sur une classe rare. Vérifie aussi la précision, le rappel et la matrice de confusion.
| Tâche | Code |
|---|---|
| Imports | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Accuracy | accuracy_score(y_test, y_pred) |
| Précision, rappel et F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 avec plusieurs classes | f1_score(y_test, y_pred, average="macro") |
| Toutes les métriques par classe | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Matrice de confusion | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Tracer la matrice de confusion | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC à partir des probabilités | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| Tracer la courbe ROC | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Accuracy pour classes déséquilibrées | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| Ton propre seuil de décision | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Métriques de régression
Les métriques d'erreur sont dans l'unité de la cible (plus bas, c'est mieux). R² est la part de variance expliquée (1 est parfait).
| Tâche | Code |
|---|---|
| Imports | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Erreur absolue moyenne | mean_absolute_error(y_test, y_pred) |
| Erreur quadratique moyenne et sa racine | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| Score R² | r2_score(y_test, y_pred) |
| Erreur absolue moyenne en pourcentage | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Tracer les prédictions face au réel | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipelines
Un pipeline enchaîne le prétraitement et un modèle en un seul estimateur : la validation croisée et la grid search ajustent ainsi chaque étape sur les folds d'entraînement uniquement.
| Tâche | Code |
|---|---|
| Imports | from sklearn.pipeline import make_pipeline, Pipeline |
| Mettre à l'échelle, puis entraîner un modèle | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Étapes avec tes propres noms | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Accéder à une étape | pipe.named_steps["model"], pipe[-1] |
| Étapes différentes selon les colonnes | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Prétraitement et modèle dans un seul objet | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Choisir les colonnes par type | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Imputer, puis mettre à l'échelle | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Noms des features en sortie | pre.get_feature_names_out() |
Validation croisée
La validation croisée entraîne et évalue le modèle sur plusieurs découpages, ce qui donne une estimation plus stable qu'un seul jeu de test.
| Tâche | Code |
|---|---|
| Imports | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Score sur 5 folds | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Choisir la métrique | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Folds mélangés | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Même répartition des classes dans chaque fold | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Plusieurs métriques et scores d'entraînement | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Une prédiction hors fold pour chaque ligne | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Folds par groupe, folds dans l'ordre temporel | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Tous les noms de scoring valides | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid search et optimisation
Une recherche entraîne le modèle pour chaque combinaison de paramètres avec validation croisée, garde la meilleure et la réentraîne sur toutes les données d'entraînement.
| Tâche | Code |
|---|---|
| Imports | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Tester toutes les combinaisons | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Meilleurs paramètres et leur score | grid.best_params_, grid.best_score_ |
| Utiliser le meilleur modèle | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Optimiser une étape d'un pipeline | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Paramètres tirés de distributions | from scipy.stats import randint
search = RandomizedSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": randint(50, 150)}, n_iter=5, cv=3, random_state=0)
search.fit(X_train, y_train) |
| Utiliser tous les cœurs du CPU | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Tous les résultats sous forme de tableau | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Clustering et réduction de dimension
Les modèles non supervisés apprennent à partir de X seul. Mets d'abord les features à l'échelle, car les deux utilisent des distances.
| Tâche | Code |
|---|---|
| Clusters k-means | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Centres des clusters et inertie | km.cluster_centers_, km.inertia_ |
| Qualité de séparation des clusters | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Clusters par densité, le bruit vaut -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Projeter sur 2 composantes | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Variance expliquée par chaque composante | pca.explained_variance_ratio_ |
| Garder 95 % de la variance | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9 : anciennes syntaxes et quoi écrire maintenant
Le code copié d'anciens tutoriels peut échouer ou déclencher des avertissements avec scikit-learn 1.9. Écris plutôt la version de la colonne scikit-learn 1.9.
| Tâche | scikit-learn 1.9 | Ancienne syntaxe |
|---|---|---|
| Racine de l'erreur quadratique moyenne | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Sortie one-hot dense | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Régression logistique L1 (lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Régression logistique sans régularisation | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Enregistrer, charger et reproduire
| Tâche | Code |
|---|---|
| Enregistrer un modèle ou un pipeline entraîné | import joblib
joblib.dump(model, "model.joblib") |
| Le recharger | model = joblib.load("model.joblib") |
| Même résultat à chaque exécution | random_state=0 |
| Version installée | import sklearn
sklearn.__version__ |
Le code scikit-learn d'un vrai workflow de machine learning, dans l'ordre où tu l'écris : charger et découper les données, les prétraiter, choisir un modèle, l'entraîner et prédire, mesurer le résultat, enchaîner les étapes dans un pipeline, faire une validation croisée et optimiser avec une grid search. Chaque ligne donne un court extrait à copier-coller, avec une phrase qui explique ce qu'il fait.
Tous les modèles de scikit-learn partagent la même API : fit apprend à partir des données d'entraînement, predict et transform appliquent ce qui a été appris. Tout est écrit pour scikit-learn 1.9, la version utilisée par Coddy, avec X pour les features et y pour la cible. scikit-learn travaille sur des tableaux NumPy et des DataFrames pandas, et l'aide-mémoire Matplotlib couvre les graphiques. Tu débutes en Python ? Commence par l'aide-mémoire Python.
FAQ de l'aide-mémoire scikit-learn
Cet aide-mémoire scikit-learn est-il gratuit ?
Oui. Cet aide-mémoire scikit-learn est entièrement gratuit, sans inscription. Ajoute-le à tes favoris ou imprime-le en PDF depuis ton navigateur, et reviens dès que tu as besoin de l'appel exact pour un pipeline, une métrique ou une grid search.
sklearn et scikit-learn, c'est la même chose ?
Oui. scikit-learn est le nom de la bibliothèque et du paquet que tu installes (
pip install scikit-learn), et sklearn est le nom que tu importes dans le code (from sklearn.linear_model import LinearRegression). Un aide-mémoire sklearn et un aide-mémoire scikit-learn couvrent donc exactement la même chose.Quelle est la différence entre fit, transform et fit_transform ?
fit apprend à partir des données : un scaler apprend la moyenne de chaque colonne, un modèle apprend ses poids. transform applique ce qui a été appris, et fit_transform fait les deux en un seul appel. Utilise fit_transform sur le jeu d'entraînement et seulement transform sur le jeu de test, sinon les données de test fuient dans l'entraînement. Un pipeline s'en charge pour toi.Dois-je mettre mes features à l'échelle ?
Pour les modèles qui utilisent des distances ou des gradients, oui : k plus proches voisins, SVM, k-means, ACP et régressions linéaire et logistique régularisées fonctionnent tous mieux sur des données mises à l'échelle. Les modèles à base d'arbres comme les arbres de décision, les forêts aléatoires et le gradient boosting n'en ont pas besoin. Place le scaler dans un pipeline pour qu'il ne soit ajusté que sur les données d'entraînement.
Par quel modèle scikit-learn commencer ?
Commence par un modèle simple et rapide comme baseline :
LinearRegression pour prédire des nombres, LogisticRegression pour prédire des classes. Essaie ensuite RandomForestClassifier ou HistGradientBoostingClassifier (ou leurs versions regressor), compare-les avec une validation croisée, et optimise le meilleur avec GridSearchCV.Quelle version de scikit-learn cet aide-mémoire couvre-t-il ?
scikit-learn 1.9, la version utilisée par Coddy, avec NumPy 2 et pandas 3. Les anciens appels qui échouent ou déclenchent maintenant des avertissements, comme
squared=False dans mean_squared_error, sparse=False dans OneHotEncoder et l'argument penalty de LogisticRegression, figurent dans le tableau des anciennes syntaxes, à côté de ce qu'il faut écrire à la place.Puis-je exécuter du code scikit-learn en ligne ?
Oui. Le playground Matplotlib gratuit exécute Python avec scikit-learn, pandas, NumPy et Matplotlib dans ton navigateur : tu peux coller n'importe quel extrait de cet aide-mémoire et le lancer sans rien installer. Le cours Machine Learning de Coddy enseigne pas à pas tout le workflow de cette page, du découpage des données à l'optimisation d'un modèle.
Ressources connexes
Plus d'aide-mémoires
