Régression linéaire avec sklearn : guide complet avec exemples

La régression linéaire est une technique essentielle en statistiques et en apprentissage automatique qui permet de modéliser la relation entre des variables. En termes simples, elle permet de prédire une valeur cible à partir d’un ou plusieurs facteurs explicatifs. Elle est largement utilisée pour l’estimation des prix immobiliers, la prévision des ventes, l’évaluation des risques, et bien d’autres domaines.

Dans ce tutoriel, nous allons explorer la régression linéaire avec scikit-learn : comment elle fonctionne, pourquoi elle est utile, et comment l’implémenter. À la fin, vous serez en mesure de construire et d’évaluer un modèle de régression linéaire pour réaliser des prédictions basées sur les données.

Nuage de points : prix des maisons en fonction du nombre de pièces

Régression linéaire et apprentissage automatique

Au-delà de son utilité immédiate pour estimer des prix immobiliers, la régression linéaire joue un rôle clé en apprentissage automatique.

• Elle constitue un modèle de base pour comprendre des techniques plus avancées comme la régression logistique, les réseaux de neurones et les machines à vecteurs de support.
• Elle est rapide à entraîner, idéale pour le prototypage.
• Elle sert aussi de référence de comparaison. Si des modèles plus complexes ne font pas nettement mieux, leur complexité supplémentaire n’est peut-être pas justifiée.
• Contrairement à certaines approches (comme le deep learning), elle est facilement interprétable.
• Elle aide à la sélection de variables, en identifiant les meilleurs prédicteurs.

Malgré sa simplicité, la régression linéaire reste un outil indispensable en machine learning grâce à son efficacité, son interprétabilité et sa polyvalence.

Régression linéaire et bibliothèque scikit-learn

La bibliothèque scikit-learn simplifie grandement l’implémentation de la régression linéaire. Elle présente de nombreux atouts.

• Une interface cohérente : le code pour différents algorithmes de ML est similaire.
• Un code concis : les détails mathématiques et d’implémentation sont encapsulés. Par exemple, pour entraîner un modèle sur un jeu d’entraînement, il suffit d’utiliser model.fit(X_train, y_train).
• Accès simple aux coefficients du modèle.
• Métriques intégrées pour évaluer les performances.
• Intégration aisée avec les étapes de prétraitement (mise à l’échelle, sélection de variables) via Pipeline.

Si vous débutez avec scikit-learn, consultez notre cours Machine learning avec scikit-learn pour une initiation pratique à la bibliothèque Python. 

Comprendre la régression linéaire

Comme nous l’avons vu, en régression linéaire simple, les données sont modélisées par une « droite de meilleure adéquation ». Sa formule est : 

où m est la pente de la droite et b l’ordonnée à l’origine.

La « régression linéaire multiple » généralise le cas à plusieurs prédicteurs (nombre de pièces, proximité de l’océan, revenu médian du quartier). La formule devient : 

où chaque x_i est une variable indépendante et le b_i correspondant est son coefficient. En trois dimensions, la droite devient un plan. Au-delà, il s’agit d’un « hyperplan ».

Comment interpréter les coefficients et l’ordonnée à l’origine ? L’ordonnée à l’origine est la valeur prédite de y lorsque toutes les variables indépendantes valent 0, autrement dit la valeur de base de la variable cible en l’absence de contribution des prédicteurs. Chaque coefficient b_i représente la variation de y pour une augmentation d’une unité de x_i, toutes choses égales par ailleurs.

Préparer l’environnement

L’installation de scikit-learn est simple : utilisez pip install scikit-learn. Pour installer une version précise, par exemple 1.2.2, ajoutez la version : pip install scikit-learn==1.2.2. Si vous utilisez Anaconda, scikit-learn est généralement déjà installé. Si besoin, avec Anaconda, utilisez conda install scikit-learn.

Plusieurs bibliothèques sont nécessaires ou recommandées avec scikit-learn. La bibliothèque numpy est requise pour stocker les variables explicatives et les étiquettes. La bibliothèque pandas est recommandée pour charger, prétraiter et explorer les jeux de données. 

Si vous utilisez scikit-learn, vous utilisez très probablement déjà pandas pour la préparation des données. Pour tracer vos résultats, vous utiliserez sans doute matplotlib ou seaborn, voire les deux. Toutes ces bibliothèques s’installent via pip, comme dans l’exemple ci-dessus. Vous pouvez même installer plusieurs bibliothèques en une seule commande :

pip install scikit-learn numpy pandas matplotlib seaborn.

Implémenter la régression linéaire avec sklearn

Avant de charger le jeu de données, importons les incontournables.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Charger le jeu de données

Utilisons le célèbre jeu de données California housing.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

Préparer les données

Scindons les données en ensembles d’entraînement et de test. Nous importons la fonction train_test_split() depuis sklearn.model_selection, puis nous l’appelons en précisant la taille de l’ensemble de test et un random_state. Nous utiliserons aussi une régression linéaire simple, avec la variable correspondant au nombre moyen de pièces.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Maintenant que nous avons séparé les jeux d’entraînement et de test, standardisons les variables. Cette étape garantit que toutes les variables sont sur la même échelle, ce qui peut améliorer les performances et la stabilité numérique du modèle.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

Dans ce code, StandardScaler est un outil de prétraitement qui centre les variables (moyenne nulle) et les met à l’échelle (variance unitaire). Cela évite que certaines variables dominent le modèle à cause de différences d’échelle.

Le scaler est ajusté sur les données d’entraînement via fit_transform(). Les données de test sont ensuite transformées avec transform() pour garantir l’usage des mêmes paramètres de mise à l’échelle et éviter toute fuite de données.

Entraîner le modèle de régression linéaire

Pour créer un modèle de régression linéaire, importez LinearRegression() depuis sklearn.linear_model. Instanciez-le et affectez-le à une variable.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

L’ajustement du modèle sur les données d’entraînement est direct.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Réaliser des prédictions

Maintenant que le modèle est entraîné, générons des prédictions sur l’ensemble de test.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Évaluer les performances du modèle

Maintenant que nous avons des prédictions sur l’ensemble de test, évaluons leur adéquation avec la réalité. Plusieurs métriques existent pour juger un algorithme de régression. Les plus courantes sont le coefficient de détermination (R²), l’erreur quadratique moyenne (MSE) et la racine de l’erreur quadratique moyenne (RMSE).

Le coefficient de détermination, noté R², mesure la part de la variabilité de la variable cible expliquée par le modèle. Autrement dit, il quantifie la qualité de l’ajustement.

Pour aller plus loin, observons la formule :

où yactual sont les valeurs observées, ypredicted les valeurs prédites par le modèle, et ȳ la moyenne des valeurs observées. Le dénominateur représente la variance totale, tandis que le numérateur représente la variance non expliquée après la régression. Le rapport indique donc la proportion de variance expliquée par le modèle.

Comment interpréter R² ?

• R² = 1 : le modèle explique parfaitement toute la variance de la cible. 
• R² = 0 : le modèle n’explique aucune variance ; il ne fait pas mieux que la moyenne. 
• R² < 0 : le modèle fait pire que la moyenne ; l’ajustement est médiocre.

Points de vigilance :

• Un R² élevé n’est pas toujours synonyme de meilleur modèle. Il peut révéler du surapprentissage, surtout avec des modèles complexes. 
• Ajouter des variables augmente souvent artificiellement R² ; une valeur plus élevée n’est pas forcément préférable.
• En régression multiple, privilégiez le R² ajusté, qui tient compte du nombre de prédicteurs et évite des améliorations trompeuses.

Évaluer les performances avec le coefficient de détermination est très simple avec scikit-learn.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

D’autres métriques courantes sont la MSE (erreur quadratique moyenne) et la RMSE (racine de l’erreur quadratique moyenne). Elles mesurent l’écart entre les prédictions du modèle et les valeurs réelles.

La MSE calcule la moyenne des carrés des écarts entre valeurs réelles et prédites : 

pour un nombre total d’observations n. Comme les erreurs sont élevées au carré, les grandes erreurs sont davantage pénalisées, ce qui rend la MSE sensible aux valeurs aberrantes. Une MSE plus faible indique un meilleur ajustement.

Pour pallier cela, on utilise la RMSE, qui est simplement la racine carrée de la MSE. Comme la RMSE s’exprime dans la même unité que la variable cible, elle est plus interprétable pour quantifier l’erreur moyenne des prédictions.

Calculer MSE et RMSE avec scikit-learn est également très simple.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Utiliser la régression linéaire multiple avec scikit-learn

Relançons le modèle en utilisant toutes les variables disponibles, et pas seulement le nombre moyen de pièces. Attendez-vous à de meilleurs résultats ?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

Les résultats sont bien meilleurs qu’avec une seule variable. Cela pose toutefois la question : avons-nous besoin de toutes les variables ? Certaines sont-elles plus pertinentes que d’autres ? Le choix des variables les plus utiles s’appelle la sélection de variables.

La sélection de variables est importante pour plusieurs raisons :

• Réduire le surapprentissage : moins de variables signifie moins de complexité et donc moins de risque d’overfitting.
• Améliorer la précision : retirer les variables inutiles ou redondantes aide le modèle à capter les bons signaux.
• Renforcer l’interprétabilité : on comprend mieux le modèle en mettant en avant les facteurs clés.
• Accélérer l’entraînement : moins de variables, c’est moins de calcul et de mémoire.

Lorsque plusieurs variables sont fortement corrélées, elles sont redondantes, c’est-à-dire qu’elles transmettent la même information au modèle. Cette situation est appelée multicolinéarité. Si elle n’altère pas toujours la précision prédictive, elle complique la sélection et l’interprétation des variables, en particulier en régression linéaire et modèles apparentés.

Le facteur d’inflation de variance (VIF) est une mesure pour détecter la multicolinéarité entre prédicteurs. Pour chaque variable, il est défini comme : 

où R_i² est la valeur de R² obtenue en régressant le prédicteur X_i sur tous les autres. Un VIF élevé indique une forte corrélation avec d’autres variables.

• VIF = 1 : pas de multicolinéarité (idéal).
• VIF < 5 : multicolinéarité faible à modérée (généralement acceptable).
• VIF > 5 : multicolinéarité élevée (envisager de supprimer ou combiner des variables corrélées).
• VIF > 10 : multicolinéarité sévère (forte redondance).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Supprimons AveBedrms du modèle.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

Les résultats sont (légèrement) améliorés.

Extraire des insights du modèle

Construire un modèle de régression n’est qu’une première étape ; comprendre ses sorties est tout aussi important. En analysant les coefficients, on peut identifier les variables qui influencent le plus les prédictions.

Comprendre les coefficients de régression

Une fois le modèle entraîné, on accède aux coefficients via model.coef_ et à l’ordonnée à l’origine via model.intercept_.

Après l’entraînement avec LinearRegression(), les coefficients sont disponibles via model.coef_ et l’ordonnée à l’origine via model.intercept_.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Synthétiser les résultats du modèle

Comme Scikit-Learn ne fournit pas de méthode summary() intégrée comme Statsmodels, nous pouvons extraire et visualiser manuellement l’importance de chaque variable à l’aide des coefficients. Les coefficients de plus grande valeur absolue ont un impact plus fort sur la variable cible. Considérez le code suivant.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Graphique d’importance des variables basé sur les coefficients

Visualisons maintenant les résidus et l’ajustement de la régression.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Graphiques pour visualiser les résidus et l’ajustement de la régression

La distribution des résidus (graphique de gauche) doit être centrée autour de zéro, signe d’erreurs aléatoires. Si les résidus suivent une loi normale, le modèle s’ajuste bien ; une asymétrie ou une tendance peut révéler des erreurs systémiques. L’ajustement de la régression (graphique de droite) compare valeurs réelles et prédites, la ligne pointillée rouge représentant l’ajustement parfait. Plus les points suivent cette ligne, plus les prédictions sont précises ; l’apparition d’un motif (par exemple une courbe) peut indiquer que la relation n’est pas vraiment linéaire. 

Ces visualisations aident à diagnostiquer surapprentissage ou sous-apprentissage, à repérer des motifs dans les résidus suggérant des relations manquantes, et à évaluer clairement l’efficacité du modèle.

Cas d’usage concrets

La régression linéaire est largement utilisée dans de nombreux secteurs pour la prédiction et l’aide à la décision. En immobilier, elle estime le prix des logements selon la surface, l’emplacement, etc. 

En ventes et marketing, elle sert à la prévision de la demande et à l’optimisation des budgets ; en santé, à l’évaluation des risques de maladie. En finance, elle contribue à la prédiction des cours et au scoring de crédit ; en industrie, au contrôle qualité et à la prédiction des pannes. 

Quand utiliser la régression linéaire

• Les variables explicatives et la cible ont une relation linéaire.
• L’interprétabilité et la simplicité priment sur la complexité.
• Les données nécessitent peu de feature engineering.

Quand ne pas l’utiliser

• La relation entre la cible et les variables est complexe et non linéaire.
• Les variables sont fortement corrélées.
• Les données contiennent des valeurs aberrantes qu’il est impossible de retirer. Dans ce cas, vous pouvez appliquer des transformations ou utiliser des stratégies pour atténuer leur impact.

Conclusion

La régression linéaire demeure l’une des techniques les plus fondamentales et les plus utilisées en apprentissage automatique et en modélisation statistique. Malgré sa simplicité, elle est puissante pour comprendre les relations entre variables et réaliser des prédictions dans de nombreux cas réels.

À retenir :

• Applications variées : la régression linéaire apporte des insights précieux dans de multiples secteurs et types de problèmes.
• Interprétable : à l’inverse des modèles « boîte noire », elle fournit des interprétations claires basées sur les coefficients.
• Sélection de variables : un choix pertinent des variables et la gestion de la multicolinéarité garantissent des modèles précis, stables et fiables. 

Pour plus d’informations sur l’interpolation de chaînes en Python, consultez les ressources DataCamp.

• Simple Linear Regression: Everything You Need to Know - Tutoriel
• How to Do Linear Regression in R - Tutoriel
• Linear Regression in Excel: A Comprehensive Guide For Beginners - Tutoriel
• Introduction to Regression in R - Cours
• Supervised Learning with scikit-learn - Cours
• Scikit-Learn Cheat Sheet: Python Machine Learning - Fiche mémo
• Understanding Logistic Regression in Python - Tutoriel