Régression linéaire avec la bibliothèque Scikit-Learn en Python

La régression linéaire est l’une des techniques fondamentales et populaires en statistiques ainsi qu’en apprentissage automatique. Elle permet de modéliser une relation linéaire entre une variable dépendante (la réponse du système) et une ou plusieurs variables indépendantes (les facteurs ou les Xi). Dans cet article, nous allons explorer ensemble comment mettre en place une régression linéaire en utilisant Python, en mettant l’accent sur sa mise en œuvre pratique et ses applications dans le domaine de l’apprentissage automatique. Nous nous appuierons sur la bibliothèque Scikit-Learn pour l’apprentissage et Matplotlib pour la visualisation. Pour plus d’informations sur ces deux librairies, je présente Scikit-Learn dans cet article et Matplotlib dans celui-ci.

Qu’est-ce qu’une régression linéaire ?

La régression linéaire vise à trouver la meilleure droite (ou hyperplan) qui représente la relation linéaire entre la variable et la réponse de votre système. Elle est généralement exprimée sous la forme d’une fonction affine (équation linéaire) :

y = a x + b

Où :

• y est la réponse (la cible)
• x est la variable indépendante (votre facteur ou Xi)
• a est la pente (coefficient de régression)
• b est l’ordonnée à l’origine (l’intercept)

L’objectif de la régression linéaire est de trouver les valeurs optimales de a et b pour minimiser l’erreur entre les valeurs prédites et les valeurs réelles.

Mise en œuvre de la régression linéaire avec Scikit-Learn en Python

Nous allons maintenant explorer comment mettre en œuvre la régression linéaire en Python en utilisant la bibliothèque populaire scikit-learn. Il faudra dans premier temps s’assurer que la bibliothèque est bien installée. Si ce n’est pas le cas, vous pouvez le faire facilement en tapant la ligne de code suivante dans votre terminal.

pip install scikit-learn

Étape 1 : Importer les bibliothèques

La première étape consiste à importer les modules et bibliothèques que nous utiliserons pour créer notre régression linéaire avec Scikit-Learn en Python. Nous utiliserons la librairie Numpy pour générer les données (je présente la librairie Numpy dans cet article) et Matplotlib pour la visualisation. Ensuite, le module train_test_split nous servira à générer automatiquement des données d’entrainement et des données de test. Enfin, le module LinearRegression, comme son nom l’indique, génèrera le modèle de régression.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

Étape 2 : Préparation des données

Pour illustrer la régression linéaire, nous allons créer un jeu de données factice. Le jeu de données représentent les résultats obtenus à un examen en fonction du temps passé pour les révisions.

# Données factices
x = np.array([2, 4, 6, 7, 8, 10, 12, 14, 16, 18]).reshape(-1, 1)  # Heures passées
y = np.array([35, 42, 50, 53, 60, 65, 70, 75, 80, 85])  # Résultats à l'examen

Vous noterez que pour les heures passées, on doit redimensionner le tableau. En effet, lorsqu’un tableau à une dimension est créé avec np.array(), il est par défaut considéré comme un vecteur (une dimension). Le modèle de prédiction par contre attend une matrice, donc deux dimensions, c’est pourquoi nous utilisons la fonction « reshape » pour ajouter la seconde dimension.

Étape 3 : Diviser les données en ensembles d’apprentissage et de test

Une bonne pratique en apprentissage machine est de créer un jeu de données pour l’apprentissage et un jeu de données pour tester le modèle. Ainsi, les données de test étant indépendantes, on peut estimer la performance du modèle sans interaction avec les données d’entrainement. Pour réaliser cette étape, on utilise le module train_test_split de la librairie Scikit-Learn.

# Diviser les données en ensembles d'apprentissage (80%) et de test (20%)
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

Dans l’exemple présenté, on garde 80% des données pour l’entrainement et 20% pour le test. C’est en général une bonne proportion mais vous pouvez tout à fait les changer suivant le problème que vous souhaitez résoudre.

L’argument random_state permet de rendre le processus aléatoire répétable. En précisant cette valeur, le processus aléatoire se déroule de la même manière à chaque fois. Cela permet de comparer les résultats d’un essai à un autre.

Étape 4 : Créer et entraîner le modèle de régression linéaire

Nous avons maintenant nos données d’entrainement et nos données de tests. Le premier jeu de données va donc être utilisé pour entrainer le modèle. La première étape consiste à créer le modèle et la seconde à l’entrainer avec les données de test.

# Créer le modèle de régression linéaire
model = LinearRegression()

# Entraîner le modèle sur les données d'apprentissage
model.fit(X_train, y_train)

Le modèle est stocké dans la variable model. Ensuite, avec la méthode fit et les données d’entrainement en arguments, le modèle est entrainé.

Étape 5 : Faire des prédictions

Nous avons maintenant un modèle entrainé. L’étape suivante consiste à prédire la réponse avec les données de tests. Pour rappel, les données de test ne sont pas utilisées pour l’entrainement. Nous allons alors comparer les résultats donnés par le modèle par rapport aux données réelles.

# Faire des prédictions sur les données de test
y_pred = model.predict(X_test)

Étape 6 : Visualiser les résultats

# Tracer le nuage de points (données réelles) et la droite de régression
plt.scatter(X_test, y_test, color='blue', label='Données réelles')
plt.plot(X_test, y_pred, color='red', label='Régression linéaire')
plt.xlabel('Heures d\'étude')
plt.ylabel('Scores')
plt.legend()
plt.title('Régression linéaire en Python')
plt.show()

Etape 7 : Performance du modèle de régression

La bibliothèque Scikit-Learn offre des modules permettant d’évaluer la performance des modèles. De plus, une méthode associée au modèle permet de calculer directement la valeur de l’indicateur R².

# Affichage du coefficient de régression et de l'ordonnée à l'origine
print(f'Model coefficient : {model.coef_[0]:.2f}')
print(f'Model intercept : {model.intercept_:.2f}')

# Evaluation de la performance
r2_score = model.score(x,y)
mae = mean_absolute_error(y, model.predict(x))
print(f'Coefficient R² = {r2_score:.2f}')
print(f'Mean absolute error = {mae:.2f}')

Model coefficient : 3.10
Model intercept : 31.75
Coefficient R² = 0.98
Mean absolute error = 1.68

Le coefficient R² est très proche de 1 ce qui signifie que notre modèle permet d’estimer correctement le comportement de notre système. De plus, l’erreur moyenne faite sur la prédiction est de 1.7 environ. Sachant que nous souhaitons prédire une note sur 100, le modèle est donc satisfaisant.

Enfin, une fois le modèle validé, il est alors possible de récupérer les coefficients de la régression pour les réutiliser dans une autre partie de votre programme si besoin.

Synthèse de la régression linéaire avec Scikit-Learn en Python

La régression linéaire est une technique simple et puissante pour modéliser une relation linéaire entre une variable et la réponse du système. Dans cet article, nous avons utilisé Python et la bibliothèque Scikit-Learn pour mettre en application une régression linéaire. N’hésitez pas à explorer davantage cette technique en utilisant des données réelles afin d’optimiser vos processus. Toutes les informations utiles sur la librairie Scikit-Learn sont disponibles sur leur site dont voici le lien.

Enfin, la régression linéaire n’est qu’un des nombreux outils disponibles en apprentissage automatique. Cependant, elle sert de base pour de nombreuses autres techniques plus avancées. Continuez à explorer le vaste domaine de l’apprentissage automatique pour enrichir vos connaissances et développer des modèles encore plus performants pour résoudre divers problèmes du monde réel. N’hésitez pas à parcourir ce site car je vous présente au travers des différents articles comme mettre en place différents types de modèle.