Tuto Python & Scikit-learn : la régression linéaire

Table des matières

Introduction

La régression linéaire est l’un des principaux modèles à aborder en Machine Learning. À vrai dire, il n’existe pas qu’un seul type de régression. On distingue la régression de type linéaire mais aussi la régression logistique. Lors de ce tutoriel, nous n’aborderons que la régression linéaire en utilisant la bibliothèque d’apprentissage automatique Scikit-learn.

1. Définition

Une régression a pour objectif d’expliquer une variable Y par le moyen d’une autre variable X. Par exemple, le salaire d’une personne peut être expliqué à travers son niveau universitaire ; c’est à dire le nombre d’années passées à l’université.

La régression linéaire est alors modélisée par l’équation linéaire suivante qui met en relation X et Y :

Où

et
sont les paramètres du modèle ;
X est la variable explicative ;
Y est la variable expliquée ;
est l’erreur de l’estimation.

Puisqu’on a une seule variable explicative, alors on est dans le cas de la régression linéaire simple. Par conséquent, la régression linéaire multiple est lorsque vous avez au moins deux variables explicatives.

2. Module Scikit-learn

Nous aborderons dans ce qui suit les modules fournis par la bibliothèque d’apprentissage automatique Scikit-learn pour implémenter les fonctions de régression. Dans un premier temps, nous allons commencer par un exemple de régression linéaire simple ensuite nous allons voir un exemple de régression linéaire multiple.

2.1. Régression linéaire simple

La régression linéaire est l’une des techniques les plus utilisées dans l’apprentissage automatique et cela revient principalement à sa simplicité et la facilité d’interprétation de ses résultats. Comme on a pris l’habitude d’appliquer le modèle d’apprentissage sur un exemple pour le voir en action, on va procéder ainsi pour l’algorithme de régression linéaire simple.

Tout d’abord, on importe le package NumPy et la classe LinearRegression. Ensuite, on définit les données x et y sur lesquelles le modèle va performer et s’exécuter. On fait appel à la méthode reshape() parce que le tableau x doit être bidimensionnel.

L’étape suivante consiste à créer une instance de la classe LinearRegression et on entraine celle-ci sur notre ensemble de données à l’aide de la méthode fit().. On calcule ensuite la précision du modèle à l’aide de la méthode score(). Ainsi, Le résultat obtenu par cette méthode est également le coefficient de détermination (R²).

Finalement, on fait de la prédiction en appelant la méthode predict() appliquée sur notre modèle.

Code :

import numpy as np
from sklearn.linear_model import LinearRegression
#données
x = np.array([6, 8, 10, 14, 18]).reshape((-1, 1))
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
model_linReg = LinearRegression()
#entrainement du modèle
model_linReg.fit(x, y)
#précision du modèle
precision = model_linReg.score(x, y)
print(precision*100)
#prédiction
prediction = model_linReg.predict(x)
print(prediction)

Résultat de l’exécution :

2.1.1. Paramètres du modèle LinearRegression

Le modèle LinearRegression peut prendre plusieurs paramètres optionnels, à savoir :

fit_intercept : prend une valeur booléenne qui calcule l’interception
si elle est mise à la valeur True, sinon elle prend la valeur zéro. Ce paramètre prend True par défaut.
normalize : prend une valeur booléenne qui normalise les variables d’entrée si elle est mise à True ou non sinon. Ce paramètre prend False par défaut.
copy_X : prend une valeur booléenne qui copie les variables d’entrée si True, sinon elle les écrase. Par défau,t il prend la valeur True.
n_jobs : prend une valeur entière (ou None par défaut) et représente le nombre d’emplois utilisés dans le calcul parallèle.

2.1.2. Les attributs du modèle LinearRegression

Les attributs du modèle LinearRegression simple sont :

intercept_ : qui permet de calculer le paramètre
.
coef_ : qui permet de calculer le paramètre
1.

Code :

model_linReg.intercept_
model_linReg.coef_

Résultat de l’exécution :

Remarque :

On peut réaliser la même prévision sans avoir à faire appel à la méthode predict() et cela en ajoutant à intercept_ appliquée au modèle la multiplication du coef_ appliquée au modèle par x .

La seule différence entre la prévision ci-dessous et la prévision obtenue à l’aide de la méthode precidt() est que dans la première on a obtenu un tableau bidimensionnel et dans la deuxième on a un tableau à une seule dimension.

Code :

prediction = model_linReg.intercept_ + model_linReg.coef_*x
print(prediction)

Résultat de l’exécution :

2.2. Régression linéaire multiple

Pour mettre en œuvre la régression linéaire multiple, on suit les mêmes étapes précédemment citées pour la régression linéaire simple. Tout d’abord, on importe le package NumPy et la classe LinearRegression.Ensuite, on définit les données x et y sur lesquelles le modèle va performer.

Pour la régression linéaire multiple, x est bidimensionnel contenant au moins deux colonnes et y, quand à lui, représente un tableau d’une dimension unique. L’étape qui suit consiste à créer une instance de la classeLinearRegression et on entraine celle-ci sur notre ensemble de données à l’aide de la méthode fit().

On calcule la précision du modèle à l’aide de la méthode score(). Le résultat obtenu par cette méthode est également le coefficient de détermination (R²). Finalement, on réalise une prédiction en appelant la méthodepredict() appliquée sur notre modèle.

Code :

import numpy as np
from sklearn.linear_model import LinearRegression
#données
x = np.array([[5, 1], [8, 2], [10, 13], [14, 15], [18, 9]])
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
model_linRegMul = LinearRegression()
#entrainement du modèle
model_linRegMul.fit(x, y)
#précision du modèle
precision = model_linRegMul.score(x, y)
print(precision*100)
#prédiction
test = np.arange(10).reshape((-1, 2))
prediction = model_linRegMul.predict(test)
print(prediction)

Résultat de l’exécution :

2.2.1. Attribut

On applique les attributs du modèle LinearRegression multiple pour notre exemple :

Code :

model_linRegMul.intercept_
model_linRegMul.coef_

Résultat de l’exécution :

3. Cas d’utilisation

En général, la régression est utilisée pour avoir une idée concernant comment les liaisons de variables entre elles. Cette méthode est également utile pour faire de la prévision, par exemple on peut prévoir la consommation d’électricité d’un ménage pour une période compte tenu du nombre de résidents dans celui-ci, de la température extérieure et de l’heure de la journée.

De nos jours, l’utilisation de la régression augmente de plus en plus vu la disponibilité de grandes quantités de données et la sensibilisation de l’importance de ces dernières.

4. Avantages et limites

4.1. Avantages

Comme mentionné précédemment, la régression linéaire est simple à mettre en œuvre et donne des résultats satisfaisants. Les modèles de régression peuvent être formés facilement et efficacement. Ils ont aussi une complexité temporelle considérablement faible par rapport à d’autres modèles d’apprentissage automatique. Cet algorithme performe sur des ensembles de données séparables linéairement et il est ainsi souvent appliqué pour déterminer la nature de la relation entre les variables.

4.2. Limites

Lors de l’application des modèles de régression, les valeurs aberrantes peuvent avoir des effets énormes sur la régression. Il est possible dans certains cas qu’on retrouve des situations de sous-ajustement (underfitting), et cela lorsque le modèle d’apprentissage automatique ne parvient pas à saisir les données correctement ce qui est généralement le résultat d’une fonction d’hypothèse mal adaptée aux données. La régression linéaire suppose alors que les données d’entrée sont indépendantes l’une de l’autre.

5. Exercices

5.1. Exercice 1

Appliquez la régression linéaire sur la dataset « iris ».

5.2. Exercice 2

Appliquez la régression linéaire sur la dataset « Boston » de scikit-learn. Utilisez le code suivant pour afficher une description détaillé de la dataset :

Code :

from sklearn import datasets
données = datasets.load_boston()
print(données.DESCR)

Résultat de l’exécution :

5.3. Exercice 3

Générez un problème de régression aléatoire à l’aide de make_regression, et appliquer le modèle de régression linéaire.

5.4. Exercice 4

Appliquez la régression linéaire sur un ensemble de données généré aléatoirement.

6. Solution des exercices

6.1. Exercice 1

Dans cet exercice, on souhaite prévoir la largeur d’un iris. Tout d’abord, on importe le package pandas et la classe LinearRegression. Ensuite, on définit les variables x et y sur lesquelles le modèle va performer. L’étape suivante consiste à créer une instance de la classe LinearRegression et on entraine celle-ci sur notre ensemble de données à l’aide de la méthode fit().

On calcule la précision du modèle à l’aide de la méthode score(). Finalement, on fait de la prédiction en appelant la méthode predict() appliquée sur notre modèle.

Code :

import pandas as pd
from sklearn.linear_model import LinearRegression
#données
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/iris.csv')
df.head()
x = df[["petal_length"]]
y = df["petal_width"]
#instancier modèle
model_linReg = LinearRegression()
#entrainement du modèle
model_linReg.fit(x, y)
#précision du modèle
precision = model_linReg.score(x, y)
print(precision*100)
#prédiction
longueur = 2.5
prediction = model_linReg.predict([[longueur]])
print(prediction)

Résultat de l’exécution :

6.2. Exercice 2

Dans cet exercice, on utilise l’ensemble de données concernant les prix de l’immobilier à Boston. Tout d’abord, on importe le package pandas, linear_model et datasets. Ensuite, on définit les variables x et y sur lesquelles le modèle va performer. On crée une instance de la classe LinearRegression et on entraine celle-ci sur notre ensemble de données à l’aide de la méthode fit().

On calcule la précision du modèle à l’aide de la méthode score(). Finalement, on fait de la prédiction en appelant la méthode predict() appliquée sur notre modèle.

Code :

from sklearn import linear_model
from sklearn import datasets
import pandas as pd
#charger la dataset Boston
données = datasets.load_boston()
df = pd.DataFrame(données.data, columns = données.feature_names)
df.head()
# données cible dans un nouveau dataframe
cible = pd.DataFrame(data.target, columns = ["MEDV"])
x = df
y = cible["MEDV"]
#instancier modèle
model_linReg = linear_model.LinearRegression()
#training
model_linReg.fit(x,y)
#prédiction
prediction = model_linReg.predict(x)
print(prediction[0:5])

Résultat de l’exécution :

6.3. Exercice 3

Dans cet exercice, on importe la classe LinearRegression et make_regression. À l’aide de cette dernière, on va générer un problème de régression aléatoire sur lequel va se baser et s’entraîner notre modèleLinearRegression qu’on a instancié en premier lieu et en lui applique ensuite la méthode fit().

On fait la prédiction en appelant la méthode predict() appliquée sur notre modèle. Finalement, on calcule la précision du modèle à l’aide de la méthode score().

Code :

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
#generer problème de regression aléatoire
x, y = make_regression( n_features = 3, random_state = 0)
#afficher les cinq premiers éléments de x et y
print('les valeurs de x :', x[0:5])
print('les valeurs de y :', y[0:5])
#instancier modèle
model_linReg = LinearRegression()
#entrainement du modèle
model_linReg.fit(x, y)
#Prédiction
prediction = model_linReg.predict( [[0,0,0]])
print('la prediction: ', prediction)
#précision du modèle
precision = model_linReg.score(x, y)

Résultat de l’exécution :

Exercice 4 :

Dans cet exercice, on génère aléatoirement des valeurs d’échantillons et de caractéristiques à l’aide de la méthode randn() sur lesquelles s’entrainera notre modèle de régression linéaire et cela en lui appliquant la méthode fit(). On fait ensuite la prédiction en appelant la méthode predict() appliquée sur le modèle de régression linéaire. Finalement, on calcule la précision du modèle à l’aide de la méthode score().

Code :

import numpy as np
from sklearn.linear_model import LinearRegression
echantillons = 20
caracteristiques = 15
np.random.seed(0)
x = np.random.randn(echantillons, caracteristiques)
y = np.random.randn(echantillons)
#afficher les cinq premiers éléments de x et y
print('les valeurs de x :', x[0:5])
print('les valeurs de y :', y[0:5])
#instancier modèle
model_linReg = LinearRegression()
#entrainement du modèle
model_linReg.fit(x, y)
#Prédiction
prediction = model_linReg.predict(x)
print("la prédiction:" ,prediction)
#précision du modèle
precision = model_linReg.score(x, y)
print("la précision du modèle: ", precision*100)

Résultat de l’exécution :

Conclusion

Dans ce tutoriel, nous avons défini le modèle de régression linéaire simple et multiple. Ainsi nous l’avons appliqué sur plusieurs exemples en utilisant les classes fournies par la bibliothèque d’apprentissage automatique Scikit-learn de Python.

Article publié le 24 Novembre 2020par Imane BENHMIDOU