Régression Linéaire : Guide complet — Principes, Exemples et Implémentation Python

La régression linéaire est l’algorithme fondamental de tout praticien du Machine Learning supervisé : un outil simple, interprétable et mathématiquement élégant qui sert de point de départ à des modèles bien plus complexes. Elle modélise la relation entre une variable cible continue et une ou plusieurs variables explicatives. On l’utilise chaque fois que l’on souhaite prédire une valeur numérique à partir de données observées.

Principe mathématique

La régression linéaire repose sur une idée de départ étonnamment simple : supposer qu’il existe une relation approximativement linéaire entre les variables d’entrée (appelées caractéristiques ou features) et la variable cible que l’on cherche à prédire.

Le modèle

L’équation fondamentale de la régression linéaire s’écrit :

$$y = w_0 + w_1 x_1 + w_2 x_2 + \cdots + w_p x_p + \varepsilon$$

où :

• $y$ est la variable cible (ou variable dépendante), celle que l’on souhaite prédire.
• $x_1, x_2, \ldots, x_p$ sont les variables explicatives (ou caractéristiques), au nombre de $p$.
• $w_0$ est l’ordonnée à l’origine, aussi appelée biais ou intercept. C’est la valeur de $y$ lorsque toutes les caractéristiques sont égales à zéro.
• $w_1, w_2, \ldots, w_p$ sont les coefficients (ou poids) associés à chaque caractéristique. Chaque $w_j$ mesure l’impact de $x_j$ sur la variable cible, toutes choses égales par ailleurs.
• $\varepsilon$ est le terme d’erreur (ou bruit), capturant tout ce que le modèle n’explique pas : variations aléatoires, non-linéarités non capturées, bruit de mesure.

Fonction de coût : l’Erreur Quadratique Moyenne (MSE)

Pour trouver les meilleurs coefficients $w_0, w_1, \ldots, w_p$, on définit une fonction de coût qui mesure la qualité de nos prédictions. La fonction de coût la plus utilisée en régression linéaire est l’Erreur Quadratique Moyenne (Mean Squared Error, MSE) :

$$\text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i – \hat{y}_i)^2$$

où :

• $n$ est le nombre total d’échantillons dans nos données d’entraînement.
• $y_i$ est la valeur réelle observée pour le $i$-ième échantillon.
• $\hat{y}_i$ est la valeur prédite par notre modèle pour le $i$-ième échantillon.
• $(y_i – \hat{y}_i)$ est le résiduel, c’est-à-dire l’erreur commise sur le $i$-ième échantillon.

Le carré des résiduels pénalise davantage les grosses erreurs que les petites, ce qui rend le modèle sensible aux valeurs aberrantes (outliers).

Solution analytique : l’équation normale

La beauté de la régression linéaire réside dans le fait qu’elle admet une solution analytique fermée. En dérivant la fonction de coût MSE par rapport aux coefficients et en annulant cette dérivée, on obtient l’équation normale :

$$\hat{w} = (X^\top X)^{-1} X^\top y$$

où :

• $\hat{w}$ est le vecteur des coefficients optimaux $[w_0, w_1, \ldots, w_p]^\top$.
• $X$ est la matrice de design de taille $n \times (p+1)$, où chaque ligne correspond à un échantillon et la première colonne est généralement une colonne de 1 correspondant au biais $w_0$.
• $X^\top$ désigne la transposée de la matrice $X$.
• $y$ est le vecteur colonne des valeurs cibles de taille $n \times 1$.
• $(X^\top X)^{-1}$ est l’inverse de la matrice $X^\top X$. Cette matrice doit être inversible pour que la solution existe.

Cette solution est exacte et ne nécessite aucune itération. Cependant, calculer l’inverse d’une matrice de grande taille peut être coûteux en temps de calcul pour des jeux de données très volumineux (supérieurs à environ 100 000 échantillons), ce qui justifie l’utilisation de méthodes itératives comme la descente de gradient dans ces situations.

Intuition — Comment le comprendre ?

L’analogie géométrique

Imaginez un nuage de points tracé sur un plan cartésien : chaque point représente une observation (par exemple, la surface d’un appartement en abscisse et son prix en ordonnée). La régression linéaire consiste à trouver la droite qui passe « au mieux » à travers ce nuage.

Cette droite « optimale » est celle qui minimise la somme des distances verticales entre chaque point réel et la droite elle-même. Ces distances verticales sont précisément les résiduels mentionnés plus haut.

Pourquoi les distances verticales ?

On pourrait imaginer mesurer la distance perpendiculaire au plus court chemin entre le point et la droite, mais en régression linéaire classique, on ne s’intéresse qu’à l’erreur sur la variable cible $y$. C’est pourquoi on minimise les écarts verticaux (sur l’axe des $y$) et non les distances perpendiculaires.

Analogie du tapis

Imaginez que vous devez tendre un tapis rigide (votre droite de régression) dans une pièce où des clous sont plantés à différentes hauteurs au mur (vos données). Vous voulez que le tapis passe le plus près possible de chaque clou. Le meilleur emplacement est celui où la somme des écarts entre le tapis et chaque clou est minimale. C’est exactement ce que fait la régression linéaire.

Implémentation Python

Installation des dépendances

Commençons par installer les bibliothèques nécessaires :

pip install scikit-learn numpy matplotlib

Code complet

Voici un exemple complet et exécutable qui illustre toutes les étapes de la régression linéaire :

# -*- coding: utf-8 -*-
"""
Exemple complet de regression lineaire avec scikit-learn.
Donnees synthetiques, entrainement, evaluation et visualisation.
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# -----------------------------------------------------------
# Etape 1 : Generation des donnees synthetiques
# -----------------------------------------------------------
# On cree un jeu de donnees avec 200 echantillons et
# une seule variable explicative pour une visualisation claire.
X, y = make_regression(
    n_samples=200,
    n_features=1,
    noise=15,
    coef=True,
    random_state=42
)

# -----------------------------------------------------------
# Etape 2 : Separation entrainement / test
# -----------------------------------------------------------
# On reserve 20% des donnees pour l'evaluation finale.
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# -----------------------------------------------------------
# Etape 3 : Entrainement du modele
# -----------------------------------------------------------
# LinearRegression utilise l'equation normale par defaut.
modele = LinearRegression(fit_intercept=True)
modele.fit(X_train, y_train)

# Affichage des coefficients appris
print(f"Coefficient (pente)    : {modele.coef_[0]:.4f}")
print(f"Ordonnee a l'origine   : {modele.intercept_:.4f}")

# -----------------------------------------------------------
# Etape 4 : Evaluation sur les donnees de test
# -----------------------------------------------------------
y_pred = modele.predict(X_test)

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

print(f"MSE  : {mse:.4f}")
print(f"R2   : {r2:.4f}")

# -----------------------------------------------------------
# Etape 5 : Visualisation 1 - Nuage de points + droite de regression
# -----------------------------------------------------------
plt.style.use('seaborn-v0_8-whitegrid')
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Graphique de gauche : droite de regression
axes[0].scatter(X_train, y_train, alpha=0.4,
                color='steelblue',
                label="Donnees d'entrainement", s=40)
axes[0].scatter(X_test, y_test, alpha=0.4,
                color='coral', label="Donnees de test", s=40)

# Tracer la droite de regression
x_line = np.linspace(X.min(), X.max(), 100).reshape(-1, 1)
y_line = modele.predict(x_line)
axes[0].plot(x_line, y_line, color='darkgreen',
             linewidth=2.5, label="Droite de regression")

axes[0].set_xlabel("Variable explicative (x)", fontsize=12)
axes[0].set_ylabel("Variable cible (y)", fontsize=12)
axes[0].set_title("Regression lineaire : droite de meilleur "
                   "ajustement", fontsize=14)
axes[0].legend(fontsize=10)
axes[0].grid(True, alpha=0.3)

# -----------------------------------------------------------
# Etape 6 : Visualisation 2 - Predictions vs Valeurs reelles
# -----------------------------------------------------------
axes[1].scatter(y_test, y_pred, alpha=0.6,
                color='purple', s=50, zorder=2)

# Ligne de reference ideale (y = x)
min_val = min(y_test.min(), y_pred.min())
max_val = max(y_test.max(), y_pred.max())
axes[1].plot([min_val, max_val], [min_val, max_val],
             color='darkgreen', linewidth=2,
             linestyle='--',
             label='Prediction parfaite')

axes[1].set_xlabel("Valeurs reelles", fontsize=12)
axes[1].set_ylabel("Predictions", fontsize=12)
axes[1].set_title("Predictions vs Valeurs reelles",
                   fontsize=14)
axes[1].legend(fontsize=10)
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Ce code couvre l’intégralité du flux de travail typique en Machine Learning : génération des données, séparation entraînement/test, entraînement, évaluation et visualisation. Le score R² (coefficient de détermination) nous indique la proportion de variance de la variable cible expliquée par le modèle. Un R² proche de 1 signifie un excellent ajustement.

Hyperparamètres

Voici les principaux hyperparamètres de LinearRegression dans scikit-learn :

Avantages

• Simplicité et interprétabilité : les coefficients $w_j$ ont une interprétation directe. Un coefficient positif signifie qu’une augmentation de la caractéristique correspondante entraîne une augmentation de la cible.
• Rapidité d’entraînement : grâce à la solution analytique, l’entraînement est quasi instantané même sur des données de taille modérée.
• Pas d’hyperparamètres sensibles : il n’y a pratiquement rien à régler, contrairement aux réseaux de neurones ou aux forêts aléatoires.
• Méthode de référence solide : la régression linéaire constitue un excellent baseline contre lequel comparer des modèles plus complexes. Si un modèle sophistiqué ne bat pas la régression linéaire, il y a un problème.
• Hypothèses statistiques claires : le cadre théorique de Gauss-Markov garantit que les estimateurs sont les meilleurs estimateurs linéaires sans biais (BLUE) sous des conditions bien définies.

Limites

• Hypothèse de linéarité : le modèle suppose une relation linéaire entre les variables. Si la relation réelle est non linéaire (quadratique, exponentielle, sinusoïdale), les prédictions seront médiocres.
• Sensibilité aux valeurs aberrantes (outliers) : la fonction MSE pénalise fortement les grandes erreurs, ce qui rend le modèle très sensible aux observations inhabituelles.
• Multicolinéarité : lorsque deux variables explicatives sont fortement corrélées entre elles, les coefficients deviennent instables et difficilement interprétables. La matrice $X^\top X$ approche la singularité et l’inverse est numériquement instable.
• Hypothèse d’homoscédasticité : la variance des erreurs est supposée constante. Si elle varie (hétéroscédasticité), les intervalles de confiance ne sont plus fiables.
• Limitations en grande dimension : lorsque le nombre de caractéristiques $p$ dépasse le nombre d’échantillons $n$, le modèle fait de l’overfitting (échoue à généraliser).

Cas d’usage

1. Prévision immobilière

Estimer le prix d’un appartement en fonction de sa surface, du nombre de pièces, de l’âge du bâtiment et de la localisation. La régression linéaire donne une première estimation rapide et interprétable du prix au mètre carré et de l’impact de chaque caractéristique sur le prix final.

2. Prévision des ventes

Prédire le chiffre d’affaires mensuel d’une entreprise en fonction du budget publicitaire, du nombre de points de vente, de la saisonnalité et des indicateurs économiques. Les coefficients permettent d’identifier quel levier marketing a le plus d’impact sur les ventes.

3. Estimation de la consommation énergétique

Modéliser la consommation électrique d’un bâtiment à partir de la température extérieure, de la surface habitable, de l’isolation thermique et du nombre d’occupants. Les gestionnaires de réseau utilisent ces prévisions pour équilibrer l’offre et la demande d’énergie.

4. Analyse de l’impact du dosage en pharmacologie

Comprendre comment différentes doses d’un médicament influencent une mesure clinique (ex : baisse de la pression artérielle). Dans une plage de dosage raisonnable, la relation est souvent approximativement linéaire, ce qui rend la régression linéaire particulièrement adaptée.

Voir aussi

• Comprendre l’Exception au Théorème de Zeckendorf en Python : Approche et Applications
• Correspondance des Sommes de Chiffres : Maîtriser l’Art du Codage en Python
• Devenez ‘Trillionaire’ en Codant : Comment Python Peut Révolutionner Vos Projets Financiers
• Maîtriser les Graphiques Colorés en Python : Guide Complet pour Débutants et Experts