La régression est une forme d’apprentissage supervisé où la variable cible est continue (ex: prix, température, durée). On cherche une fonction qui, à partir des caractéristiques (features), estime la valeur attendue. Les cas d’usage typiques incluent : prévision du prix d’un logement (surface, nombre de pièces), estimation de la demande d’un produit, prédiction de la consommation électrique, etc. ISOSET propose des cursus pratiques pour maîtriser la régression, de l’exploration à la mise en production.

• Régression linéaire simple – une seule variable explicative (y = a·x + b).
• Régression linéaire multiple – plusieurs variables explicatives (y = a₁x₁ + … + aₙxₙ + b).
• Régression polynomiale – ajout de termes de degré supérieur pour capturer la non‑linéarité.
• Régularisation – Ridge, Lasso pour éviter le sur‑apprentissage et sélectionner les variables.

Le modèle linéaire postule une relation linéaire entre les variables d’entrée et la cible. Les paramètres sont appris par la méthode des moindres carrés ordinaires (OLS) : on minimise la somme des carrés des résidus (différences entre prédiction et réalité). Simple et interprétable, il constitue une baseline obligatoire. Sa mise en œuvre est immédiate avec scikit‑learn.

# Régression linéaire avec scikit‑learn
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import numpy as np

X, y = ...  # vos données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"Coefficients : {model.coef_}")
print(f"Intercept : {model.intercept_}")

ISOSET aide les entreprises à interpréter les coefficients linéaires pour la prise de décision (ex: impact du kilométrage sur le prix d’une voiture).

Contrairement à la classification, on ne peut pas utiliser l’accuracy. Les métriques les plus courantes sont :

• MSE (Mean Squared Error) – moyenne des carrés des erreurs. Pénalise fortement les grandes erreurs.
• RMSE (Root MSE) – racine du MSE, dans l’unité de la cible (plus interprétable).
• MAE (Mean Absolute Error) – moyenne des valeurs absolues des erreurs. Moins sensible aux outliers.
• R² (coefficient de détermination) – proportion de variance expliquée par le modèle (entre 0 et 1, idéalement proche de 1). Il peut être négatif si le modèle est moins bon qu’une simple moyenne.

# Calcul des métriques avec scikit‑learn
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"RMSE : {rmse:.2f}, MAE : {mae:.2f}, R² : {r2:.3f}")

ISOSET enseigne à choisir la métrique adaptée selon les objectifs business (ex: RMSE pour pénaliser les grosses prédictions erronées).

Quand la relation entre caractéristiques et cible n’est pas linéaire, on peut ajouter des termes polynomiaux (x², x³, interactions). Exemple : prédiction de la consommation en fonction de la vitesse. La régression polynomiale reste linéaire dans les paramètres (on transforme simplement les variables). Attention au sur‑apprentissage si le degré est trop élevé.

# Régression polynomiale de degré 2
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline

pipe = Pipeline([
    ('poly', PolynomialFeatures(degree=2, include_bias=False)),
    ('lin', LinearRegression())
])
pipe.fit(X_train, y_train)
y_pred_poly = pipe.predict(X_test)

ISOSET forme à l’utilisation de pipelines pour enchaîner transformations polynomiales et régression.

Lorsqu’on a beaucoup de variables (ou un degré élevé), la régression linéaire peut sur‑apprendre. La régularisation ajoute une pénalité sur les coefficients.

• Ridge (L2) – pénalise la somme des carrés des coefficients. Réduit leur amplitude sans les annuler complètement. Utile quand toutes les variables sont pertinentes.
• Lasso (L1) – pénalise la somme des valeurs absolues des coefficients. Peut forcer certains coefficients à zéro, réalisant une sélection de variables (parcimonie).
• ElasticNet – mélange L1 et L2, combine les avantages des deux.

# Ridge et Lasso avec scikit‑learn
from sklearn.linear_model import Ridge, Lasso

ridge = Ridge(alpha=1.0)   # alpha = force de régularisation
lasso = Lasso(alpha=0.1)
ridge.fit(X_train, y_train)
lasso.fit(X_train, y_train)

# Recherche du meilleur alpha par validation croisée
from sklearn.linear_model import RidgeCV
ridge_cv = RidgeCV(alphas=[0.1, 1.0, 10.0], scoring='neg_mean_squared_error')
ridge_cv.fit(X_train, y_train)
print(f"Meilleur alpha : {ridge_cv.alpha_}")

ISOSET initie les jeunes aux notions de régularisation via des expériences de sur‑apprentissage sur des petits jeux de données.

# Pipeline complet : scaling + régression Ridge
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score

data = fetch_california_housing()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('ridge', Ridge(alpha=1.0))
])
scores = cross_val_score(pipe, X_train, y_train, cv=5, scoring='r2')
print(f"R² moyen en validation : {scores.mean():.3f} (+/- {scores.std():.3f})")

pipe.fit(X_train, y_train)
print(f"R² sur test : {pipe.score(X_test, y_test):.3f}")

Ce pipeline standardise les données, applique une régression Ridge, et évalue la performance par validation croisée. ISOSET forme à l’utilisation systématique des pipelines pour des modèles reproductibles.

Pour que l’inférence statistique (intervalles de confiance, tests) soit valide, certaines hypothèses doivent être respectées : linéarité, indépendance des résidus, homoscédasticité (variance constante), normalité des résidus. En pratique, on visualise les résidus en fonction des prédictions (qq‑plot, scale‑location). Des transformations (log, Box‑Cox) peuvent corriger les violations. ISOSET forme aux outils de diagnostic (statsmodels, `regplot`).

# Analyse des résidus avec statsmodels
import statsmodels.api as sm
X_const = sm.add_constant(X_train)
model_sm = sm.OLS(y_train, X_const).fit()
print(model_sm.summary())  # Test de Breusch‑Pagan, Durbin‑Watson, etc.

• Toujours visualiser les données – nuages de points, distributions, corrélations.
• Normaliser les variables – indispensable si les échelles diffèrent (sauf pour les arbres). Les coefficients deviennent alors comparables.
• Utiliser la validation croisée – pour estimer la performance réelle et éviter le sur‑apprentissage.
• Méfiez‑vous des outliers – ils peuvent tirer la droite. Envisagez des transformations robustes (RANSAC, Huber).
• Ne pas confondre corrélation et causalité – un coefficient élevé n’implique pas une relation causale.

Quand les relations sont très non linéaires et que l’interprétabilité passe au second plan, les arbres de régression (`DecisionTreeRegressor`), les forêts aléatoires (`RandomForestRegressor`) et le gradient boosting (`XGBRegressor`, `LightGBM`) surpassent souvent les modèles linéaires. Ils capturent les interactions complexes et sont insensibles aux échelles. ISOSET propose des modules avancés sur ces algorithmes.

# Forêt aléatoire pour la régression
from sklearn.ensemble import RandomForestRegressor
rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
print(f"R² : {r2_score(y_test, y_pred_rf):.3f}")

Les témoignages d’anciens élèves d’ISOSET : *« La formation régression m’a permis de passer de simples courbes de tendance Excel à des modèles prédictifs robustes (Ridge, Lasso). Aujourd’hui, je prévois les ventes avec une erreur de moins de 5%. »*