Régression Linéaire Multiple en Python : Un Guide Complet

Introduction

La régression linéaire multiple est une technique statistique fondamentale utilisée pour modéliser la relation entre une variable dépendante et plusieurs variables indépendantes. En Python, des outils comme scikit-learn et statsmodels offrent des implémentations robustes pour l'analyse de régression. Ce tutoriel vous guidera à travers l'implémentation, l'interprétation et l'évaluation des modèles de régression linéaire multiple en utilisant Python.

Conditions préalables

Avant de plonger dans l'implémentation, assurez-vous d'avoir ce qui suit :

• Compréhension de base de Python. Vous pouvez consulter le tutoriel Python pour les débutants.
• Familiarité avec scikit-learn pour des tâches d'apprentissage automatique. Vous pouvez consulter le tutoriel Python scikit-learn.
• Compréhension des concepts de visualisation des données en Python. Vous pouvez vous référer à Comment tracer des données en Python 3 en utilisant matplotlib et Analyse et visualisation des données avec pandas et Jupyter Notebook en Python 3.
• Python 3.x installé avec les bibliothèques suivantes numpy, pandas, matplotlib, seaborn, scikit-learn, et statsmodels installées.

Qu'est-ce que la régression linéaire multiple ?

La régression linéaire multiple (RLM) est une méthode statistique qui modélise la relation entre une variable dépendante et deux ou plusieurs variables indépendantes. C'est une extension de la régression linéaire simple, qui modélise la relation entre une variable dépendante et une seule variable indépendante. Dans la RLM, la relation est modélisée en utilisant la formule :

Où :

Exemple : Prédire le prix d'une maison en fonction de sa taille, du nombre de chambres et de son emplacement. Dans ce cas, il y a trois variables indépendantes, à savoir la taille, le nombre de chambres et l'emplacement, et une variable dépendante, à savoir le prix, qui est la valeur à prédire.

Hypothèses de la régression linéaire multiple

Avant de mettre en œuvre une régression linéaire multiple, il est essentiel de s'assurer que les hypothèses suivantes sont respectées :

1. Linéarité: La relation entre la variable dépendante et les variables indépendantes est linéaire.

2. Indépendance des erreurs : Les résidus (erreurs) sont indépendants les uns des autres. Cela est souvent vérifié à l'aide du test de Durbin-Watson.

3. Homoscedasticité : La variance des résidus est constante à tous les niveaux des variables indépendantes. Un diagramme des résidus peut aider à vérifier cela.

4. Pas de multicolinéarité : Les variables indépendantes ne sont pas fortement corrélées. Le facteur d'inflation de variance (VIF) est couramment utilisé pour détecter la multicolinéarité.

5. Normalité des résidus: Les résidus doivent suivre une distribution normale. Cela peut être vérifié à l'aide d'un graphique Q-Q.

6. Influence des valeurs aberrantes : Les valeurs aberrantes ou les points à fort levier ne devraient pas influencer de manière disproportionnée le modèle.

Ces hypothèses garantissent que le modèle de régression est valide et que les résultats sont fiables. Ne pas respecter ces hypothèses peut entraîner des résultats biaisés ou trompeurs.

Prétraitez les données

Dans cette section, vous apprendrez à utiliser le modèle de régression linéaire multiple en Python pour prédire les prix des maisons en fonction des caractéristiques du jeu de données sur le logement en Californie. Vous apprendrez à prétraiter les données, à ajuster un modèle de régression et à évaluer ses performances tout en abordant des défis courants tels que la multicolinéarité, les valeurs aberrantes et la sélection des caractéristiques.

Étape 1 - Charger le jeu de données

Vous utiliserez le jeu de données sur le logement en Californie, un ensemble de données populaire pour les tâches de régression. Cet ensemble de données contient 13 caractéristiques sur les maisons dans les banlieues de Boston et leur prix médian correspondant.

Tout d'abord, installons les packages nécessaires :

pip install numpy pandas matplotlib seaborn scikit-learn statsmodels

from sklearn.datasets import fetch_california_housing  # Import the fetch_california_housing function from sklearn.datasets to load the California Housing dataset.
import pandas as pd  # Import pandas for data manipulation and analysis.
import numpy as np  # Import numpy for numerical computing.

Load the California Housing dataset using the fetch_california_housing function.
housing = fetch_california_housing()

Convert the dataset's data into a pandas DataFrame, using the feature names as column headers.
housing_df = pd.DataFrame(housing.data, columns=housing.feature_names)

Add the target variable 'MedHouseValue' to the DataFrame, using the dataset's target values.
housing_df['MedHouseValue'] = housing.target

Display the first few rows of the DataFrame to get an overview of the dataset.
print(housing_df.head())

Vous devez observer la sortie suivante du jeu de données :

 MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup  Latitude  Longitude  MedHouseValue
0  8.3252      41.0  6.984127   1.023810       322.0  2.555556     37.88    -122.23          4.526
1  8.3014      21.0  6.238137   0.971880      2401.0  2.109842     37.86    -122.22          3.585
2  7.2574      52.0  8.288136   1.073446       496.0  2.802260     37.85    -122.24          3.521
3  5.6431      52.0  5.817352   1.073059       558.0  2.547945     37.85    -122.25          3.413
4  3.8462      52.0  6.281853   1.081081       565.0  2.181467     37.85    -122.25          3.422

Voici ce que signifie chacun des attributs :

Étape 2 - Prétraiter les données

Vérifiez s'il y a des valeurs manquantes

S'assure qu'il n'y a pas de valeurs manquantes dans le jeu de données qui pourraient affecter l'analyse.

print(housing_df.isnull().sum())

Sortie :

MedInc           0
HouseAge         0
AveRooms         0
AveBedrms        0
Population       0
AveOccup         0
Latitude         0
Longitude        0
MedHouseValue    0
dtype: int64

Sélection de caractéristiques

Créons d'abord une matrice de corrélation pour comprendre les dépendances entre les variables.

correlation_matrix = housing_df.corr()
print(correlation_matrix['MedHouseValue'])

Sortie :

MedInc           0.688075
HouseAge         0.105623
AveRooms         0.151948
AveBedrms       -0.046701
Population      -0.024650
AveOccup        -0.023737
Latitude        -0.144160
Longitude       -0.045967
MedHouseValue    1.000000

Vous pouvez analyser la matrice de corrélation ci-dessus pour sélectionner les variables dépendantes et indépendantes pour notre modèle de régression. La matrice de corrélation fournit des aperçus sur les relations entre chaque paire de variables dans l'ensemble de données.

Dans la matrice de corrélation donnée, MedHouseValue est la variable dépendante, car c'est la variable que nous essayons de prédire. Les variables indépendantes ont une corrélation significative avec MedHouseValue.

Sur la base de la matrice de corrélation, vous pouvez identifier les variables indépendantes suivantes qui ont une corrélation significative avec MedHouseValue :

• MedInc : Cette variable a une forte corrélation positive (0,688075) avec MedHouseValue, ce qui indique qu'à mesure que le revenu médian augmente, la valeur médiane des maisons tend également à augmenter.
• AveRooms: Cette variable présente une corrélation positive modérée (0.151948) avec MedHouseValue, suggérant qu'à mesure que le nombre moyen de pièces par ménage augmente, la valeur médiane des maisons tend également à augmenter.
• AveOccup : Cette variable a une faible corrélation négative (-0.023737) avec MedHouseValue, indiquant qu'à mesure que l'occupation moyenne par ménage augmente, la valeur médiane des maisons tend à diminuer, mais l'effet est relativement faible.

En sélectionnant ces variables indépendantes, vous pouvez construire un modèle de régression qui capture les relations entre ces variables et MedHouseValue, nous permettant de faire des prédictions sur la valeur médiane des maisons en fonction du revenu médian, du nombre moyen de chambres et du taux d'occupation moyen.

Vous pouvez également tracer la matrice de corrélation en Python en utilisant ce qui suit :

import seaborn as sns
import matplotlib.pyplot as plt

Assuming 'housing_df' is the DataFrame containing the data
Plotting the correlation matrix
plt.figure(figsize=(10, 8))
sns.heatmap(housing_df.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Matrix')
plt.show()

Vous vous concentrerez sur quelques caractéristiques clés pour la simplicité, basées sur ce qui précède, telles que MedInc (revenu médian), AveRooms (nombre moyen de pièces par ménage) et AveOccup (taux d'occupation moyen par ménage).

selected_features = ['MedInc', 'AveRooms', 'AveOccup']
X = housing_df[selected_features]
y = housing_df['MedHouseValue']

Le bloc de code ci-dessus sélectionne des caractéristiques spécifiques du cadre de données housing_df pour l'analyse. Les caractéristiques sélectionnées sont MedInc, AveRooms et AveOccup, qui sont stockées dans la liste selected_features.

Le DataFrame housing_df est ensuite sous-ensemble pour n'inclure que ces caractéristiques sélectionnées et le résultat est stocké dans la liste X.

La variable cible MedHouseValue est extraite de housing_df et stockée dans la liste y.

Mise à l'échelle des fonctionnalités

Vous utiliserez la standardisation pour vous assurer que toutes les caractéristiques sont sur la même échelle, améliorant ainsi les performances et la comparabilité du modèle.

La standardisation est une technique de prétraitement qui ajuste les caractéristiques numériques pour avoir une moyenne de 0 et un écart type de 1. Ce processus garantit que toutes les caractéristiques sont sur la même échelle, ce qui est essentiel pour les modèles d'apprentissage automatique sensibles à l'échelle des caractéristiques d'entrée. En standardisant les caractéristiques, vous pouvez améliorer la performance du modèle et sa comparabilité en réduisant l'effet des caractéristiques avec de grandes plages qui dominent le modèle.

from sklearn.preprocessing import StandardScaler

Initialize the StandardScaler object
scaler = StandardScaler()

Fit the scaler to the data and transform it
X_scaled = scaler.fit_transform(X)

Print the scaled data
print(X_scaled)

Sortie :

[[ 2.34476576  0.62855945 -0.04959654]
[ 2.33223796  0.32704136 -0.09251223]
[ 1.7826994   1.15562047 -0.02584253]
...
[-1.14259331 -0.09031802 -0.0717345 ]
[-1.05458292 -0.04021111 -0.09122515]
[-0.78012947 -0.07044252 -0.04368215]]

La sortie représente les valeurs mises à l'échelle des caractéristiques MedInc, AveRooms, et AveOccup après application du StandardScaler. Les valeurs sont maintenant centrées autour de 0 avec un écart-type de 1, garantissant que toutes les caractéristiques sont sur la même échelle.

La première ligne [ 2.34476576 0.62855945 -0.04959654] indique que pour le premier point de données, la valeur mise à l'échelle de MedInc est 2.34476576, AveRooms est 0.62855945, et AveOccup est -0.04959654. De manière similaire, la deuxième ligne [ 2.33223796 0.32704136 -0.09251223] représente les valeurs mises à l'échelle pour le deuxième point de données, et ainsi de suite.

Les valeurs mises à l'échelle varient d'environ -1,14259331 à 2,34476576, ce qui indique que les caractéristiques sont désormais normalisées et comparables. Cela est essentiel pour les modèles d'apprentissage automatique qui sont sensibles à l'échelle des caractéristiques d'entrée, car cela empêche les caractéristiques ayant de grandes plages de dominer le modèle.

Mettre en œuvre une régression linéaire multiple

Maintenant que vous avez terminé le prétraitement des données, mettons en œuvre la régression linéaire multiple en python.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt
import seaborn as sns

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

The 'LinearRegression' model is initialized and fitted to the training data.
model = LinearRegression()
model.fit(X_train, y_train)

The model is used to predict the target variable for the test set.
y_pred = model.predict(X_test)


print("Mean Squared Error:", mean_squared_error(y_test, y_pred))
print("R-squared:", r2_score(y_test, y_pred))

La fonction train_test_split est utilisée pour diviser les données en ensembles d'entraînement et de test. Ici, 80% des données sont utilisées pour l'entraînement et 20% pour le test.

Le modèle est évalué en utilisant l'erreur quadratique moyenne et le R-carré. L'erreur quadratique moyenne (MSE) mesure la moyenne des carrés des erreurs ou des écarts.

Le R-carré (R2) est une mesure statistique qui représente la proportion de la variance d'une variable dépendante expliquée par une ou plusieurs variables indépendantes dans un modèle de régression.

Sortie :

Mean Squared Error: 0.7006855912225249
R-squared: 0.4652924370503557

La sortie ci-dessus fournit deux indicateurs clés pour évaluer la performance du modèle de régression linéaire multiple :

Erreur Quadratique Moyenne (MSE) : 0.7006855912225249 Le MSE mesure la différence moyenne au carré entre les valeurs prédites et les valeurs réelles de la variable cible. Un MSE plus bas indique une meilleure performance du modèle, car cela signifie que le modèle fait des prédictions plus précises. Dans ce cas, le MSE est 0.7006855912225249, ce qui indique que le modèle n'est pas parfait mais a un niveau de précision raisonnable. Les valeurs du MSE devraient généralement être plus proches de 0, des valeurs plus basses indiquant une meilleure performance.

R-carré (R2) : 0.4652924370503557 Le R-carré mesure la proportion de la variance de la variable dépendante qui peut être prédite à partir des variables indépendantes. Il varie de 0 à 1, où 1 indique une prédiction parfaite et 0 indique qu'il n'y a pas de relation linéaire. Dans ce cas, la valeur du R-carré est 0.4652924370503557, ce qui indique qu'environ 46,53 % de la variance de la variable cible peut être expliquée par les variables indépendantes utilisées dans le modèle. Cela suggère que le modèle est capable de capturer une partie significative des relations entre les variables, mais pas l'intégralité.

Vérifions quelques graphiques importants :

Residual Plot
residuals = y_test - y_pred
plt.scatter(y_pred, residuals, alpha=0.5)
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.title('Residual Plot')
plt.axhline(y=0, color='red', linestyle='--')
plt.show()

Predicted vs Actual Plot
plt.scatter(y_test, y_pred, alpha=0.5)
plt.xlabel('Actual Values')
plt.ylabel('Predicted Values')
plt.title('Predicted vs Actual Values')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=4)
plt.show()

Utiliser statsmodels

La bibliothèque Statsmodels en Python est un outil puissant pour l'analyse statistique. Elle fournit un large éventail de modèles statistiques et de tests, y compris la régression linéaire, l'analyse des séries chronologiques et les méthodes non paramétriques.

Dans le contexte de la régression linéaire multiple, statsmodels peut être utilisé pour ajuster un modèle linéaire aux données, puis effectuer divers tests et analyses statistiques sur le modèle. Cela peut être particulièrement utile pour comprendre les relations entre les variables indépendantes et dépendantes, et pour faire des prédictions basées sur le modèle.

import statsmodels.api as sm

Add a constant to the model
X_train_sm = sm.add_constant(X_train)
model_sm = sm.OLS(y_train, X_train_sm).fit()
print(model_sm.summary())

Q-Q Plot for residuals
sm.qqplot(model_sm.resid, line='s')
plt.title('Q-Q Plot of Residuals')
plt.show()

Sortie :

==============================================================================
Dep. Variable:          MedHouseValue   R-squared:                       0.485
Model:                            OLS   Adj. R-squared:                  0.484
Method:                 Least Squares   F-statistic:                     5173.
Date:                Fri, 17 Jan 2025   Prob (F-statistic):               0.00
Time:                        09:40:54   Log-Likelihood:                -20354.
No. Observations:               16512   AIC:                         4.072e+04
Df Residuals:                   16508   BIC:                         4.075e+04
Df Model:                           3                                        
Covariance Type:            nonrobust                                        
==============================================================================
                coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
const          2.0679      0.006    320.074      0.000       2.055       2.081
x1             0.8300      0.007    121.245      0.000       0.817       0.843
x2            -0.1000      0.007    -14.070      0.000      -0.114      -0.086
x3            -0.0397      0.006     -6.855      0.000      -0.051      -0.028
==============================================================================
Omnibus:                     3981.290   Durbin-Watson:                   1.983
Prob(Omnibus):                  0.000   Jarque-Bera (JB):            11583.284
Skew:                           1.260   Prob(JB):                         0.00
Kurtosis:                       6.239   Cond. No.                         1.42
==============================================================================

Voici le résumé du tableau ci-dessus :

Résumé du modèle

Le modèle est un modèle de régression des moindres carrés ordinaires, qui est un type de modèle de régression linéaire. La variable dépendante est MedHouseValue, et le modèle a une valeur R-carré de 0,485, ce qui indique qu'environ 48,5 % de la variation de MedHouseValue peut être expliquée par les variables indépendantes. La valeur R-carré ajustée est de 0,484, qui est une version modifiée du R-carré, pénalisant le modèle pour l'inclusion de variables indépendantes supplémentaires.

Ajustement du modèle

Le modèle a été ajusté en utilisant la méthode des moindres carrés, et la statistique F est de 5173, indiquant que le modèle est un bon ajustement. La probabilité d'observer une statistique F au moins aussi extrême que celle observée, en supposant que l'hypothèse nulle est vraie, est d'environ 0. Cela suggère que le modèle est statistiquement significatif.

Coefficients du modèle

Les coefficients du modèle sont les suivants :

• Le terme constant est 2,0679, ce qui indique que lorsque toutes les variables indépendantes sont à 0, la MedHouseValue prédite est d'environ 2,0679.
• Le coefficient pour x1 (dans ce cas MedInc) est de 0.8300, ce qui indique que pour chaque augmentation d'une unité de MedInc, la valeur prédite de MedHouseValue augmente d'environ 0.83 unités, en supposant que toutes les autres variables indépendantes restent constantes.
• Le coefficient pour x2 (dans ce cas AveRooms) est -0.1000, ce qui indique que pour chaque augmentation d'une unité de x2, la MedHouseValue prédite diminue d'environ 0.10 unités, en supposant que toutes les autres variables indépendantes restent constantes.
• Le coefficient pour x3 (dans ce cas AveOccup) est -0,0397, ce qui indique que pour chaque augmentation d'une unité de x3, la MedHouseValue prédite diminue d'environ 0,04 unités, en supposant que toutes les autres variables indépendantes restent constantes.

Diagnostics du modèle

Les diagnostics du modèle sont les suivants :

• La statistique de test omnibus est de 3981,290, ce qui indique que les résidus ne sont pas distribués normalement.
• La statistique de Durbin-Watson est de 1,983, indiquant qu'il n'y a pas d'autocorrélation significative dans les résidus.
• La statistique du test de Jarque-Bera est 11583,284, ce qui indique que les résidus ne sont pas distribués normalement.
• La skewness des résidus est de 1,260, indiquant que les résidus sont biaisés à droite.
• La kurtosis des résidus est de 6,239, ce qui indique que les résidus sont leptokurtique (c'est-à-dire qu'ils ont un pic plus élevé et des queues plus lourdes qu'une distribution normale).
• Le numéro de condition est de 1,42, ce qui indique que le modèle n'est pas sensible aux petites variations des données.

Gestion de la multicolinéarité

La multicolinéarité est un problème courant dans la régression linéaire multiple, où deux ou plusieurs variables indépendantes sont fortement corrélées entre elles. Cela peut conduire à des estimations instables et peu fiables des coefficients.

Pour détecter et gérer la multicolinéarité, vous pouvez utiliser le Facteur d'Inflation de Variance (VIF). Le VIF mesure combien la variance d'un coefficient de régression estimé augmente si vos prédicteurs sont corrélés. Un VIF de 1 signifie qu'il n'y a pas de corrélation entre un prédicteur donné et les autres prédicteurs. Des valeurs de VIF dépassant 5 ou 10 indiquent une quantité problématique de collinéarité.

Dans le bloc de code ci-dessous, calculons le VIF pour chaque variable indépendante de notre modèle. Si une valeur de VIF est supérieure à 5, vous devriez envisager de supprimer la variable du modèle.

from statsmodels.stats.outliers_influence import variance_inflation_factor

vif_data = pd.DataFrame()
vif_data['Feature'] = selected_features
vif_data['VIF'] = [variance_inflation_factor(X_scaled, i) for i in range(X_scaled.shape[1])]
print(vif_data)

Bar Plot for VIF Values
vif_data.plot(kind='bar', x='Feature', y='VIF', legend=False)
plt.title('Variance Inflation Factor (VIF) by Feature')
plt.ylabel('VIF Value')
plt.show()

Sortie :

   Feature       VIF
0    MedInc  1.120166
1  AveRooms  1.119797
2  AveOccup  1.000488

Les valeurs VIF pour chaque caractéristique sont les suivantes :

• MedInc : La valeur VIF est de 1,120166, ce qui indique une très faible corrélation avec d'autres variables indépendantes. Cela suggère que MedInc n'est pas fortement corrélée avec d'autres variables indépendantes dans le modèle.
• AveRooms : La valeur VIF est de 1,119797, ce qui indique une très faible corrélation avec d'autres variables indépendantes. Cela suggère que AveRooms n'est pas fortement corrélée avec d'autres variables indépendantes dans le modèle.
• AveOccup : La valeur VIF est de 1.000488, indiquant aucune corrélation avec d'autres variables indépendantes. Cela suggère que AveOccup n'est pas corrélé avec d'autres variables indépendantes dans le modèle.

En général, ces valeurs VIF sont toutes inférieures à 5, ce qui indique qu'il n'y a pas de multicolinéarité significative entre les variables indépendantes du modèle. Cela suggère que le modèle est stable et fiable, et que les coefficients des variables indépendantes ne sont pas significativement affectés par la multicolinéarité.

Techniques de validation croisée

La validation croisée est une technique utilisée pour évaluer la performance d'un modèle d'apprentissage automatique. C'est une procédure de rééchantillonnage utilisée pour évaluer un modèle si nous avons un échantillon de données limité. La procédure a un seul paramètre appelé k qui fait référence au nombre de groupes dans lesquels un échantillon de données donné doit être divisé. En tant que tel, la procédure est souvent appelée validation croisée en k plis.

from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X_scaled, y, cv=5, scoring='r2')
print("Cross-Validation Scores:", scores)
print("Mean CV R^2:", scores.mean())

Line Plot for Cross-Validation Scores
plt.plot(range(1, 6), scores, marker='o', linestyle='--')
plt.xlabel('Fold')
plt.ylabel('R-squared')
plt.title('Cross-Validation R-squared Scores')
plt.show()

Sortie :

Cross-Validation Scores: [0.42854821 0.37096545 0.46910866 0.31191043 0.51269138]
Mean CV R^2: 0.41864482644003276

Les scores de validation croisée indiquent comment le modèle performe sur des données non vues. Les scores varient de 0,31191043 à 0,51269138, ce qui indique que la performance du modèle varie selon les différents plis. Un score plus élevé indique une meilleure performance.

Le score moyen de CV R^2 est de 0,41864482644003276, ce qui suggère qu'en moyenne, le modèle explique environ 41,86 % de la variance de la variable cible. C'est un niveau d'explication modéré, ce qui indique que le modèle est quelque peu efficace pour prédire la variable cible, mais pourrait bénéficier d'améliorations ou de perfectionnements supplémentaires.

Ces scores peuvent être utilisés pour évaluer la généralisabilité du modèle et identifier les domaines potentiels à améliorer.

Méthodes de sélection de caractéristiques

La méthode d'élimination récursive des caractéristiques est une technique de sélection des caractéristiques qui élimine de manière récursive les caractéristiques les moins importantes jusqu'à atteindre un certain nombre de caractéristiques spécifié. Cette méthode est particulièrement utile lorsque l'on traite un grand nombre de caractéristiques et que l'objectif est de sélectionner un sous-ensemble des caractéristiques les plus informatives.

Dans le code fourni, vous importez d'abord la classe RFE de sklearn.feature_selection. Ensuite, vous créez une instance de RFE avec un estimateur spécifié (dans ce cas, LinearRegression) et définissez n_features_to_select à 2, indiquant que nous voulons sélectionner les 2 meilleures caractéristiques.

Ensuite, nous ajustons l'objet RFE à nos caractéristiques mises à l'échelle X_scaled et à la variable cible y. L'attribut support_ de l'objet RFE retourne un masque booléen indiquant quelles caractéristiques ont été sélectionnées.

Pour visualiser le classement des caractéristiques, vous créez un DataFrame avec les noms des caractéristiques et leurs classements correspondants. L'attribut ranking_ de l'objet RFE retourne le classement de chaque caractéristique, les valeurs plus faibles indiquant des caractéristiques plus importantes. Vous tracez ensuite un diagramme à barres des classements des caractéristiques, triés par leurs valeurs de classement. Ce graphique nous aide à comprendre l'importance relative de chaque caractéristique dans le modèle.

from sklearn.feature_selection import RFE
rfe = RFE(estimator=LinearRegression(), n_features_to_select=3)
rfe.fit(X_scaled, y)
print("Selected Features:", rfe.support_)

Bar Plot of Feature Rankings
feature_ranking = pd.DataFrame({
   'Feature': selected_features,
   'Ranking': rfe.ranking_
})
feature_ranking.sort_values(by='Ranking').plot(kind='bar', x='Feature', y='Ranking', legend=False)
plt.title('Feature Ranking (Lower is Better)')
plt.ylabel('Ranking')
plt.show()

Sortie :

Selected Features: [ True  True False]

D'après le graphique ci-dessus, les 2 caractéristiques les plus appropriées sont MedInc et AveRooms. Cela peut également être vérifié par la sortie du modèle ci-dessus, car la variable dépendante MedHouseValue dépend principalement de MedInc et AveRooms.

FAQ

Comment implémentez-vous la régression linéaire multiple en Python ?

Pour mettre en œuvre la régression linéaire multiple en Python, vous pouvez utiliser des bibliothèques comme statsmodels ou scikit-learn. Voici un aperçu rapide utilisant scikit-learn :

from sklearn.linear_model import LinearRegression
import numpy as np

Example data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])  # Predictor variables
y = np.array([5, 7, 9, 11])  # Target variable

Create and fit the model
model = LinearRegression()
model.fit(X, y)

Get coefficients and intercept
print("Coefficients:", model.coef_)
print("Intercept:", model.intercept_)

Make predictions
predictions = model.predict(X)
print("Predictions:", predictions)

Cela démontre comment ajuster le modèle, obtenir les coefficients et faire des prédictions.

Quelles sont les hypothèses de la régression linéaire multiple en Python ?

La régression linéaire multiple repose sur plusieurs hypothèses pour garantir des résultats valides :

1. Linéarité : La relation entre les prédicteurs et la variable cible est linéaire.
2. Indépendance : Les observations sont indépendantes les unes des autres.
3. Homoscedasticité : La variance des résidus (erreurs) est constante à tous les niveaux des variables indépendantes.
4. Normalité des résidus : Les résidus sont distribués normalement.
5. Aucune multicolinéarité : Les variables indépendantes ne sont pas fortement corrélées entre elles.

Vous pouvez tester ces hypothèses en utilisant des outils tels que des graphiques des résidus, le Facteur d'Inflation de la Variance (VIF) ou des tests statistiques.

Comment interprétez-vous les résultats de la régression multiple en Python ?

Les indicateurs clés des résultats de régression incluent :

1. Coéfficients (coef_) : Indiquent le changement dans la variable cible pour un changement d'une unité dans le prédicteur correspondant, en gardant les autres variables constantes.

Par exemple : Un coefficient de 2 pour X1 signifie que la variable cible augmente de 2 pour chaque augmentation d'une unité de X1, en maintenant les autres variables constantes.

2.Intercept (intercept_) : Représente la valeur prédite de la variable cible lorsque tous les prédicteurs sont à zéro.

3.R-carré : Exprime la proportion de la variance dans la variable cible expliquée par les prédicteurs.

Un R^2 de 0,85 signifie que 85 % de la variabilité de la variable cible est expliquée par le modèle.

4.Valeurs p (dans statsmodels) : Évaluer la signification statistique des prédicteurs. Une valeur p < 0,05 indique généralement qu'un prédicteur est significatif.

Quelle est la différence entre la régression linéaire simple et la régression linéaire multiple en Python ?

Conclusion

Dans ce tutoriel complet, vous avez appris à mettre en œuvre la régression linéaire multiple en utilisant le jeu de données sur le logement en Californie. Vous avez abordé des aspects cruciaux tels que la multicolinéarité, la validation croisée, la sélection des caractéristiques et la régularisation, offrant une compréhension approfondie de chaque concept. Vous avez également appris à incorporer des visualisations pour illustrer les résidus, l'importance des caractéristiques et la performance globale du modèle. Vous pouvez maintenant facilement construire des modèles de régression robustes en Python et appliquer ces compétences à des problèmes du monde réel.