Maîtriser la régression pas à pas avec Python : Guide complet

La régression étape par étape est une technique puissante pour sélectionner les variables prédictives les plus pertinentes dans un modèle de régression. En ajoutant ou en supprimant itérativement des variables en fonction de leur signification statistique, elle permet de construire des modèles parcimonieux plus faciles à interpréter et moins sujets au surapprentissage. Cet article explore différentes méthodes de régression étape par étape en Python, en utilisant des bibliothèques populaires comme statsmodels, scikit-learn (sklearn), et mlxtend.

Table des matières

• Sélection ascendante
• Élimination descendante
• Sélection étape par étape (bidirectionnelle)
• Régression étape par étape avec statsmodels
• Régression étape par étape avec sklearn
• Régression étape par étape avec mlxtend
• Choisir la bonne méthode et considérations

Sélection ascendante

La sélection ascendante commence avec un modèle vide et ajoute itérativement la variable prédictive qui améliore le plus significativement l’ajustement du modèle. Cette amélioration est généralement évaluée à l’aide de mesures telles que la statistique F, l’AIC (Akaike Information Criterion) ou le BIC (Bayesian Information Criterion). Le processus se poursuit jusqu’à ce que l’ajout d’une autre variable n’apporte pas d’amélioration statistiquement significative.

Élimination descendante

L’élimination descendante adopte l’approche inverse. Elle commence par un modèle incluant toutes les variables prédictives et supprime itérativement la variable la moins significative. La variable avec la plus haute valeur p (ou la plus faible statistique F) est supprimée à chaque étape, à condition que sa suppression n’empire pas significativement l’ajustement du modèle. Cela continue jusqu’à ce que la suppression de toute variable restante dégrade significativement les performances du modèle.

Sélection étape par étape (bidirectionnelle)

La sélection étape par étape combine les forces de la sélection ascendante et descendante. Elle commence soit avec un modèle vide (comme la sélection ascendante), soit avec un modèle complet (comme l’élimination descendante) et ajoute ou supprime itérativement des variables en fonction de leur signification. Cela permet un sous-ensemble de prédicteurs plus flexible et potentiellement optimal.

Régression étape par étape avec statsmodels

statsmodels ne possède pas de fonction de régression étape par étape intégrée, mais nous pouvons implémenter manuellement la sélection ascendante en utilisant son modèle OLS (Ordinary Least Squares) :

import pandas as pd
import numpy as np
import statsmodels.api as sm
from statsmodels.formula.api import ols

# Données d'exemple
data = {'y': [10, 12, 15, 18, 20, 22, 25, 28, 30, 32],
        'x1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        'x2': [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],
        'x3': [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]}
df = pd.DataFrame(data)

def forward_selection(data, target, significance_level=0.05):
    included = []
    while True:
        changed=False
        excluded = list(set(data.columns)-set(included)-{target})
        best_pvalue = 1.0
        best_feature = None
        for new_column in excluded:
            model = sm.OLS(target, sm.add_constant(data[included+[new_column]])).fit()
            pvalue = model.pvalues[new_column]
            if pvalue < best_pvalue:
                best_pvalue = pvalue
                best_feature = new_column
        if best_pvalue < significance_level:
            included.append(best_feature)
            changed=True
        if not changed: break
    return included

selected_features = forward_selection(df, df['y'])
print(f"Variables sélectionnées: {selected_features}")
final_model = sm.OLS(df['y'], sm.add_constant(df[selected_features])).fit()
print(final_model.summary())

Régression étape par étape avec sklearn

sklearn utilise l’élimination récursive de caractéristiques (RFE) pour la sélection de caractéristiques. RFE supprime itérativement les caractéristiques en fonction de leurs scores d’importance à partir d’un modèle de base (comme la régression linéaire) :

from sklearn.linear_model import LinearRegression
from sklearn.feature_selection import RFE
from sklearn.model_selection import train_test_split

X = df.drop('y', axis=1)
y = df['y']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LinearRegression()
rfe = RFE(model, n_features_to_select=2) # Ajuster si nécessaire
rfe = rfe.fit(X_train, y_train)

print(f"Variables sélectionnées: {X.columns[rfe.support_]}")

final_model = LinearRegression().fit(X_train[X.columns[rfe.support_]], y_train)
print(f"R-carré sur l'ensemble de test: {final_model.score(X_test[X.columns[rfe.support_]], y_test)}")

Régression étape par étape avec mlxtend

SequentialFeatureSelector de mlxtend fournit un moyen pratique d’effectuer une sélection ascendante, descendante ou étape par étape :

from mlxtend.feature_selection import SequentialFeatureSelector as SFS
from sklearn.linear_model import LinearRegression

model = LinearRegression()
sfs = SFS(model, k_features='best', forward=True, floating=False, scoring='r2', cv=5) #sélection ascendante

sfs = sfs.fit(X, y)

print(f"Variables sélectionnées: {list(sfs.k_feature_idx_)}")

final_model = LinearRegression().fit(X[X.columns[list(sfs.k_feature_idx_)]], y)

Choisir la bonne méthode et considérations

Le choix de la méthode de régression étape par étape (ascendante, descendante ou étape par étape) et de la bibliothèque utilisée dépend des données et des objectifs spécifiques. N’oubliez pas de prendre en compte :

• Taille des données : L’élimination descendante peut être coûteuse en calcul avec un grand nombre de prédicteurs.
• Multicolinéarité : Les méthodes étape par étape peuvent avoir des difficultés avec des prédicteurs fortement corrélés.
• Interprétation vs. précision prédictive : Un modèle plus simple (moins de variables) peut être plus facile à interpréter, même s’il est légèrement moins précis.
• Validation croisée : Validez toujours votre modèle à l’aide de techniques telles que la validation croisée k-fold pour garantir la généralisation.

La régression étape par étape doit être utilisée avec prudence. Elle peut conduire à des modèles instables qui ne se généralisent pas bien aux nouvelles données. Envisagez d’explorer d’autres méthodes de sélection de caractéristiques telles que LASSO ou la régression Ridge, qui intègrent la régularisation pour gérer le surapprentissage.