TP Pratique — Régression Linéaire en Python

Introduction

La régression linéaire est l'une des techniques d'apprentissage automatique les plus fondamentales et les plus largement utilisées. Ce tutoriel pratique vous guidera à travers les concepts clés et leur implémentation en Python avec NumPy. Nous explorerons comment ajuster un modèle linéaire aux données et faire des prédictions.

Définition

La régression linéaire peut être catégorisée en deux types :

• Régression linéaire simple : Une seule variable indépendante (X) pour expliquer une variable dépendante (Y)
• Régression linéaire multiple : Plusieurs variables indépendantes pour expliquer une variable dépendante

L'objectif est de trouver les paramètres du modèle qui expliquent au mieux la relation entre la variable dépendante (Y) et les variables indépendantes (X).

Le modèle

Le modèle de régression linéaire est défini comme :

$y = X^{T}\cdot \theta + \epsilon$

où ε est le terme d'erreur qui suit une distribution normale :

$\epsilon ~ N(0, \sigma^2)$

θ représente le vecteur des coefficients (paramètres) que nous cherchons à estimer. X est la matrice des variables indépendantes, et y est le vecteur des observations de la variable dépendante.

Estimation par Maximum de Vraisemblance

Pour estimer les paramètres θ, nous utilisons l'approche du maximum de vraisemblance. La solution analytique est donnée par :

$\theta_{ML} = (X^{T}\cdot X)^{-1}\cdot X^{T}\cdot y$

Cette formule nous permet de calculer directement les paramètres optimaux sans avoir besoin d'algorithmes d'optimisation itératifs.

Implémentation Python avec NumPy

Étape 1 : Préparation des données

Commençons par créer nos données d'entraînement et les visualiser :

import numpy as np
import matplotlib.pyplot as plt

# Données d'entraînement
x_train = np.array([1, 2, 3, 4, 5])
y_train = np.array([2.1, 3.9, 6.2, 7.8, 10.1])

plt.scatter(x_train, y_train, color='gold', edgecolor='navy')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Données d\'entraînement')
plt.show()

Étape 2 : Fonction d'estimation par maximum de vraisemblance

Créons une fonction qui implémente la formule d'estimation des paramètres :

def max_lik_estimate(x, y):
    N = len(x)
    X = np.column_stack([np.ones(N), x])
    theta = np.linalg.inv(X.T @ X) @ X.T @ y
    return theta

Dans cette fonction, nous construisons la matrice X en ajoutant une colonne de uns pour le terme constant (intercept). Puis nous appliquons la formule du maximum de vraisemblance pour obtenir les coefficients θ.

Étape 3 : Fonction de prédiction

Créons une fonction qui utilise les paramètres estimés pour faire des prédictions :

def predict(x, theta):
    X = np.column_stack([np.ones(len(x)), x])
    return X @ theta

Étape 4 : Ajustement et visualisation

Maintenant, estimons les paramètres et traçons la droite de régression :

theta = max_lik_estimate(x_train, y_train)
print(f"θ₀ = {theta[0]:.4f}, θ₁ = {theta[1]:.4f}")

x_test = np.linspace(0, 6, 100)
y_pred = predict(x_test, theta)

plt.scatter(x_train, y_train, color='gold', edgecolor='navy', label='Données')
plt.plot(x_test, y_pred, color='navy', label='Régression')
plt.legend()
plt.show()

Cette étape calcule les paramètres θ₀ (intercept) et θ₁ (pente), puis trace à la fois les points d'entraînement et la droite de régression ajustée.

Étape 5 : Test avec données modifiées

Voyons ce qui se passe lorsque nous modifions nos données (par exemple, un décalage vertical) et réajustons le modèle :

# Modifier les données avec un décalage
y_train_modified = y_train + 2.0

# Réestimer les paramètres
theta_modified = max_lik_estimate(x_train, y_train_modified)
y_pred_modified = predict(x_test, theta_modified)

# Comparaison
plt.scatter(x_train, y_train, color='gold', edgecolor='navy', label='Données originales')
plt.plot(x_test, y_pred, color='navy', label='Régression originale')
plt.scatter(x_train, y_train_modified, color='coral', edgecolor='darkred', label='Données modifiées')
plt.plot(x_test, y_pred_modified, color='darkred', label='Régression modifiée')
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('Comparaison des régressions')
plt.show()

Ce dernier exemple illustre comment le modèle s'adapte aux changements dans les données. Le décalage vertical affecte principalement l'intercept (θ₀) tandis que la pente (θ₁) reste essentiellement la même.

Conclusion

La régression linéaire est un outil puissant et simple pour la modélisation statistique. Nous avons exploré sa formulation mathématique, l'estimation par maximum de vraisemblance, et son implémentation pratique en Python avec NumPy. Cette fondation vous permet de construire des modèles plus complexes et d'explorer d'autres techniques d'apprentissage automatique.