Régression linéaire

Ton premier algorithme de machine learning, écrit de zéro en Python.

Introduction

La régression linéaire simple modélise la relation entre une variable explicative x et une variable cible y par une droite :

estimatePrice(x) = θ₀ + θ₁ × x

• θ₀ : l'ordonnée à l'origine (la valeur de y quand x = 0)
• θ₁ : la pente (la variation de y quand x augmente de 1)

Exemple du projet : prédire le prix d'une voiture selon son kilométrage. θ₀ ≈ le prix d'une voiture neuve (0 km), θ₁ ≈ la perte de valeur par kilomètre. Avec le modèle entraîné : prix = 8480,97 - 0,0213 × km.

Le but de l'apprentissage : trouver les meilleurs θ₀ et θ₁ pour que la droite colle le mieux possible aux données réelles. Deux grandes approches existent - les moindres carrés (formule analytique) et la descente de gradient (optimisation itérative).

Prérequis & installation

Tout le code utilise NumPy, Pandas et Matplotlib :

python3 -m venv .venv
source .venv/bin/activate
pip install numpy pandas matplotlib

Le jeu de données data.csv contient 24 voitures : deux colonnes km et price.

km,price
240000,3650
139800,3800
150500,4400
…

La fonction de coût : l'erreur quadratique moyenne

Pour savoir si la droite est bonne, on mesure l'écart entre les valeurs prédites et les valeurs réelles. La fonction de coût de référence est la MSE (Mean Squared Error) :

MSE = (1/n) × Σ (yᵢ - ŷᵢ)²

avec ŷᵢ = θ₀ + θ₁ × xᵢ la prédiction et n le nombre de données.

Entraîner le modèle = minimiser la MSE sur les données disponibles.

Partie 1 : la méthode des moindres carrés

Les moindres carrés (OLS, Ordinary Least Squares) résolvent le problème de manière analytique : on trouve le minimum de la fonction de coût par le calcul, en une seule étape.

Les formules :

β₁ = Σ[(Xᵢ - X̄) × (Yᵢ - Ȳ)] / Σ[(Xᵢ - X̄)²]     la pente
β₀ = Ȳ - β₁ × X̄                                  l'ordonnée à l'origine

avec X̄ et Ȳ les moyennes de x et y.

Implémentation pas à pas

import pandas as pd

data = pd.read_csv("data.csv")
X = data["km"]        # kilométrage
Y = data["price"]     # prix

# 1. Moyennes
mean_x = X.mean()
mean_y = Y.mean()

# 2. Pente β₁ = Σ[(Xᵢ - X̄)(Yᵢ - Ȳ)] / Σ[(Xᵢ - X̄)²]
numerateur   = sum((x - mean_x) * (y - mean_y) for x, y in zip(X, Y))
denominateur = sum((x - mean_x) ** 2 for x in X)
beta_1 = numerateur / denominateur

# 3. Ordonnée à l'origine β₀ = Ȳ - β₁·X̄
beta_0 = mean_y - beta_1 * mean_x

# 4. Prédiction
prix = beta_0 + beta_1 * 100_000     # pour 100 000 km

import numpy as np
X, Y = data["km"].to_numpy(float), data["price"].to_numpy(float)

beta_1 = np.sum((X - X.mean()) * (Y - Y.mean())) / np.sum((X - X.mean())**2)
beta_0 = Y.mean() - beta_1 * X.mean()

Avantages : rapide, exact, aucune boucle d'apprentissage.

Limite : la formule fermée ne se généralise pas telle quelle à tous les modèles (réseaux de neurones, etc.). D'où la descente de gradient.

Partie 2 : la descente de gradient

La descente de gradient approche le minimum de la MSE par étapes itératives : on regarde la pente de la fonction de coût, et on fait un petit pas dans la direction opposée (vers le bas).

Étape 1 - Normaliser les données

Le kilométrage (jusqu'à 240 000) et le prix (quelques milliers) n'ont pas la même échelle : la descente serait instable. On normalise tout vers [0, 1] :

def normalize(x):
    x_min, x_max = min(x), max(x)
    return np.array([(xi - x_min) / (x_max - x_min) for xi in x], dtype=float), x_min, x_max

x_norm, x_min, x_max = normalize(X)
y_norm, y_min, y_max = normalize(Y)

Étape 2 - Boucle d'entraînement

À chaque itération on calcule les gradients (les dérivées partielles de la MSE par rapport à θ₀ et θ₁), puis on met à jour simultanément les deux paramètres :

ITERATIONS    = 10_000
LEARNING_RATE = 0.01
n = len(x_norm)

theta0, theta1 = 0.0, 0.0          # paramètres initiaux

for _ in range(ITERATIONS):
    # Prédiction avec les paramètres courants
    y_pred = theta0 + theta1 * x_norm
    error  = y_pred - y_norm

    # Gradients de la MSE
    grad_theta0 = (1 / n) * error.sum()
    grad_theta1 = (1 / n) * (error * x_norm).sum()

    # Mise à jour simultanée (pas dans le sens inverse du gradient)
    theta0 -= LEARNING_RATE * grad_theta0
    theta1 -= LEARNING_RATE * grad_theta1

Étape 3 - Dénormaliser les paramètres

L'entraînement s'est fait sur des données normalisées [0, 1] : il faut ramener θ₀ et θ₁ à l'échelle d'origine avant de les utiliser pour prédire.

# θ₁ : rapport des écarts (pente dans l'échelle d'origine)
theta1_final = theta1 * (y_max - y_min) / (x_max - x_min)

# θ₀ : ajustement pour retrouver l'ordonnée à l'origine
theta0_final = y_min + (y_max - y_min) * (theta0 - theta1 * x_min / (x_max - x_min))

Enfin on sauvegarde les paramètres pour les réutiliser plus tard :

import json
json.dump({"theta0": theta0_final, "theta1": theta1_final}, open("thetas.json", "w"))

Résultat obtenu avec les données du sujet (10 000 itérations, taux 0,01) :

{ "theta0": 8480.966554681116, "theta1": -0.021271757648460635 }

Prédiction

Une fois le modèle entraîné, on prédit le prix d'une voiture à partir de son kilométrage :

import json

with open("thetas.json") as f:
    thetas = json.load(f)
theta0, theta1 = thetas["theta0"], thetas["theta1"]

km = float(input("Kilométrage : "))       # ex. 150000
prix_estime = theta0 + theta1 * km

print(f"Prix estimé pour {km:,.0f} km : {prix_estime:,.2f} €")

Évaluer le modèle : MSE, MAE, R²

Trois métriques mesurent la qualité de la régression :

import numpy as np

def mean_squared_error(y, y_pred):
    return ((y - y_pred) ** 2).mean()

def mean_absolute_error(y, y_pred):
    return np.abs(y - y_pred).mean()

def r2_score(y, y_pred):
    ss_res = ((y - y_pred) ** 2).sum()
    ss_tot = ((y - y.mean()) ** 2).sum()
    return 1 - (ss_res / ss_tot)

y_pred = theta0 + theta1 * X
print(f"MSE = {mean_squared_error(Y, y_pred):,.2f}")
print(f"MAE = {mean_absolute_error(Y, y_pred):,.2f}")
print(f"R²  = {r2_score(Y, y_pred):.4f}")

Résultats réels du projet :

MSE = 445 729,27
MAE = 556,48
R²  = 0,7329

Visualiser avec Matplotlib

Le meilleur moyen de valider un modèle : regarder la droite par-dessus les données.

import matplotlib.pyplot as plt

# Nuage de points des données réelles
plt.scatter(X, Y, color="blue", label="Prix réels")

# Droite de régression
plt.plot(X, theta0 + theta1 * X, color="red", label="Régression")

plt.title("Évolution du prix en fonction des kilomètres parcourus")
plt.xlabel("Kilomètres parcourus")
plt.ylabel("Prix du véhicule (€)")
plt.grid(True)
plt.legend()
plt.savefig("regression_lineaire.png")

Comparaison des deux méthodes

Pour aller plus loin

• Scikit-learn : la bibliothèque qui implémente LinearRegression, train_test_split et cross_val_score - maintenant que tu sais les coder, tu peux les utiliser sans mystère.
• Régression multiple : plusieurs variables explicatives (km, âge, motorisation…) → l'équation devient ŷ = θ₀ + θ₁x₁ + θ₂x₂ + … et le raisonnement reste le même.
• Régularisation : Ridge / Lasso pour limiter le surapprentissage.
• Le projet complet - la fiche 42 de la descente de gradient, avec son architecture et ses résultats chiffrés : Linear Regression.