Algorithmes de régression - Régression linéaire

Introduction à la régression linéaire

La régression linéaire peut être définie comme le modèle statistique qui analyse la relation linéaire entre une variable dépendante avec un ensemble donné de variables indépendantes. La relation linéaire entre les variables signifie que lorsque la valeur d'une ou de plusieurs variables indépendantes change (augmente ou diminue), la valeur de la variable dépendante change également en conséquence (augmente ou diminue).

Mathématiquement, la relation peut être représentée à l'aide de l'équation suivante -

Y = mX + b

Ici, Y est la variable dépendante que nous essayons de prédire

X est la variable dépendante que nous utilisons pour faire des prédictions.

m est la pente de la droite de régression qui représente l'effet de X sur Y

b est une constante, connue sous le nom d'ordonnée à l'origine. Si X = 0, Y serait égal à b.

De plus, la relation linéaire peut être de nature positive ou négative comme expliqué ci-dessous -

Relation linéaire positive

Une relation linéaire sera dite positive si la variable indépendante et dépendante augmente. Il peut être compris à l'aide du graphique suivant -

Relation linéaire négative

Une relation linéaire sera dite positive si indépendante augmente et que la variable dépendante diminue. Il peut être compris à l'aide du graphique suivant -

Types de régression linéaire

La régression linéaire est des deux types suivants -

  • Régression linéaire simple
  • Régression linéaire multiple

Régression linéaire simple (SLR)

C'est la version la plus basique de la régression linéaire qui prédit une réponse en utilisant une seule caractéristique. L'hypothèse dans SLR est que les deux variables sont linéairement liées.

Implémentation Python

Nous pouvons implémenter SLR en Python de deux manières, l'une consiste à fournir votre propre ensemble de données et l'autre à utiliser l'ensemble de données de la bibliothèque python scikit-learn.

Example 1 - Dans l'exemple d'implémentation Python suivant, nous utilisons notre propre ensemble de données.

Tout d'abord, nous commencerons par importer les packages nécessaires comme suit -

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

Ensuite, définissez une fonction qui calculera les valeurs importantes pour SLR -

def coef_estimation(x, y):

La ligne de script suivante donnera le nombre d'observations n -

n = np.size(x)

La moyenne des vecteurs x et y peut être calculée comme suit -

m_x, m_y = np.mean(x), np.mean(y)

Nous pouvons trouver la déviation croisée et la déviation autour de x comme suit -

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x

Ensuite, les coefficients de régression, c'est-à-dire b, peuvent être calculés comme suit -

b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

Ensuite, nous devons définir une fonction qui tracera la droite de régression et prédira le vecteur de réponse -

def plot_regression_line(x, y, b):

La ligne de script suivante trace les points réels sous forme de nuage de points -

plt.scatter(x, y, color = "m", marker = "o", s = 30)

La ligne de script suivante prédira le vecteur de réponse -

y_pred = b[0] + b[1]*x

Les lignes de script suivantes traceront la ligne de régression et mettront les étiquettes dessus -

plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Enfin, nous devons définir la fonction main () pour fournir un ensemble de données et appeler la fonction que nous avons définie ci-dessus -

def main():
   x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
   y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
   b = coef_estimation(x, y)
   print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
   plot_regression_line(x, y, b)
   
if __name__ == "__main__":
main()

Production

Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788

Example 2 - Dans l'exemple d'implémentation Python suivant, nous utilisons l'ensemble de données sur le diabète de scikit-learn.

Tout d'abord, nous commencerons par importer les packages nécessaires comme suit -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

Ensuite, nous allons charger le jeu de données sur le diabète et créer son objet -

diabetes = datasets.load_diabetes()

Comme nous implémentons SLR, nous n'utiliserons qu'une seule fonctionnalité comme suit -

X = diabetes.data[:, np.newaxis, 2]

Ensuite, nous devons diviser les données en ensembles d'entraînement et de test comme suit -

X_train = X[:-30]
X_test = X[-30:]

Ensuite, nous devons diviser la cible en ensembles de formation et de test comme suit -

y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]

Maintenant, pour entraîner le modèle, nous devons créer un objet de régression linéaire comme suit -

regr = linear_model.LinearRegression()

Ensuite, entraînez le modèle à l'aide des ensembles d'apprentissage comme suit:

regr.fit(X_train, y_train)

Ensuite, faites des prédictions en utilisant l'ensemble de test comme suit -

y_pred = regr.predict(X_test)

Ensuite, nous imprimerons un coefficient comme MSE, le score de variance, etc. comme suit -

print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))

Maintenant, tracez les sorties comme suit -

plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

Production

Coefficients:
   [941.43097333]
Mean squared error: 3035.06
Variance score: 0.41

Régression linéaire multiple (MLR)

C'est l'extension de la régression linéaire simple qui prédit une réponse en utilisant deux ou plusieurs caractéristiques. Mathématiquement, nous pouvons l'expliquer comme suit -

Considérons un ensemble de données ayant n observations, p caractéristiques, c'est-à-dire des variables indépendantes et y comme une réponse, c'est-à-dire une variable dépendante, la droite de régression pour p caractéristiques peut être calculée comme suit -

$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} $$

Ici, h (x i ) est la valeur de réponse prédite et b 0 , b 1 , b 2 …, b p sont les coefficients de régression.

Les modèles de régression linéaire multiple incluent toujours les erreurs dans les données connues sous le nom d'erreur résiduelle qui modifient le calcul comme suit -

$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} + e_ {i} $$

Nous pouvons également écrire l'équation ci-dessus comme suit -

$$ y_ {i} = h (x_ {i}) + e_ {i} \: ou \: e_ {i} = y_ {i} - h (x_ {i}) $$

Implémentation Python

dans cet exemple, nous utiliserons l'ensemble de données sur le logement de Boston de scikit learn -

Tout d'abord, nous commencerons par importer les packages nécessaires comme suit -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

Ensuite, chargez l'ensemble de données comme suit -

boston = datasets.load_boston(return_X_y=False)

Les lignes de script suivantes définiront la matrice de caractéristiques, X et le vecteur de réponse, Y -

X = boston.data
y = boston.target

Ensuite, divisez l'ensemble de données en ensembles d'entraînement et de test comme suit:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)

Exemple

Maintenant, créez un objet de régression linéaire et entraînez le modèle comme suit -

reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
   color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
   color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()

Production

Coefficients:
[
   -1.16358797e-01  6.44549228e-02  1.65416147e-01  1.45101654e+00
   -1.77862563e+01  2.80392779e+00  4.61905315e-02 -1.13518865e+00
    3.31725870e-01 -1.01196059e-02 -9.94812678e-01  9.18522056e-03
   -7.92395217e-01
]
Variance score: 0.709454060230326

Hypothèses

Voici quelques hypothèses sur le jeu de données réalisé par le modèle de régression linéaire -

Multi-collinearity- Le modèle de régression linéaire suppose qu'il y a très peu ou pas de multi-colinéarité dans les données. Fondamentalement, la multi-colinéarité se produit lorsque les variables ou entités indépendantes ont une dépendance en elles.

Auto-correlation- Une autre hypothèse que le modèle de régression linéaire suppose qu'il y a très peu ou pas d'autocorrélation dans les données. Fondamentalement, l'autocorrélation se produit lorsqu'il existe une dépendance entre les erreurs résiduelles.

Relationship between variables - Le modèle de régression linéaire suppose que la relation entre les variables de réponse et de caractéristique doit être linéaire.