Analyse de régression en Python

L'analyse de régression est l'une des tâches les plus fondamentales dans les industries axées sur les données. En termes simples, il s'agit de trouver une relation entre des variables indépendantes et dépendantes (attributs) dans un ensemble de données donné.

Prenons l'exemple d'un problème de prévision du prix d'une maison :compte tenu de la taille et du nombre de chambres, nous voulons prédire le prix d'une maison. Il s'agit d'un simple problème de régression où la taille de la maison et le nombre de chambres sont les variables indépendantes et le prix de la maison est la variable dépendante.

Une myriade d'autres tâches financières impliquent une analyse de régression. Par exemple, si vous souhaitez déterminer la probabilité qu'un client rembourse un prêt, vous pouvez effectuer une analyse de régression sur les données des anciens clients qui ont emprunté des prêts. L'estimation de la valeur d'un actif financier particulier qui dépend de diverses caractéristiques implique également une analyse de régression.

Dans cet article, nous étudierons un type de régression où deux ou plusieurs variables sont liées linéairement. C'est ce qu'on appelle la régression linéaire .

Régression linéaire :Intuition mathématique

Mathématiquement, la régression linéaire peut être représentée comme suit :

Ici, Y est la variable dépendante, tandis que x₁ , x₂ , x₃ , ..., x_n sont les variables indépendantes. De plus, les coefficients w1, w2, w3, ..., wn représentent le poids (ou contribution) de chaque variable indépendante dans la détermination de la valeur de la variable dépendante (Y).

Dans l'analyse de régression, les variables indépendantes sont également appelées variables explicatives car ils aident à expliquer les tendances (le cas échéant) que nous observons dans la variable dépendante. La variable dépendante est également appelée variable de réponse car il répond aux changements des variables explicatives.

Nous modifions les valeurs des variables indépendantes telles qu'elles apparaissent dans notre ensemble de données ; la seule chose que nous ne pouvons pas mettre à jour est leur poids. Autrement dit, nous ajustons les pondérations pour modifier l'importance que nous accordons à la contribution d'une variable particulière à la valeur de Y.

Dans l'analyse de régression, les valeurs des pondérations sont déterminées de telle manière que la différence entre la valeur prévue pour Y (selon l'équation ci-dessus) et la valeur réelle pour Y (selon l'ensemble de données - les prix réels des logements) est minimisée.

Effectuer une analyse de régression avec Python

Le langage de programmation Python est livré avec une variété d'outils qui peuvent être utilisés pour l'analyse de régression. La bibliothèque scikit-learn de Python est l'un de ces outils. Cette bibliothèque fournit un certain nombre de fonctions pour effectuer des tâches d'apprentissage automatique et de science des données, y compris l'analyse de régression.

Ensemble de données :logements du comté de King

Dans cet article, nous verrons comment utiliser Python pour l'analyse de régression. Nous allons prédire le prix d'une maison en fonction de différents attributs, tels que la taille, l'état, le niveau (tel qu'attribué par la municipalité locale) et l'année de construction.

L'ensemble de données que nous allons utiliser pour ce problème peut être téléchargé à partir de ce lien kaggle. Cet ensemble de données contient les prix de vente des maisons pour le comté de King, Washington et inclut les maisons vendues entre mai 2014 et mai 2015. J'ai renommé l'ensemble de données en housing_data.csv; vous pouvez lui donner n'importe quel nom.

Remarque :Tout le code de cet article est exécuté à l'aide de l'IDE Spyder pour Python.

Étape 1 :Importer les bibliothèques requises

Nous devons importer les pandas , numpy , et matplotlib bibliothèques afin de charger et d'analyser notre jeu de données. Exécutez le script suivant pour ce faire :

import pandas as pd  
import numpy as np  
import matplotlib.pyplot as plt  

La taille de figure par défaut créée à l'aide de matplotlib est de 6 x 4 pouces dans l'éditeur Spyder pour le développement Python. Cependant, pour une compréhension claire et une meilleure analyse, augmentons la taille par défaut des tracés à 10 x 8. Le code suivant le fait :

fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 10
fig_size[1] = 8
plt.rcParams["figure.figsize"] = fig_size

Étape 2 :Charger l'ensemble de données

Nous utiliserons le read_csv fonction des pandas bibliothèque pour lire notre ensemble de données dans un DataFrame :

housing_data = pd.read_csv(r'E:\Datasets\housing_data.csv')

Étape 3 :Effectuez une analyse exploratoire des données

C'est toujours une bonne idée d'examiner les tendances de nos données avant d'effectuer une régression pour avoir un aperçu. Observons d'abord la forme de notre jeu de données :

housing_data.shape

Dans la sortie, vous devriez voir (21613, 21), ce qui signifie que notre jeu de données contient 21613 lignes et 21 colonnes.

Dans cet article, nous effectuerons une analyse de régression en utilisant uniquement les quatre fonctionnalités suivantes :

• sqft_living — contient la taille de la maison en pieds carrés.
• yr_built — contient l'année de construction de la maison.
• condition — correspond à l'état de la maison.
• Grade - la note attribuée à la maison sur la base du système de notation King Count.

Filtrons toutes les caractéristiques pertinentes de notre ensemble de données et supprimons le reste (notez que le prix sera la variable dépendante) :

housing_data = housing_data[['sqft_living', 'yr_built', 'condition','grade', 'price']]

Voyons maintenant à quoi ressemblent réellement nos données. On peut utiliser la fonction head des pandas DataFrame faire cela; il renvoie les cinq premières lignes de l'ensemble de données.

housing_data.head()

Dans la sortie, vous verrez les cinq premières lignes des données comme indiqué ci-dessous :

De même, pour voir les détails statistiques des données, nous pouvons utiliser la fonction describe :

housing_data.describe()

Cela renvoie les informations suivantes :

• Le nombre de valeurs dans chaque colonne.
• La moyenne (moyenne) de chaque colonne.
• L'écart type de chaque colonne.
• Les valeurs maximales et minimales pour chaque colonne.
• Les 25e, 50e et 75e centiles des valeurs de chaque colonne.

Dans la sortie, vous devriez voir quelque chose comme ceci :

Étape 4 :Visualiser les données

Voyons le rapport entre la superficie d'une maison et son prix. Nous pouvons utiliser le plotly.offline.plot fonction de l'intrigue bibliothèque. Faire intrigue travailler avec le dataframe pandas, nous utiliserons les boutons de manchette bibliothèque. N'oubliez pas, boutons de manchette la bibliothèque fonctionne avec plotly bibliothèque version 2.7.0. Exécutez le script suivant pour connecter les pandas bibliothèque avec le plotly bibliothèque.

import cufflinks as cf
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot  
cf.go_offline() 

Traçons maintenant la relation entre la taille de la maison et son prix :

housing_data.iplot(kind='scatter', x='sqft_living', y='price', mode='markers', color = '#5d3087',  layout = {
        'title' :'Size vs Price',
        'xaxis': {'title': 'Size', 'type': 'log'},
        'yaxis': {'title': "Price"}
    })

Vous devriez voir le tracé suivant dans la sortie :

You can see that there is a slight positive correlation between the size and price of a house. However, after roughly 8000 square feet, the effect of the size on the house price starts diminishing.

Correlation simply refers to the relationship between two variables, where an increase or decrease in the value of one variable causes an increase or decrease in the value of the other variable. In a positive correlation , the values of both the correlated variables move in the same direction. In a negative correlation , an increase in the value of one variable causes a decrease in the value of other, and vice versa.

Let's now plot the relationship between grade and price:

housing_data.iplot(kind='scatter', x='grade', y='price', mode='markers', color = '#5d3087',  layout = {
        'title' :'grade vs Price',
        'xaxis': {'title': 'grade', 'type': 'log'},
        'yaxis': {'title': "Price"}
    })

Here is the output of the above script:

You can clearly see that there's a positive correlation between the grade and price of a house. In other words, houses with higher grades tend to have higher prices compared to houses with lower grades.

Finally, let's plot the relationship between year built and price:

housing_data.iplot(kind='scatter', x='yr_built', y='price', mode='markers', color = '#5d3087',  layout = {
        'title' :'Year vs Price',
        'xaxis': {'title': 'Year', 'type': 'log'},
        'yaxis': {'title': "Price"}
    })

La sortie ressemble à ceci :

You can see that the relationship between the price of a house and the year in which it was built is purely random. The relationship between two or more variables is random when no correlation, either positive or negative, is observed between them.

Step 5:Creating a Linear Regression Model

Now that we have a general idea of the trends in our dataset, let's see if our regression model confirms our observations.

To perform regression using Python's scikit-learn library, we need to divide our dataset into features and their corresponding predictions. By convention, the feature set is represented with the variable X, and predictions are stored in the variable y. However, you can use any variable names for these.

Let's divide our dataset into features and predictions:

X = housing_data[['sqft_living', 'yr_built', 'condition','grade']] 
y = housing_data['price']

To evaluate the performance of our regression model, we'll also divide our data into a training set and a test set. The training set contains data that will be used to train our regression model. In the training process, we're basically finding a mathematical equation that minimizes the difference between the actual values of the dependent variable (price) and the values that we predict with our model (Y).

As a rule of thumb, a regression model should be trained on one part of the data and tested on another, known as the test set , that our model has not seen. This practice of dividing data into training and test sets ensures that our regression model is robust and can make good predictions on data that it has not encountered in the past.

Execute the following script to divide the data into a training set and test set:

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

Here, the value of the test_size argument specifies the percent of dataset values that should be used for the test set. That is, a value of 0.25 means that our test set will consist of 25% of the actual data, while the training set will consist of the remaining 75%. You can use any value for test_size .

Next, we need to train our regression model. As explained earlier, training a regression model refers to finding a mathematical equation as described in the Mathematical Intuition section.

Python's scikit-learn library contains the LinearRegression class for this purpose. To create a regression model based on the training data, we need to call the fit method of the LinearRegression class and pass in our features and predictions, as shown below:

from sklearn.linear_model import LinearRegression  
reg = LinearRegression()  
reg.fit(X_train, y_train)

Once our regression model is trained, we can extract the coefficients (the Ws) that our model found for each independent variable (feature). Exécutez le script suivant :

attributes_coefficients = pd.DataFrame(reg.coef_, X.columns, columns=['Coefficient'])  
attributes_coefficients

In the output, you should see the following values:

According to to this model:

• Each square-footage increase in area causes an increase of $176 in the price.
• Each increase of one year in the year built causes a decrease of $3541 in the price.
• Each one-unit increase in a house's condition causes an increase of $11379 in its price.
• Each one-unit increase in the grade of a house causes an increase of $140779 in its price.

With this information, we can now test the performance of our regression model on the test set:

y_pred = reg.predict(X_test)

comparison = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})  
comparison

Here's a snippet of some of the comparisons between actual and predicted house prices:

You can see that our regression model has made some closes guesses regarding the prices—and, in some cases, is very far from the actual price.

Step 6:Testing the Linear Regression Model

Once you've trained your regression model, the next step is to evaluate its performance. This is very important—if your model isn't good enough for predictions, there is no point in using it.

There are different metrics to evaluate the performance of a regression models. The root-mean-square error (RMSE), mean squared error (MSE), and mean absolute error (MAE°) are the most commonly used metrics.

The scikit-learn library contains built-in functions for calculating these values. Execute the following script to calculate each one, in order:

from sklearn import metrics  
print('MAE:', metrics.mean_absolute_error(y_test, y_pred))  
print('MSE:', metrics.mean_squared_error(y_test, y_pred))  
print('RMSE:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))  

In the output, you should see the following results:

MAE: 150410.9696916637
MSE: 59028208836.96216
RMSE: 242957.21606275075

You can see that our value for the RMSE is quite large. As a rule of thumb, the RMSE should be less than 10 percent of the mean value of the predicted output.

As an exercise, try to add the remaining features of the dataset to the regression model, and see if you can achieve a lower value of RMSE.

Next Steps

Impressionnant! With Python's scikit-learn library, we were able to develop a linear regression model to predict house prices based on different features in our dataset.

Regression is one of the most frequently performed tasks in finance. But as you can see, the process of performing regression analysis in Python is actually quite straightforward—it only takes a few lines of code.

Of course, this is just the beginning. In the real world, Python can be used to perform much more complex financial tasks, which we'll look at in later articles. Stay tuned!

Looking to pursue a career in finance or data science? Consider learning Python to expand your professional toolkit and position yourself strategically in today's competitive job market.