Régression linéaire : définition et exemple en Python

La régression linéaire est une méthode de machine learning supervisé qui prédit une valeur numérique en modélisant la relation entre variables par une droite. Elle répond à des questions du type « quelle latence pour cette charge de requêtes ? » ou « quel prix pour cette surface ? », en traçant la droite qui colle au mieux aux données observées.

Cette leçon définit la régression linéaire, explique la droite des moindres carrés, la met en oeuvre avec scikit-learn dans l'environnement data de la formation, montre comment l'évaluer avec le coefficient de détermination R² et le RMSE, puis distingue régression simple et multiple. Elle approfondit la famille supervisée présentée dans les types d'apprentissage.

Ce que vous allez apprendre

• Définir la régression linéaire et son principe.
• Comprendre la droite des moindres carrés.
• Entraîner un modèle avec scikit-learn et prédire une valeur.
• Évaluer un modèle avec R² et le RMSE.
• Distinguer régression simple et régression multiple.

Quels sont les prérequis ?

La leçon suppose l'environnement conda data créé dans la leçon Conda et Miniconda et un notebook ou un terminal Python pour exécuter le code. Elle suppose aussi le vocabulaire de la leçon Types d'apprentissage : exemples étiquetés, valeur continue. Aucune notion de statistiques n'est requise, chaque indicateur est défini à son premier emploi.

Qu'est-ce que la régression linéaire ?

La régression linéaire cherche la droite qui résume le mieux la relation entre une variable à prédire et une ou plusieurs variables explicatives, c'est-à-dire les mesures dont on part, comme la charge d'un service. Avec une seule variable explicative, cette droite s'écrit :

y = a * x + b

où a est la pente (de combien y augmente quand x augmente de 1) et b l'ordonnée à l'origine (la valeur de y quand x vaut 0). Le modèle apprend les valeurs de a et b qui minimisent l'erreur sur les données connues.

C'est de l'apprentissage supervisé : on fournit des exemples où la réponse est connue, et le modèle prédit ensuite la valeur pour de nouvelles entrées. Contrairement à la classification, la sortie est une valeur continue, pas une catégorie.

La droite des moindres carrés

Comment trouver la « meilleure » droite ? En minimisant la somme des carrés des écarts entre les points réels et la droite : c'est la méthode des moindres carrés. Élever au carré évite que les écarts positifs et négatifs s'annulent, et pénalise fortement les grosses erreurs.

Corrélation n'est pas causalité

Une régression peut trouver une relation forte entre deux variables sans qu'il y ait de lien de cause à effet. La droite mesure une association statistique ; l'interprétation causale reste votre responsabilité.

Entraîner une régression linéaire avec scikit-learn

Activez l'environnement data de la leçon conda : il contient déjà scikit-learn 1.9.1, NumPy 2.5.4 et matplotlib 3.11.2, à ces versions exactes. Un contrôle rapide confirme que vous êtes au bon endroit :

conda activate data
python -c "import sklearn, numpy; print(sklearn.__version__, numpy.__version__)"
# 1.9.1 2.5.4

Si la commande répond ModuleNotFoundError, l'environnement n'est pas actif (le prompt n'affiche pas (data)) : relancez conda activate data.

On génère des données de démonstration avec make_regression, on sépare en jeu d'entraînement et de test, puis on entraîne le modèle. Côté exploitation, imaginez que X soit la charge d'un service (requêtes par seconde) et y sa latence : la droite apprise permettrait de prévoir la latence pour une charge jamais observée. Les chiffres ci-dessous viennent de données synthétiques générées par scikit-learn ; le jeu de métriques d'exploitation de la formation n'est pas encore publié.

from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

# Données : 100 points avec du bruit
X, y = make_regression(n_samples=100, n_features=1, noise=15, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entraînement
model = LinearRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Pente :", round(float(model.coef_[0]), 2))
print("Ordonnée :", round(float(model.intercept_), 2))
print("R2 :", round(r2_score(y_test, y_pred), 3))
print("RMSE :", round(mean_squared_error(y_test, y_pred) ** 0.5, 2))

Le paramètre random_state fige le hasard (génération du bruit, tirage de la séparation entraînement et test), et ** 0.5 prend la racine carrée de l'erreur quadratique moyenne pour obtenir le RMSE. La sortie, identique à chaque exécution avec les mêmes versions, donne l'équation apprise et la qualité du modèle :

Pente : 45.5
Ordonnée : 0.15
R2 : 0.874
RMSE : 15.31

Le modèle a appris la droite y = 45.5 * x + 0.15 : la pente vaut 45,5, donc quand x augmente de 1 la valeur prédite augmente d'environ 45,5. Superposée aux données, la droite suit bien la tendance :

Pourquoi séparer entraînement et test

On évalue le modèle sur des données jamais vues à l'entraînement (train_test_split). Sinon, on mesure sa capacité à réciter les exemples connus, pas à généraliser à de nouvelles données.

Évaluer un modèle de régression

Deux indicateurs complémentaires mesurent la qualité d'une régression.

• Le coefficient de détermination R² : la part de la variation expliquée par le modèle, au plus égale à 1. Un R² de 0.874 signifie que le modèle explique 87 % de la variabilité des données. Plus il est proche de 1, mieux c'est ; il vaut 0 pour un modèle qui prédit toujours la moyenne et peut même devenir négatif sur le jeu de test si le modèle fait pire.
• Le RMSE (racine de l'erreur quadratique moyenne) : l'erreur typique de prédiction, dans l'unité de la variable cible. Un RMSE de 15.31 signifie que les prédictions s'écartent d'environ 15 unités, les grosses erreurs pesant plus que les petites.

Le R² dit quelle proportion est expliquée, le RMSE dit de combien on se trompe. On les regarde ensemble, et toujours sur le jeu de test : c'est ce que calcule le code ci-dessus avec y_test et y_pred.

Une droite a une limite : si la relation réelle est courbe, le R² peut rester élevé et ne suffit pas à le révéler. On repère la non-linéarité en regardant les résidus, c'est-à-dire l'écart entre la valeur réelle et la valeur prédite : s'ils dessinent une forme (une courbe, un arc) au lieu d'un nuage sans structure, la droite rate quelque chose.

Deux remèdes courants : transformer les variables (ajouter x² ou log x) tout en gardant LinearRegression, ou passer à un arbre ou une forêt, qui épousent les courbes sans que vous ayez à les décrire.

Régression simple ou multiple

La régression linéaire simple utilise une seule variable explicative (une droite). La régression multiple en utilise plusieurs : le modèle apprend alors un plan (ou un hyperplan, son équivalent à plus de trois dimensions), avec un coefficient par variable.

Simple   : y = a * x + b
Multiple : y = a1 * x1 + a2 * x2 + ... + b

Le code scikit-learn est identique : il suffit de fournir un X à plusieurs colonnes. La régression multiple est la plus fréquente en pratique, car un phénomène dépend rarement d'un seul facteur.

Cas d'usage de la régression linéaire

La régression linéaire sert dès qu'on veut prédire une quantité à partir de facteurs mesurables :

• Prévision de latence ou de capacité : estimer le temps de réponse d'un service, ou la mémoire consommée, d'après la charge entrante.
• Estimation de prix : immobilier, véhicules d'occasion, selon leurs caractéristiques.
• Prévision de ventes en fonction du budget marketing ou de la saison.
• Analyse d'impact : mesurer l'effet d'une variable sur une autre.
• Base de référence : c'est le modèle le plus simple, celui auquel on compare des modèles plus complexes.

À retenir

1. La régression linéaire prédit une valeur continue avec une droite y = a*x + b.
2. La méthode des moindres carrés trouve la droite qui minimise les carrés des écarts.
3. scikit-learn l'entraîne en quelques lignes avec LinearRegression.
4. On évalue avec R² (part expliquée, au plus 1, négatif si le modèle fait pire que la moyenne) et RMSE (erreur typique), sur le jeu de test.
5. La régression multiple généralise à plusieurs variables, avec le même code.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

FAQ : questions fréquentes

La régression linéaire, c'est quoi ?

Comment fonctionne la méthode des moindres carrés ?

Qu'est-ce que le coefficient de détermination R² ?

Quelle différence entre régression et classification ?

×

📖 Voir la documentation →