🤖 Scikit-learn – Le Machine Learning en Python

Le génie de Scikit-learn est son **API Cohérente** (l'interface "Estimator"). Que vous utilisiez une Régression Logistique ou une Random Forest, la syntaxe est la **même**.

L'API "Estimator"

Tout "estimateur" (modèle) suit ce pattern :

1. Instancier : Choisir le modèle et ses hyperparamètres.
2. .fit(X, y) : Entraîner le modèle sur les données d'entraînement (X_train, y_train).
3. .predict(X) : Faire des prédictions sur de nouvelles données (X_test).

// (X_train, y_train, X_test sont prêts)

// --- Modèle 1 : Logistic Regression ---
from sklearn.linear_model import LogisticRegression
model_1 = LogisticRegression(C=1.0)
model_1.fit(X_train, y_train)
preds_1 = model_1.predict(X_test)

// --- Modèle 2 : Random Forest ---
from sklearn.ensemble import RandomForestClassifier
model_2 = RandomForestClassifier(n_estimators=100)
model_2.fit(X_train, y_train)
preds_2 = model_2.predict(X_test)

// (Même syntaxe, modèle différent.
// Cela rend le "benchmarking" trivial)

L'installation se fait via pip ou conda. (Un environnement virtuel Python venv est fortement recommandé).

Le nom du paquet est scikit-learn, mais le nom de l'import Python est sklearn.

# 1. Installation (via pip)
# (Installe aussi les dépendances: numpy, scipy)
pip install scikit-learn

# (Recommandé: installer aussi pandas et matplotlib)
pip install pandas matplotlib

# 2. Installation (via Conda)
conda install -c anaconda scikit-learn

# 3. Import en Python
import sklearn
from sklearn.model_selection import train_test_split

C'est la première étape **obligatoire** de tout projet ML. On sépare les données en deux sets :

• Train set (ex: 80%) : Pour entraîner le modèle.
• Test set (ex: 20%) : Pour évaluer la performance du modèle sur des données qu'il n'a **jamais** vues (simule le futur).

Ne pas le faire (entraîner et tester sur les mêmes données) mène à l'overfitting (le modèle "apprend par cœur" mais ne généralise pas).

from sklearn.model_selection import train_test_split

# (X = features, y = target)
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,    // (Garde 20% pour le test)
    random_state=42,  // (Pour la reproductibilité)
    stratify=y        // (Optionnel: garde la proportion des classes dans 'y')
)

print(X_train.shape, X_test.shape)

Certains modèles (SVM, k-NN, Régressions, PCA) sont sensibles à l'échelle des features (ex: un "âge" [20-60] pèse moins qu'un "salaire" [30k-100k]).

StandardScaler (Centrer-Réduire) est le plus courant : il transforme chaque feature pour qu'elle ait une moyenne=0 et un écart-type=1.

Le Pattern (Manuel)

from sklearn.preprocessing import StandardScaler

# 1. Créer le scaler
scaler = StandardScaler()

# 2. FIT sur TRAIN (apprend la moyenne/std de X_train)
scaler.fit(X_train)

# 3. TRANSFORM (applique la transformation)
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test) // (Utilise la moyenne/std de TRAIN !)

// (Raccourci pour l'étape 2 et 3)
// X_train_scaled = scaler.fit_transform(X_train)

Note : Les modèles basés sur les arbres (DecisionTree, RandomForest) ne sont *pas* sensibles à l'échelle.

Les modèles ne comprennent pas le texte ("Rouge", "Bleu"). Il faut encoder les features catégorielles.

OneHotEncoder (OHE) est la méthode standard. Elle transforme N catégories en N-1 colonnes binaires (Dummies).

Exemple (OHE)

from sklearn.preprocessing import OneHotEncoder

# (Ex: X_train['couleur'] = ["Rouge", "Bleu", "Rouge"])

# drop='first' (évite la multi-colinéarité)
# handle_unknown='ignore' (si une catégorie inconnue arrive en test)
ohe = OneHotEncoder(drop='first', handle_unknown='ignore', sparse_output=False)

# (Apprend les catégories sur TRAIN)
ohe.fit(X_train_categorical)

# (Transforme)
X_train_encoded = ohe.transform(X_train_categorical)
X_test_encoded = ohe.transform(X_test_categorical)

Gérer le scaling et l'encoding manuellement (2.2, 2.3) est source d'erreurs (data leakage). La Pipeline automatise tout.

La ColumnTransformer applique des étapes différentes (ex: Scaler) à des colonnes différentes (ex: numériques) au sein de la Pipeline.

Exemple (Workflow complet)

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer // (Bonus: gère les NaN)
from sklearn.ensemble import RandomForestClassifier

# (Supposons X_train/X_test sont des DataFrames Pandas)
# (Définir les listes de noms de colonnes)
cols_num = ["age", "salaire"]
cols_cat = ["departement", "region"]

# 1. Pipeline de preprocessing Numérique
# (Étape 1: Remplir NaN, Étape 2: Scaler)
pipe_num = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# 2. Pipeline de preprocessing Catégoriel
pipe_cat = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore'))
])

# 3. ColumnTransformer (Assemble les pipelines)
preprocessor = ColumnTransformer(
    transformers=[
        ('num', pipe_num, cols_num),
        ('cat', pipe_cat, cols_cat)
    ],
    remainder='passthrough' // (Garde les autres colonnes)
)

# 4. Pipeline Finale (Preproc + Modèle)
model = RandomForestClassifier()

final_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('model', model)
])

# 5. Entraîner (TOUT se fait en 1 ligne !)
final_pipeline.fit(X_train, y_train)

# 6. Prédire (La pipeline gère tout automatiquement)
preds = final_pipeline.predict(X_test)

(Ne nécessitent pas de StandardScaler)

(Nécessitent scaling et OHE)

Objectif : Regrouper des données non-étiquetées (X seulement). .fit_predict(X).

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=4, n_init='auto')
clusters = kmeans.fit_predict(X_scaled)

Principal Component Analysis (PCA) : Réduit le nombre de features (dimensions) en trouvant de nouveaux axes (composantes) qui maximisent la variance.

Utile pour la visualisation (réduire à 2D/3D) ou pour "débruiter" les données avant un modèle. (Nécessite StandardScaler).

from sklearn.decomposition import PCA

# (Garder 95% de la variance expliquée)
pca = PCA(n_components=0.95) 

# (ou n_components=2 pour visualiser)
X_train_pca = pca.fit_transform(X_train_scaled)
X_test_pca = pca.transform(X_test_scaled)

print(pca.explained_variance_ratio_)

Grid Search (Recherche par grille) : L'outil pour trouver les meilleurs hyperparamètres. Il teste *toutes* les combinaisons possibles en utilisant la **Cross-Validation (CV)**.

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

// (Utiliser la pipeline (2.4) est la meilleure pratique)
// (On accède aux params du modèle via 'model__PARAM')
pipeline = Pipeline(steps=[
    ('scaler', StandardScaler()),
    ('model', SVC())
])

// 1. Définir la grille de recherche
// (Clé = 'NOM_ETAPE__HYPERPARAMETRE')
param_grid = {
    'model__C': [0.1, 1, 10],
    'model__kernel': ['linear', 'rbf']
}

// 2. Initialiser le GridSearch
// (cv=5 -> 5-fold Cross-Validation)
search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1 // (Utilise tous les CPUs)
)

// 3. Entraîner (teste toutes les 3*2=6 combos, 5 fois)
search.fit(X_train, y_train)

// 4. Meilleurs résultats
print(search.best_params_)
print(search.best_score_)

// (Le 'search' est maintenant le meilleur modèle)
best_model = search.best_estimator_
preds = best_model.predict(X_test)

Pour sauvegarder un modèle (ou une pipeline) entraîné. joblib est préféré à pickle car il est plus efficace pour les gros arrays NumPy.

import joblib

// (Entraîner le modèle/pipeline)
pipeline.fit(X_train, y_train)

// 1. Sauvegarder (Dump)
joblib.dump(pipeline, "mon_modele.joblib")

// --- (Plus tard, dans une autre app) ---

// 2. Charger (Load)
loaded_model = joblib.load("mon_modele.joblib")

// 3. Prédire
preds = loaded_model.predict(X_new_data)

Pour évaluer la performance (y_test vs y_pred).

accuracy_score

Pourcentage de prédictions correctes. (Trompeur si les classes sont déséquilibrées).

confusion_matrix & classification_report

Les outils les plus importants pour la classification.

from sklearn.metrics import (
    accuracy_score, 
    confusion_matrix, 
    classification_report
)

y_pred = model.predict(X_test)

// 1. Accuracy
print(accuracy_score(y_test, y_pred)) // ex: 0.91

// 2. Matrice de Confusion
// (DIAGRAMME ASCII)
//
//          Prédit: 0   Prédit: 1
// Réel: 0     [ TN ]      [ FP ]
// Réel: 1     [ FN ]      [ TP ]
//
print(confusion_matrix(y_test, y_pred))

// 3. Rapport Complet
// (Precision, Recall, F1-Score)
print(classification_report(y_test, y_pred))

Pour évaluer la performance (y_test vs y_pred_reg).

from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

y_pred_reg = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred_reg)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred_reg)

Scikit-learn est l'outil **standard** de tout Data Scientist/Analyst travaillant en Python. Il est utilisé par quasiment toutes les entreprises qui traitent des données tabulaires (clients, ventes, capteurs...).

La documentation de Scikit-learn est considérée comme l'une des meilleures (la meilleure ?) du monde open-source.