Introduction simple à la régression linéaire multiple

Publié: 22-06-2019
Le code de ce post est écrit avec Python version 3.7.3 à l'aide du logiciel Spyder.

Dans un précédent article <Introduction à la régression linéaire simple>, j'avais introduit la régression linéaire simple. Dans cet article, nous allons examiner le cas où l'ensemble de données contient plusieurs entrées. Il s’agit du scénario le plus réaliste, car la plupart du temps, votre variable de sortie dépend de plusieurs facteurs. Par exemple, le prix de l'immobilier peut être prédit en utilisant la taille de la maison et le nombre de chambres.

Pour la régression linéaire simple, nous avons eu ce qui suit: $$\big\{\big(x_1,y_1\big),\big(x_2,y_2\big),...,\big(x_N,y_N\big)\big\}$$ Maintenant, nous avons le même, mais X peut contenir plusieurs nombres, nous le représentons donc comme un vecteur. Ce vecteur est appelé le vecteur de caractéristiques.
La taille de X, appelée dimensionalité, est généralement représentée par la lettre D. Notre modèle est comme suit: $$\hat{y} = w^Tx + b$$ $$\hat{y} \; \; \text{ est la valeur prédite} $$ $$w \; \; \text{ est le paramètre du modèle, il contient les poids des caractéristiques } $$ $$x \; \; \text{ contient le vecteur de caractéristiques}$$ $$b \; \; \text{est le terme de biais}$$ Puisque nous devons prendre le produit scalaire entre W et X, W devrait également être de dimensionalité D.

Le terme de biais b dans cette équation peut être ajouté au vecteur de paramètre du modèle W en ajoutant 1 au vecteur de caractéristiques X comme suit: $$\hat{y} = b + w_1x_1 + w_2x_2 + ... + w_Dx_D$$ renommer b en w0, $$\hat{y} = w_0 + w_1x_1 + w_2x_2 + ... + w_Dx_D$$ ajouter x0 qui est toujours 1, $$\hat{y} = w_0x_0 + w_1x_1 + w_2x_2 + ... + w_Dx_D = w^{'T}x' \; \; \text{ / } x_0=1 $$ Ceci équivaut à ajouter une colonne de 1 à la matrice de données X de taille [NxD].

Comme déjà mentionné, X est une matrice [NxD] dans le problème de la régression linéaire multiple. Où N représente le nombre d'échantillons et D le nombre de caractéristiques. Considérez que vous voulez prédire le prix d’une maison en utilisant trois caractéristiques: le nombre de chambres, la taille de la maison et la ville. Dans ce cas, D sera égal à 3 et N sera égal au nombre d'observations que vous avez dans votre jeu de données. Chaque observation ou ligne de cette matrice a la forme [1xD] et est appelée vecteur caractéristique (feature vector).

Une prédiction d'un échantillon ressemblera à ceci: $$\hat{y_i}=w^Tx_i$$ Et la prédiction de tous les échantillons donnera un vecteur Y comme suit: $$\vec{Y}_{N \times 1} = X_{N \times D}w_{D \times 1}$$ Considérons un ensemble de données contenant 4 observations de trois caractéristiques, comme suit: $$ X= \begin{vmatrix} 0&0&1\\ 0&1&0\\ 1&0&0\\ 1&1&0\\ \end{vmatrix} \; \; w=\begin{vmatrix} 1\\ 2\\ 3\\ \end{vmatrix} $$ Si nous voulons trouver la prédiction y1 de la première ligne, prenons le vecteur x1 (première ligne de X) et faisons le produit scalaire avec w. La prédiction de la première ligne y1 est un scalaire [1x1], nous devons donc multiplier [1x3] par [3x1] (les dimensions intérieures doivent correspondre). Par convention, les vecteurs sont des vecteurs colonne comme suit: $$ x1=\begin{vmatrix} 0\\ 0\\ 1\\ \end{vmatrix} \; \; \text{ et } \; w=\begin{vmatrix} 1\\ 2\\ 3\\ \end{vmatrix} $$ Notez que dans la matrice X, x1 est horizontal, mais lorsqu'il est seul, il est vertical. Le produit scalaire étant symétrique, nous devons transposer x1 ou w (transformation en vecteur ligne) pour que les dimensions intérieures correspondent: $$ y1=w^Tx_1= \begin{vmatrix} 1&2&3\\ \end{vmatrix} \begin{vmatrix} 0\\ 0\\ 1\\ \end{vmatrix} = 3 = x_1^Tw $$

Nous ne voulons pas calculer y1, y2, y3 et y4 séparément. Nous voulons calculer le vecteur de prédiction dans le moins d'appels possible. Nous pouvons calculer toutes les prédictions en procédant comme suit: $$ Y_{4 \times 1} = \begin{vmatrix} 3\\ 2\\ 1\\ 3\\ \end{vmatrix}_{4 \times 1} = \begin{vmatrix} 0&0&1\\ 0&1&0\\ 1&0&0\\ 1&1&0\\ \end{vmatrix}_{4 \times 3} \times \begin{vmatrix} 1\\ 2\\ 3\\ \end{vmatrix}_{3 \times 1} $$

Maintenant nous savons ce que nous devrions faire pour calculer le vecteur de prédiction. La tâche importante est de calculer le vecteur de paramètres du modèle W. Ayant la même fonction d'erreur que dans le problème de la régression linéaire simple, nous pouvons toujours utiliser le calculus pour prendre la dérivée de l'erreur par rapport à n'importe quel composant de W (w1, w2, ..., wD). $$ E=\sum_{i=1}^{N}\big(y_i - \hat{y}_i \big)^2 = \sum_{i=1}^{N}\big(y_i - w^Tx_i \big)^2 $$ $$ \frac{\partial E}{\partial w_j} \; \; \text{ \ } j=1,..,D $$ Pour répéter, l’objectif est de calculer w1, w2, ..., wD afin d’avoir le vecteur paramètres W. La fonction de coût E peut être écrite sous la forme de matrices comme suit: $$ E=\sum_{i=1}^{N}\big(y_i - \hat{y}_i \big)^2 = \big( Y_{N \times 1} - \hat{Y}_{N \times 1} \big)^T\big( Y_{N \times 1} - \hat{Y}_{N \times 1} \big) $$ Rappelez-vous que: $$ \hat{Y}_{N \times 1}=X_{N \times D}W_{D \times 1} $$ En développant la fonction de coût, nous aurons: $$ E=\big( Y - \hat{Y} \big)^T\big( Y - \hat{Y} \big) $$ $$ =Y^TY - Y^T\hat{Y} - \hat{Y}^TY + \hat{Y}^T\hat{Y} $$ $$ =Y^TY - Y^TXW - \big(XW\big)^TY + \big(XW\big)^T\big(XW\big) $$ $$ =Y^TY - Y^TXW - W^TX^TY + W^TX^TXW $$ Maintenant, en prenant la dérivée de la fonction de coût par rapport à W et la mise à zéro: $$ \frac{\partial E}{\partial W} = -2X^TY + 2X^TXW = 0 $$ $$ X^TXW = X^TY $$ $$ W=\big(X^TX \big)^{-1}X^TY $$ Notez que vous devez vous référer au calcul matriciel pour effectuer la dérivée. Le résultat final est appelé l'équation normale. Dans certains livres, vous le trouverez comme suit: $$\hat{\theta}=\big(X^TX \big)^{-1}X^Ty$$ Où thêta est la valeur du vecteur de paramètres qui minimise la fonction de coût.

Codage de la solution 2-D en python

Dans ce qui suit, je vais vous montrer comment coder une régression linéaire multiple en Python. Nous allons commencer par importer les bibliothèques numpy et pyplot.

            
                import numpy as np
                import matplotlib.pyplot as plt
            
        

Nous allons maintenant générer des données linéaires. Notre matrice X contiendra deux caractéristiques (X1 et X2).

            
                X1=2*np.random.rand(100,1)
                X2=0.5*np.random.rand(100,1)

                Y=4 + 3*X1 + 2*X2 + np.random.rand(100,1)
            
        

Nous devons maintenant ajouter X0 = 1 à chaque instance et former notre matrice X.

            
                X=np.c_[np.ones((100,1)),X1,X2]
            
        

Nous pouvons tracer les données:

            
                fig=plt.figure()
                ax=fig.add_subplot(111,projection='3d')
                ax.scatter(X[:,1],X[:,2],Y)
            
        

Calculons maintenant W en utilisant l’équation normale. Nous allons utiliser la fonction inv() du module Algèbre linéaire de NumPy (np.linalg) pour calculer l’inverse d’une matrice et la méthode dot () pour la multiplication matricielle:

            
                W=np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y)
            
        

Calculons la matrice de prédictions:

            
                Yhat=np.dot(X,W)
            
        

Nous déterminerons la qualité de nos prédictions en utilisant le R-carré. Reportez-vous à ce lien <Introduction à la régression linéaire simple> pour plus d'informations.

            
                #Calculer r-carre
                d1=Y-Yhat
                d2=Y-Y.mean()
                r2=1-(d1.T.dot(d1)/d2.T.dot(d2))

                print ("le r-carre est:",r2)
                # → 0.97
            
        

Le R-carré de notre modèle est proche de 1, ce qui signifie que c'est un très bon modèle. Dans cet article, nous avons vu un exemple très simple de régression linéaire multiple. Dans les prochains articles, je discuterai d'exemples et d'implémentations plus complexes.

Références

  • Aurélien Géron - Hands-On Machine Learning with Scikit-Learn and TensorFlow.
  • Lazy programmer - https://deeplearningcourses.com