Régression linéaire simple et multiple

La régression linéaire est un modèle statistique utilisé pour analyser la relation entre une variable dépendante (ou cible) et une ou plusieurs variables indépendantes (ou prédicteurs). Cette méthode est très utilisée en analyse prédictive et en apprentissage automatique.

Régression Linéaire Simple

La régression linéaire simple consiste à modéliser la relation entre une seule variable dépendante

$y$

$y$ et une seule variable indépendante

$x$

$x$ . Le modèle linéaire est représenté par l’équation :

$y = \beta_0 + \beta_1 x + \epsilon$

$y = β_{0} + β_{1} x + ϵ$

où :

$y$ $y$ : variable dépendante (cible),
$x$ $x$ : variable indépendante (prédicteur),
$\beta_0$ $β_{0}$ : intercept (ordonnée à l’origine),
$\beta_1$ $β_{1}$ : pente (coefficient de régression),
$\epsilon$ $ϵ$ : erreur (terme aléatoire ou bruit).

L’objectif de la régression linéaire simple est de trouver les valeurs des paramètres

$\beta_0$

$β_{0}$ et

$\beta_1$

$β_{1}$ qui minimisent la somme des carrés des erreurs (SSE, Sum of Squared Errors).

Hypothèses de la Régression Linéaire Simple

Linéarité : La relation entre

$x$ $x$ et

$y$ $y$ est linéaire.
Indépendance : Les observations sont indépendantes.
Homoscedasticité : La variance des erreurs est constante pour toutes les valeurs de

$x$ $x$ .
Normalité des erreurs : Les erreurs doivent suivre une distribution normale.

Interprétation des Paramètres

$\beta_0$ $β_{0}$ (l’intercept) : C’est la valeur de

$y$ $y$ lorsque

$x = 0$ $x = 0$ .
$\beta_1$ $β_{1}$ (la pente) : C’est la variation de

$y$ $y$ associée à une unité de variation de

$x$ $x$ . Si

$\beta_1$ $β_{1}$ est positif, cela signifie que la relation entre

$x$ $x$ et

$y$ $y$ est positive (augmentation de

$x$ $x$ entraîne une augmentation de

$y$ $y$ ).

Régression Linéaire Multiple

La régression linéaire multiple étend la régression linéaire simple à plusieurs variables indépendantes. Elle est utilisée pour prédire une variable dépendante

$y$

$y$ à partir de plusieurs variables indépendantes

$x_1, x_2, \dots, x_n$

$x_{1}, x_{2}, \dots, x_{n}$ .

Le modèle de régression linéaire multiple est représenté par l’équation :

$y = \beta_0 + \beta_1 x_1 + \beta_2 x_2 + \dots + \beta_n x_n + \epsilon$

$y = β_{0} + β_{1} x_{1} + β_{2} x_{2} + \dots + β_{n} x_{n} + ϵ$

où :

$y$ $y$ : variable dépendante,
$x_1, x_2, \dots, x_n$ $x_{1}, x_{2}, \dots, x_{n}$ : variables indépendantes,
$\beta_0$ $β_{0}$ : intercept,
$\beta_1, \beta_2, \dots, \beta_n$ $β_{1}, β_{2}, \dots, β_{n}$ : coefficients des variables indépendantes,
$\epsilon$ $ϵ$ : erreur.

L’objectif est également de trouver les paramètres

$\beta_0, \beta_1, \dots, \beta_n$

$β_{0}, β_{1}, \dots, β_{n}$ qui minimisent la somme des carrés des erreurs.

Hypothèses de la Régression Linéaire Multiple

Les hypothèses restent similaires à celles de la régression linéaire simple, mais il faut aussi considérer les relations entre les variables indépendantes :

Multicolinéarité : Les variables indépendantes ne doivent pas être fortement corrélées entre elles. Si elles le sont, cela peut rendre l’estimation des coefficients peu fiable.

Interprétation des Paramètres

$\beta_0$ $β_{0}$ (intercept) : C’est la valeur prédite de

$y$ $y$ lorsque toutes les variables

$x_1, x_2, \dots, x_n$ $x_{1}, x_{2}, \dots, x_{n}$ sont égales à zéro.
$\beta_1, \dots, \beta_n$ $β_{1}, \dots, β_{n}$ : Ce sont les effets des variables

$x_1, x_2, \dots, x_n$ $x_{1}, x_{2}, \dots, x_{n}$ sur

$y$ $y$ , tout en maintenant les autres variables constantes. Par exemple,

$\beta_1$ $β_{1}$ représente la variation de

$y$ $y$ lorsque

$x_1$ $x_{1}$ change de 1 unité, en gardant les autres variables constantes.

Évaluation de la Régression Linéaire

Voici quelques mesures de performance courantes utilisées pour évaluer la qualité d’un modèle de régression linéaire :

$R^2$ $R^{2}$ (Coefficient de Détermination) : Cette mesure indique la proportion de la variance de la variable dépendante qui est expliquée par les variables indépendantes. Plus

$R^2$ $R^{2}$ est proche de 1, meilleur est le modèle.

$R^2 = 1 – \frac{\sum_{i=1}^{n} (y_i – \hat{y}_i)^2}{\sum_{i=1}^{n} (y_i – \bar{y})^2}$ $R^{2} = 1 - \sum ^{i = 1 n} ( y ^{i} - y ˉ ) ^{2} \sum ^{i = 1 n} ( y ^{i} - y ^ ^{i} ) ^{2}$

où

$\hat{y}_i$ $y^_{i}$ est la valeur prédite, et

$\bar{y}$ $y ˉ$ est la moyenne de

$y$ $y$ .
Erreur quadratique moyenne (RMSE) : Elle mesure la différence entre les valeurs observées et les valeurs prédites. Plus elle est faible, mieux c’est.

$RMSE = \sqrt{\frac{1}{n} \sum_{i=1}^{n} (y_i – \hat{y}_i)^2}$ $RMSE = n 1 i = 1 \sum n (y^{i} - y^^{i})^{2}$
Erreur absolue moyenne (MAE) : C’est la moyenne des erreurs absolues entre les valeurs observées et les valeurs prédites.

$MAE = \frac{1}{n} \sum_{i=1}^{n} |y_i – \hat{y}_i|$ $M A E = n 1 i = 1 \sum n ∣ y_{i} - y^_{i} ∣$

Fonctions :

LinearRegression()

La fonction LinearRegression() de scikit-learn permet de réaliser une régression linéaire, c'est-à-dire de modéliser la relation entre une ou plusieurs variables indépendantes et une variable dépendante. Elle ajuste une droite (ou un hyperplan) qui minimise l'erreur quadratique entre les points observés et la droite prédit. La régression linéaire est l'un des modèles les plus utilisés pour la prédiction dans les problèmes de régression.

Importation :

from sklearn.linear_model import LinearRegression

Attributs :

Nom	Type	Description
fit_intercept	bool, optionnel	Indique si l'algorithme doit calculer l'ordonnée à l'origine (par défaut, True).
normalize	bool, optionnel	Si True, les variables d'entrée sont normalisées avant d'ajuster le modèle (par défaut, False).
n_jobs	int, optionnel	Nombre de jobs à utiliser pour effectuer la régression (par défaut, 1). Utiliser -1 pour utiliser tous les processeurs disponibles.
positive	bool, optionnel	Si True, les coefficients de régression sont contraints à être positifs (par défaut, False).

Exemple de code :

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

# Création de données d'exemple
X = np.array([[1], [2], [3], [4], [5]])  # Variable indépendante
y = np.array([1, 2, 1.5, 3.5, 2.5])      # Variable dépendante

# Initialisation du modèle de régression linéaire
model = LinearRegression()

# Entraînement du modèle sur les données
model.fit(X, y)

# Prédiction
y_pred = model.predict(X)

# Affichage des résultats
plt.scatter(X, y, color='blue', label='Données réelles')
plt.plot(X, y_pred, color='red', label='Droite de régression')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()

# Affichage des coefficients
print(f'Coefficient de régression: {model.coef_[0]}')
print(f'Ordonnée à l\'origine: {model.intercept_}')

Explication du code :

from sklearn.linear_model import LinearRegression importe la classe LinearRegression de la bibliothèque scikit-learn, qui permet de créer un modèle de régression linéaire.

import numpy as np importe la bibliothèque numpy, renommée ici en np, qui est utilisée pour manipuler des tableaux (arrays) et effectuer des opérations numériques.

import matplotlib.pyplot as plt importe la bibliothèque matplotlib, renommée ici en plt, utilisée pour créer des graphiques et des visualisations.

Création de données d'exemple

X = np.array([[1], [2], [3], [4], [5]]) crée un tableau X représentant la variable indépendante (ou prédicteur) sous forme de tableau à une seule colonne.

y = np.array([1, 2, 1.5, 3.5, 2.5]) crée un tableau y représentant la variable dépendante (ou cible), que l'on souhaite prédire en fonction de X.

Initialisation du modèle de régression linéaire

model = LinearRegression() initialise un objet model de la classe LinearRegression, qui est le modèle de régression linéaire utilisé pour ajuster une droite aux données.

Entraînement du modèle sur les données

model.fit(X, y) entraîne le modèle de régression linéaire sur les données X (variables indépendantes) et y (variable dépendante). Cela permet de calculer les coefficients de la droite de régression.

Prédiction

y_pred = model.predict(X) effectue une prédiction sur les données d'entrée X en utilisant le modèle entraîné. Cela génère les valeurs prédites y_pred.

Affichage des résultats

plt.scatter(X, y, color='blue', label='Données réelles') crée un graphique en nuage de points représentant les données réelles (avec X sur l'axe des abscisses et y sur l'axe des ordonnées), affichées en bleu.

plt.plot(X, y_pred, color='red', label='Droite de régression') trace la droite de régression, qui est le modèle prédit par y_pred, en rouge.

plt.xlabel('X') ajoute un label à l'axe des abscisses.

plt.ylabel('y') ajoute un label à l'axe des ordonnées.

plt.legend() affiche la légende du graphique pour différencier les données réelles de la droite de régression.

plt.show() affiche le graphique final.

Affichage des coefficients

print(f'Coefficient de régression: {model.coef_[0]}') affiche le coefficient de régression (la pente de la droite) du modèle. Il représente le changement de y pour chaque unité de changement dans X.

print(f'Ordonnée à l\'origine: {model.intercept_}') affiche l'ordonnée à l'origine de la droite de régression (l'intersection avec l'axe des ordonnées), c'est-à-dire la valeur de y lorsque X = 0.