TP n°4 — Régression Linéaire Multiple avec

scikit-learn
ENSA Kénitra | Cycle Ingénieur

Nom & Prénom : Wiame EL HABTI | Filière : Génie Industrielle

1. Importation des Bibliothèques et Chargement des

Données
On commence par importer les bibliothèques nécessaires : NumPy pour les calculs
matriciels, Pandas pour la manipulation des données, Matplotlib pour la visualisation, et les
modules scikit-learn pour le modèle et l'évaluation.

Le dataset utilisé est House Sales in King County, USA, téléchargé depuis Kaggle. Il
contient des informations sur des ventes immobilières réelles, avec des variables comme la
superficie, le nombre de chambres, l'étage, etc. L'objectif est de prédire le prix de vente à
partir de ces caractéristiques.

In [9]: import numpy as np

import pandas as pd
import [Link] as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from [Link] import mean_squared_error

# Chargement du dataset
data = pd.read_csv("F:\WIAME EL HABTI - kc_house_data.csv")

# Afficher les premières lignes

[Link]()
Out[9]: id date price bedrooms bathrooms sqft_living sqft_lot flo

0 7129300520 20141013T000000 221900.0 3 1.00 1180 5650

1 6414100192 20141209T000000 538000.0 3 2.25 2570 7242

2 5631500400 20150225T000000 180000.0 2 1.00 770 10000

3 2487200875 604000.0 4 3.00 1960 5000

4 1954400510 20150218T000000 510000.0 3 2.00 1680 8080

5 rows × 21 columns

 

In [10]: # Infos générales

[Link]()
[Link]()

# Vérifier les valeurs nulles

print([Link]().sum())
<class '[Link]'>
RangeIndex: 21613 entries, 0 to 21612
Data columns (total 21 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 id 21613 non-null int64
1 date 21613 non-null object
2 price 21613 non-null float64
3 bedrooms 21613 non-null int64
4 bathrooms 21613 non-null float64
5 sqft_living 21613 non-null int64
6 sqft_lot 21613 non-null int64
7 floors 21613 non-null float64
8 waterfront 21613 non-null int64
9 view 21613 non-null int64
10 condition 21613 non-null int64
11 grade 21613 non-null int64
12 sqft_above 21613 non-null int64
13 sqft_basement 21613 non-null int64
14 yr_built 21613 non-null int64
15 yr_renovated 21613 non-null int64
16 zipcode 21613 non-null int64
17 lat 21613 non-null float64
18 long 21613 non-null float64
19 sqft_living15 21613 non-null int64
20 sqft_lot15 21613 non-null int64
dtypes: float64(5), int64(15), object(1)
memory usage: 3.5+ MB
id 0
date 0
price 0
bedrooms 0
bathrooms 0
sqft_living 0
sqft_lot 0
floors 0
waterfront 0
view 0
condition 0
grade 0
sqft_above 0
sqft_basement 0
yr_built 0
yr_renovated 0
zipcode 0
lat 0
long 0
sqft_living15 0
sqft_lot15 0
dtype: int64

2. Nettoyage et Sélection des Variables

 Avant d'entraîner le modèle, on doit préparer le dataset. Les colonnes id, date, lat et long
sont supprimées car elles n'apportent aucune information utile à la prédiction du prix — ce
sont soit des identifiants, soit des coordonnées géographiques sans lien direct avec la
valeur du bien.

On sépare ensuite la variable cible y = price du reste des features regroupées dans la
matrice X. On vérifie les dimensions avec shape pour s'assurer que la préparation est
correcte avant de passer au découpage.

In [11]: # Variable dépendante (cible)

y = data['price']

# Variables indépendantes (on supprime id, date, lat, long et price)

X = [Link](columns=['id', 'date', 'lat', 'long', 'price'])

# Dimensions
print("Shape de X :", [Link])
print("Shape de y :", [Link])

Shape de X : (21613, 16)

Shape de y : (21613,)

3. Division en Ensembles d'Entraînement et de Test

On divise le dataset en deux parties grâce à train_test_split() : 80% pour l'entraînement
et 20% pour le test. Le paramètre random_state=1 garantit que le découpage est
identique à chaque exécution, ce qui assure la reproductibilité des résultats.

L'ensemble d'entraînement ( X_train , y_train ) servira à apprendre les paramètres du

modèle. L'ensemble de test ( X_test , y_test ) restera invisible pendant l'entraînement
et ne sera utilisé qu'en phase d'évaluation.

In [12]: X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=1
)

print("X_train :", X_train.shape)

print("X_test :", X_test.shape)

X_train : (17290, 16)

X_test : (4323, 16)

4. Entraînement du Modèle
On initialise le modèle avec LinearRegression() de scikit-learn. Ce modèle cherche les
coefficients w = (w₁, w₂, ..., wₚ) qui minimisent la somme des erreurs au carré (RSS) entre
les valeurs réelles et les valeurs prédites.
 L'entraînement est lancé via la méthode fit(X_train, y_train). Contrairement à la descente
de gradient manuelle du TP2, scikit-learn résout ce problème de manière analytique, ce qui
est plus rapide et exact sur des datasets de taille raisonnable.

In [14]: regressor = LinearRegression()

[Link](X_train, y_train)

print("Modèle entraîné avec succès !")

print("Coefficients :", regressor.coef_)
print("Intercept :", regressor.intercept_)

Modèle entraîné avec succès !

Coefficients : [-3.49140798e+04 4.09446100e+04 1.04686293e+02 1.44707891e-02
3.00249509e+04 5.36275550e+05 4.15981325e+04 2.03397100e+04
1.18970487e+05 4.88602765e+01 5.58260171e+01 -3.44783200e+03
1.28216995e+01 2.81874617e+01 2.60924487e+01 -5.23813229e-01]
Intercept : 3193862.11966628

5. Évaluation des Performances du Modèle

Pour évaluer la qualité du modèle, on utilise trois indicateurs complémentaires :

R² (coefficient de détermination) : mesure la proportion de variance expliquée par le

modèle. Une valeur proche de 1 indique un bon ajustement. On le calcule sur le train et
le test pour détecter un éventuel overfitting.
MSE (Mean Squared Error) : moyenne des erreurs au carré. Pénalise fortement les
grandes erreurs.
RMSE (Root MSE) : racine du MSE, exprimée dans la même unité que y (ici en USD),
donc plus interprétable.

In [15]: # Prédictions sur le test set

y_pred = [Link](X_test)

# ---- R² Score ----

r2_train = [Link](X_train, y_train)
r2_test = [Link](X_test, y_test)
print(f"R² Train : {r2_train:.4f}")
print(f"R² Test : {r2_test:.4f}")

# ---- MSE et RMSE ----

mse = mean_squared_error(y_test, y_pred)
rmse = [Link](mse)
print(f"MSE : {mse:.2f}")
print(f"RMSE : {rmse:.2f}")

R² Train : 0.6530
R² Test : 0.6533
MSE : 59842877532.23
RMSE : 244628.04

6. Analyse des Résidus

 Le graphe des résidus représente la différence entre les valeurs réelles et les valeurs
prédites par le modèle. Si le modèle est bien ajusté, ces résidus doivent être distribués
aléatoirement autour de zéro, sans aucun pattern visible.

Sur notre graphe, on observe une dispersion qui s'élargit pour les prix élevés —
phénomène appelé hétéroscédasticité. Cela indique que la régression linéaire multiple
atteint ses limites sur ce dataset : la relation entre les features et le prix n'est pas
parfaitement linéaire, et un modèle plus complexe (régression polynomiale, Random
Forest...) pourrait mieux capturer cette structure.

In [16]: # ---- Residual Plot ----

residuals = y_test - y_pred

[Link](figsize=(10, 5))
[Link](x=y_pred, y=residuals, lowess=True,
line_kws={'color': 'red', 'lw': 2})
[Link]("Valeurs prédites")
[Link]("Résidus")
[Link]("Residual Plot")
[Link](0, color='black', linestyle='--')
[Link]()

Analyse du Residual Plot

En observant le graphe des résidus, on peut tirer les conclusions suivantes :

Pour les prix bas (partie gauche) : les résidus sont très concentrés autour de zéro —
le modèle prédit correctement dans cette zone.
Pour les prix élevés (partie droite) : les résidus s'écartent de plus en plus de zéro —
le modèle devient moins précis pour les maisons chères.
 La courbe rouge (LOWESS) n'est pas parfaitement horizontale, ce qui confirme que
les erreurs ne sont pas aléatoires et uniformes.

On observe donc un phénomène d'hétéroscédasticité : la variance des résidus augmente

avec les valeurs prédites. Cela indique que la régression linéaire multiple atteint ses
limites sur ce dataset — la relation entre les features et le prix n'est pas purement linéaire.
Des modèles plus avancés comme Random Forest ou XGBoost permettraient de mieux
capturer cette structure et d'améliorer les prédictions.

Conclusion Générale

Dans ce TP, nous avons implémenté une régression linéaire multiple en Python à l'aide
de la bibliothèque scikit-learn, appliquée à un dataset réel de ventes immobilières (King
County, USA).

Nous avons suivi un pipeline complet et structuré : chargement et nettoyage des

données, sélection des variables, division train/test, entraînement du modèle, et enfin
évaluation des performances via le R², le MSE, le RMSE et le graphe des résidus.

Les résultats montrent que le modèle capture une bonne partie de la structure des données.
Cependant, l'analyse des résidus révèle une hétéroscédasticité — la variance des erreurs
augmente pour les prix élevés — ce qui indique que la relation entre les features et le prix
n'est pas purement linéaire.

Ce TP nous a également permis de comparer deux approches : la descente de gradient

manuelle implémentée dans le TP2, et la résolution analytique automatique de scikit-
learn. Les deux convergent vers le même objectif — minimiser l'erreur de prédiction — mais
scikit-learn offre une solution plus rapide, robuste et directement applicable sur des
datasets réels à multiples variables.