TP — Régression linéaire par descente de gradient avec scikit-learn

Auteur : Pr. El Alam

Objectifs pédagogiques

Dans ce TP, nous utilisons scikit-learn pour appliquer la descente de gradient à un modèle de régression linéaire.

À la fin de ce TP, l’étudiant doit être capable de :

• Comprendre la différence entre solution analytique et descente de gradient
• Utiliser SGDRegressor de scikit-learn
• Comprendre le rôle du taux d’apprentissage
• Évaluer et visualiser un modèle de régression

👉 Ce TP complète les TP précédents (manuel et analytique).

1) Importation des bibliothèques

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

from sklearn.linear_model import SGDRegressor
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_error, r2_score

2) Génération de données fictives

Nous créons des données simples suivant une relation linéaire avec du bruit.

# Fixer le hasard pour obtenir toujours les mêmes résultats
np.random.seed(42)

# Nombre de données
n = 200

# Variable explicative x (matrice colonne)
X = np.random.uniform(0, 10, size=(n, 1))

# Paramètres réels (inconnus pour l'étudiant)
a_true = 3.0
b_true = 1.5

# Bruit aléatoire
noise = np.random.normal(0, 2, size=n)

# Variable cible y
y = a_true * X[:, 0] + b_true + noise

print("Shape de X :", X.shape)
print("Shape de y :", y.shape)

Shape de X : (200, 1)
Shape de y : (200,)

3) Visualisation des données

plt.scatter(X, y)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Données fictives")
plt.show()

4) Séparation Train / Test

Le modèle apprend sur les données d'entraînement et est évalué sur le test.

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42
)

print("Train :", X_train.shape)
print("Test  :", X_test.shape)

Train : (160, 1)
Test  : (40, 1)

5) Création du modèle avec scikit-learn

Nous utilisons SGDRegressor, qui applique la descente de gradient.

Attention: Ce modèle est sensible à l’échelle des données,
c’est pourquoi nous utilisons une standardisation.

model = make_pipeline(
    StandardScaler(),  # Mise à l'échelle des données
    SGDRegressor(
        max_iter=1000,        # Nombre d'itérations
        eta0=0.01,            # Taux d'apprentissage
        learning_rate='constant',
        random_state=42
    )
)

6) Entraînement du modèle

scikit-learn effectue automatiquement la descente de gradient.

model.fit(X_train, y_train)

Pipeline(steps=[('standardscaler', StandardScaler()),
                ('sgdregressor',
                 SGDRegressor(learning_rate='constant', random_state=42))])

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

7) Paramètres appris

Les paramètres sont appris progressivement par descente de gradient.

sgd = model.named_steps["sgdregressor"]

print("Coefficient (a) appris :", round(sgd.coef_[0], 3))
print("Intercept (b) appris  :", round(sgd.intercept_[0], 3))

Coefficient (a) appris : 8.841
Intercept (b) appris  : 16.104

8) Prédiction et évaluation

y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print("MSE :", round(mse, 2))
print("R²  :", round(r2, 3))

MSE : 4.3
R²  : 0.942

9) Visualisation de la droite de régression

x_grid = np.linspace(X.min(), X.max(), 200).reshape(-1, 1)
y_grid = model.predict(x_grid)

plt.scatter(X_test, y_test, label="Données réelles")
plt.plot(x_grid, y_grid, color="red", label="Modèle (SGDRegressor)")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.title("Régression linéaire avec descente de gradient (scikit-learn)")
plt.show()

Conclusion pédagogique

• SGDRegressor utilise la descente de gradient
• Le taux d’apprentissage influence la convergence
• La standardisation est essentielle

• scikit-learn masque les calculs mais applique le même principe que le TP manuel

  Ce TP montre la version outil professionnel de la descente de gradient.