Projet de Synthèse : Le Grand Duel des Régresseurs

Conclusion de la série ‘Maîtriser la Régression’

Machine Learning
Apprentissage Supervisé
Régression
Python
Projet
Author
Affiliation

Wilson Toussile

ENSPY & ESSFAR

1 Introduction : Le Choix du Meilleur Prédicteur

Au fil de cette série, nous avons construit une impressionnante boîte à outils de modèles de régression. De la simple ligne droite de la régression linéaire à la sagesse collective des forêts aléatoires, chaque algorithme offre une approche unique pour prédire des valeurs numériques.

Mais face à un nouveau problème, la question ultime demeure : quel modèle choisir ?

Cet atelier est le point d’orgue de notre parcours. Nous allons organiser un “grand duel” pour comparer de manière rigoureuse la performance de tous les régresseurs que nous avons étudiés. L’objectif n’est pas seulement de couronner un vainqueur, mais de comprendre les forces, les faiblesses et les compromis de chaque approche, afin de vous armer pour faire des choix éclairés dans vos propres projets.

2 Le Champ de Bataille : Le Marché Immobilier Californien

Pour notre projet, nous utiliserons le jeu de données California Housing de Scikit-learn. C’est un problème de régression classique et robuste.

  • Objectif : Prédire la valeur médiane des maisons (MedHouseVal) dans les districts de Californie, en centaines de milliers de dollars.
  • Variables Explicatives : 8 caractéristiques numériques décrivant chaque district (revenu médian, âge médian des maisons, nombre moyen de chambres, localisation géographique, etc.).
  • Pourquoi ce jeu de données ? Il est propre, entièrement numérique, et suffisamment complexe pour que les différents modèles puissent montrer leurs forces respectives.

3 Les Combattants

Voici la liste des modèles qui vont s’affronter :

  1. Régression Linéaire (notre modèle de base)
  2. Régression Ridge (régularisation L2)
  3. Régression Lasso (régularisation L1 et sélection de variables)
  4. k-Plus Proches Voisins (k-NN)
  5. Arbre de Décision (élagué)
  6. Forêt Aléatoire
  7. Gradient Boosting

4 La Méthodologie : Des Règles du Jeu Équitables

Pour une comparaison juste, nous suivrons une méthodologie stricte :

  1. Pré-traitement Standardisé : Les modèles sensibles à l’échelle des données (Linéaire, Ridge, Lasso, k-NN) seront intégrés dans un Pipeline avec un StandardScaler.
  2. Recherche d’Hyperparamètres : Nous utiliserons GridSearchCV pour trouver la meilleure configuration pour les modèles qui en bénéficient le plus (Ridge, Lasso, k-NN, Arbre de Décision).
  3. Évaluation Cohérente : Tous les modèles finaux seront évalués sur le même jeu de test en utilisant trois métriques clés :
    • R-carré (\(R^2\)) : La proportion de variance expliquée.
    • Erreur Quadratique Moyenne (MSE) : Utile pour l’optimisation.
    • Racine de l’Erreur Quadratique Moyenne (RMSE) : La plus interprétable, car elle est dans la même unité que la cible (centaines de milliers de dollars).

5 Préparation de l’Environnement et des Données

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Données et pré-traitement
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Les modèles
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

# Métriques
from sklearn.metrics import r2_score, mean_squared_error

# Configuration
sns.set_theme(style="whitegrid")
plt.rcParams['figure.figsize'] = (12, 7)

# 1. Charger et préparer les données
housing = fetch_california_housing()
X, y = housing.data, housing.target

# 2. Diviser les données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"Données prêtes. Entraînement: {X_train.shape[0]} échantillons, Test: {X_test.shape[0]} échantillons.")
Données prêtes. Entraînement: 16512 échantillons, Test: 4128 échantillons.

6 Le Duel : Entraînement et Évaluation des Modèles

Nous allons maintenant entraîner chaque modèle et stocker leurs performances.

# Dictionnaire pour stocker les résultats
results = {}

# Fonction pour évaluer et stocker les résultats
def evaluate_model(name, model, X_test, y_test):
    y_pred = model.predict(X_test)
    r2 = r2_score(y_test, y_pred)
    mse = mean_squared_error(y_test, y_pred)
    rmse = np.sqrt(mse)
    results[name] = {'R2': r2, 'MSE': mse, 'RMSE': rmse}
    print(f"--- {name} ---")
    print(f"R²: {r2:.4f}, MSE: {mse:.4f}, RMSE: {rmse:.4f}\n")

# --- 1. Régression Linéaire (Baseline) ---
pipe_lr = Pipeline([('scaler', StandardScaler()), ('regressor', LinearRegression())])
pipe_lr.fit(X_train, y_train)
evaluate_model('Linear Regression', pipe_lr, X_test, y_test)

# --- 2 & 3. Ridge & Lasso (avec GridSearchCV) ---
print("--- Entraînement: Ridge & Lasso (avec GridSearchCV) ---")
pipe_ridge = Pipeline([('scaler', StandardScaler()), ('regressor', Ridge())])
pipe_lasso = Pipeline([('scaler', StandardScaler()), ('regressor', Lasso())])
param_grid_reg = {'regressor__alpha': np.logspace(-4, 2, 7)} # Grille de 10^-4 à 10^2

gs_ridge = GridSearchCV(pipe_ridge, param_grid_reg, cv=5, scoring='r2')
gs_ridge.fit(X_train, y_train)
evaluate_model('Ridge', gs_ridge.best_estimator_, X_test, y_test)
print(f"Meilleur alpha pour Ridge: {gs_ridge.best_params_['regressor__alpha']}")

gs_lasso = GridSearchCV(pipe_lasso, param_grid_reg, cv=5, scoring='r2')
gs_lasso.fit(X_train, y_train)
evaluate_model('Lasso', gs_lasso.best_estimator_, X_test, y_test)
print(f"Meilleur alpha pour Lasso: {gs_lasso.best_params_['regressor__alpha']}")

# --- 4. k-NN ---
print("\n--- Entraînement: k-NN (avec GridSearchCV) ---")
pipe_knn = Pipeline([('scaler', StandardScaler()), ('regressor', KNeighborsRegressor())])
param_grid_knn = {'regressor__n_neighbors': [3, 5, 7, 9, 11]}
gs_knn = GridSearchCV(pipe_knn, param_grid_knn, cv=5, scoring='r2')
gs_knn.fit(X_train, y_train)
evaluate_model('k-NN', gs_knn.best_estimator_, X_test, y_test)
print(f"Meilleur k: {gs_knn.best_params_['regressor__n_neighbors']}")

# --- 5. Arbre de Décision ---
print("\n--- Entraînement: Arbre de Décision (avec GridSearchCV) ---")
pipe_tree = Pipeline([('regressor', DecisionTreeRegressor(random_state=42))])
param_grid_tree = {'regressor__max_depth': [5, 10, 15], 'regressor__min_samples_leaf': [10, 20, 50]}
gs_tree = GridSearchCV(pipe_tree, param_grid_tree, cv=5, scoring='r2')
gs_tree.fit(X_train, y_train)
evaluate_model('Decision Tree', gs_tree.best_estimator_, X_test, y_test)
print(f"Meilleurs paramètres: {gs_tree.best_params_}")

# --- 6. Forêt Aléatoire ---
print("\n--- Entraînement: Forêt Aléatoire ---")
# Pas de scaler nécessaire
rf = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)
evaluate_model('Random Forest', rf, X_test, y_test)

# --- 7. Gradient Boosting ---
print("\n--- Entraînement: Gradient Boosting ---")
gb = GradientBoostingRegressor(n_estimators=100, random_state=42)
gb.fit(X_train, y_train)
evaluate_model('Gradient Boosting', gb, X_test, y_test)

print("\n--- Entraînement de tous les modèles terminé ! ---")
--- Linear Regression ---
R²: 0.5758, MSE: 0.5559, RMSE: 0.7456

--- Entraînement: Ridge & Lasso (avec GridSearchCV) ---
--- Ridge ---
R²: 0.5758, MSE: 0.5559, RMSE: 0.7456

Meilleur alpha pour Ridge: 0.0001
--- Lasso ---
R²: 0.5759, MSE: 0.5557, RMSE: 0.7455

Meilleur alpha pour Lasso: 0.0001

--- Entraînement: k-NN (avec GridSearchCV) ---
--- k-NN ---
R²: 0.6760, MSE: 0.4246, RMSE: 0.6516

Meilleur k: 9

--- Entraînement: Arbre de Décision (avec GridSearchCV) ---
--- Decision Tree ---
R²: 0.7272, MSE: 0.3574, RMSE: 0.5979

Meilleurs paramètres: {'regressor__max_depth': 15, 'regressor__min_samples_leaf': 20}

--- Entraînement: Forêt Aléatoire ---
--- Random Forest ---
R²: 0.8051, MSE: 0.2554, RMSE: 0.5053


--- Entraînement: Gradient Boosting ---
--- Gradient Boosting ---
R²: 0.7756, MSE: 0.2940, RMSE: 0.5422


--- Entraînement de tous les modèles terminé ! ---

7 Les Résultats du Duel

Comparons les performances finales de tous nos modèles sur le jeu de test.

# Créer un DataFrame à partir des résultats
results_df = pd.DataFrame.from_dict(results, orient='index')
results_df = results_df.sort_values(by='R2', ascending=False)

print("--- Classement Final des Modèles par R² sur le Jeu de Test ---")
print(results_df)

# Visualisation des résultats
fig, axes = plt.subplots(1, 2, figsize=(20, 8))
fig.suptitle("Comparaison des Performances des Modèles de Régression", fontsize=18)

# Graphique R²
sns.barplot(x=results_df['R2'], y=results_df.index, ax=axes[0], palette='summer')
axes[0].set_title("Coefficient de Détermination (R²)")
axes[0].set_xlim(0.5, 0.85)

# Graphique RMSE
sns.barplot(x=results_df['RMSE'], y=results_df.index, ax=axes[1], palette='autumn')
axes[1].set_title("Racine de l'Erreur Quadratique Moyenne (RMSE)")

plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()
--- Classement Final des Modèles par R² sur le Jeu de Test ---
                         R2       MSE      RMSE
Random Forest      0.805123  0.255368  0.505340
Gradient Boosting  0.775645  0.293997  0.542215
Decision Tree      0.727229  0.357441  0.597864
k-NN               0.675961  0.424623  0.651631
Lasso              0.575900  0.555745  0.745483
Ridge              0.575788  0.555892  0.745581
Linear Regression  0.575788  0.555892  0.745581
/tmp/ipykernel_61468/3981110210.py:13: FutureWarning:



Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.


/tmp/ipykernel_61468/3981110210.py:18: FutureWarning:



Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.

8 Discussion et Conclusion

Les résultats sont clairs :

  • Les Champions : Les méthodes ensemblistes, Forêt Aléatoire et Gradient Boosting, dominent largement la compétition. Elles obtiennent le R² le plus élevé (plus de 80% de la variance expliquée) et l’erreur de prédiction (RMSE) la plus faible.
  • Les Challengers : Le k-NN et l’Arbre de Décision, une fois leurs hyperparamètres bien réglés, offrent des performances respectables, bien meilleures que notre modèle de base.
  • La Référence : La Régression Linéaire (et ses variantes régularisées, qui performent de manière très similaire ici) sert de bonne ligne de base, mais elle est clairement surpassée par les modèles non-linéaires et ensemblistes, ce qui suggère que les relations dans les données sont plus complexes qu’une simple combinaison linéaire.

Conclusion finale : Pour ce problème, si la performance prédictive est le seul critère, la Forêt Aléatoire serait le choix de prédilection. Elle est extrêmement performante, robuste, et facile à mettre en œuvre. Si l’interprétabilité était cruciale, on pourrait se tourner vers l’Arbre de Décision (en sacrifiant de la performance) ou analyser l’importance des variables de la Forêt Aléatoire.

Cet atelier conclut notre exploration de la régression. Vous avez maintenant une méthodologie complète pour aborder un problème de régression, depuis la construction de modèles simples jusqu’à l’entraînement d’ensembles complexes, et surtout, pour les évaluer rigoureusement afin de choisir le meilleur outil pour votre tâche.

Back to top