Régression Linéaire & Logistique

La régression est la base de tout système de prédiction. Votre score de crédit, les prévisions météo, l'estimation du prix d'une maison, le moteur de recommandation — tout commence ici. Avant les réseaux de neurones, avant les ensembles, il y avait la droite. Comprendre profondément la régression signifie comprendre ce que 'l'apprentissage' signifie mathématiquement.

Imaginez lancer des fléchettes sur un mur. Chaque fléchette atterrit à une position (x, y). Vous voulez trouver la droite qui passe le plus près de toutes les fléchettes simultanément. 'Le plus près' signifie minimiser les distances verticales (résidus) de chaque fléchette à votre droite. Les résidus au carré transforment cela en un paysage en forme de bol — et le fond du bol est la solution MCO.

Nous modélisons la relation comme ŷ = Xβ + ε où ε ~ N(0, σ²). Minimiser la somme des résidus au carré a une belle solution en forme fermée appelée l'Équation Normale. Cela fonctionne parce que la surface de perte est un paraboloïde — un bol parfait avec exactement un minimum.

Cette connexion est profonde. Si nous supposons un bruit gaussien ε ~ N(0, σ²), alors la vraisemblance de l'observation y sachant x est proportionnelle à exp(-(y - Xβ)²/2σ²). Prendre le log et nier donne exactement la somme des résidus au carré. MCO et EMV sont la même chose sous un bruit gaussien.

Quand XᵀX n'est pas inversible (multicolinéarité) ou que le jeu de données est trop grand pour l'Équation Normale, nous utilisons la descente de gradient. Commencez n'importe où sur la surface de perte, mesurez la pente, faites un petit pas vers le bas. Répétez jusqu'à la convergence.

Pour les résultats binaires, nous avons besoin de sorties dans (0,1). Nous passons la combinaison linéaire à travers la fonction sigmoïde σ(z) = 1/(1+e⁻ᶻ), qui applique ℝ → (0,1). La fonction de perte passe de MSE à l'Entropie Croisée Binaire (log loss).

The full gradient descent implementation in 12 lines:

import numpy as np
from sklearn.datasets import make_regression

class="tok-comment"># ── Données d'exemple ──────────────────────────────────────────────────
X_brut, y = make_regression(n_samples=class="tok-num">200, n_features=class="tok-num">5, noise=class="tok-num">10, random_state=class="tok-num">42)
X = np.c_[np.ones(len(X_brut)), X_brut]   class="tok-comment"># ajouter colonne de biais
lam = class="tok-num">0.1                                   class="tok-comment"># intensité de la régularisation Ridge

class RegLineaire:
    def __init__(self, lr=class="tok-num">0.01, n_iter=class="tok-num">1000):
        self.lr, self.n_iter = lr, n_iter

    def ajuster(self, X, y):
        n, p = X.shape
        self.beta = np.zeros(p)
        for _ in range(self.n_iter):
            y_pred = X @ self.beta
            residus = y - y_pred
            grad = -(class="tok-num">2/n) * X.T @ residus
            self.beta -= self.lr * grad
        return self

    def predire(self, X):
        return X @ self.beta

class="tok-comment"># Démo
modele = RegLineaire(lr=class="tok-num">0.01, n_iter=class="tok-num">1000).ajuster(X, y)
print(class="tok-str">"Bêta GD :", modele.beta[:class="tok-num">3].round(class="tok-num">2))

class="tok-comment"># Forme fermée (Équation Normale) :
beta_mco = np.linalg.solve(X.T @ X, X.T @ y)
class="tok-comment"># Ridge (régularisation L2) :
p = X.shape[class="tok-num">1]
beta_ridge = np.linalg.solve(X.T @ X + lam * np.eye(p), X.T @ y)
print(class="tok-str">"Bêta MCO :  ", beta_mco[:class="tok-num">3].round(class="tok-num">2))
print(class="tok-str">"Bêta Ridge :", beta_ridge[:class="tok-num">3].round(class="tok-num">2))

Quatre erreurs qui tuent les modèles de régression en production :

?Vérification des Connaissances