Cet article détaille la mise en œuvre d'un modèle de régression linéaire pour prédire les prix des maisons en utilisant le jeu de données de Boston. Nous couvrirons le chargement des données, leur prétraitemnet, l'entraînement du modèle et l'évaluation de ses performances.

1. Configuration de l'environnement et chargement des données

Nous commençons par importer les bibliothèques nécessaires et charger le jeu de données Boston. Notez que le jeu de données original de scikit-learn load_boston n'est plus disponible ; nous utilisons une méthode alternative pour le récupérer.

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, root_mean_squared_error, mean_absolute_error

# Charger le jeu de données Boston depuis une URL
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_dataframe = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
# Combiner les données brutes pour former les caractéristiques et la cible
# Les lignes paires contiennent des caractéristiques, les lignes impaires contiennent des caractéristiques et la cible
features = np.hstack([raw_dataframe.values[::2, :], raw_dataframe.values[1::2, :2]])
target = raw_dataframe.values[1::2, 2]

print(f"Forme des caractéristiques : {features.shape}")
print(f"Forme de la cible : {target.shape}")
print(f"Premières 5 lignes de caractéristiques :\n{features[:5]}")
print(f"Premières 5 valeurs cibles : {target[:5]}")

2. Prétraitement des données

Avant d'entraîner le modèle, nous devons prétraiter les données. Cela inclut la division du jeu de données en ensembles d'entraînement et de test, et la standardisation des caractéristiques pour s'assurer qu'elles ont la même échelle.

# Diviser les données en ensembles d'entraînement et de test (80% entraînement, 20% test)
# random_state assure la reproductibilité de la division
X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)

# Initialiser l'objet StandardScaler pour la standardisation
scaler = StandardScaler()

# Ajuster le scaler sur les données d'entraînement et transformer ces données
X_train_scaled = scaler.fit_transform(X_train)

# Transformer les données de test en utilisant le scaler ajusté sur les données d'entraînement
X_test_scaled = scaler.transform(X_test)

print(f"\nForme des caractéristiques d'entraînement après mise à l'échelle : {X_train_scaled.shape}")
print(f"Forme des caractéristiques de test après mise à l'échelle : {X_test_scaled.shape}")

3. Entraînement du modèle de régression linéaire

Nous utilisons maintenant la régression linéaire pour entraîner un modèle sur les données d'entraînement prétraitées. Nous instancions le modèle et le entraînons à l'aide de la méthode fit.

# Initialiser le modèle de régression linéaire
# fit_intercept=True inclut le terme d'intercept (biais) dans le modèle
linear_reg_model = LinearRegression(fit_intercept=True)

# Entraîner le modèle sur les données d'entraînement mises à l'échelle
linear_reg_model.fit(X_train_scaled, y_train)

# Afficher les coefficients (poids) et l'intercept (biais) calculés par le modèle
print(f"\nCoefficients (poids) du modèle : {linear_reg_model.coef_}")
print(f"Intercept (biais) du modèle : {linear_reg_model.intercept_}")

4. Prédiction et évaluation du modèle

Une fois le modèle entraîné, nous faisons des prédictions sur l'ensemble de test et évaluons ses performances à l'aide de métriques courantes telles que l'erreur quadratique moyenne (MSE), l'erreur quadratique moyenne racine (RMSE) et l'erreur absolue moyenne (MAE).

# Faire des prédictions sur l'ensemble de test mis à l'échelle
y_predicted = linear_reg_model.predict(X_test_scaled)

print(f"\nQuelques prédictions du modèle : {y_predicted[:5]}")
print(f"Véritables valeurs cibles : {y_test[:5]}")

# Évaluer le modèle
mse = mean_squared_error(y_test, y_predicted)
rmse = root_mean_squared_error(y_test, y_predicted)
mae = mean_absolute_error(y_test, y_predicted)

print(f"\nErreur quadratique moyenne (MSE) : {mse:.2f}")
print(f"Erreur quadratique moyenne racine (RMSE) : {rmse:.2f}")
print(f"Erreur absolue moyenne (MAE) : {mae:.2f}")

5. Code complet

Voici le script Python complet intégrant toutes les étapes décrites ci-dessus.

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, root_mean_squared_error, mean_absolute_error

# 1. Charger le jeu de données Boston
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_dataframe = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
features = np.hstack([raw_dataframe.values[::2, :], raw_dataframe.values[1::2, :2]])
target = raw_dataframe.values[1::2, 2]

print(f"Forme des caractéristiques : {features.shape}")
print(f"Forme de la cible : {target.shape}")

# 2. Prétraitement des données
X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3. Entraînement du modèle
linear_reg_model = LinearRegression(fit_intercept=True)
linear_reg_model.fit(X_train_scaled, y_train)

print(f"Coefficients : {linear_reg_model.coef_}")
print(f"Intercept : {linear_reg_model.intercept_}")

# 4. Prédiction et évaluation
y_predicted = linear_reg_model.predict(X_test_scaled)

print(f"Prédictions : {y_predicted[:5]}")

mse = mean_squared_error(y_test, y_predicted)
rmse = root_mean_squared_error(y_test, y_predicted)
mae = mean_absolute_error(y_test, y_predicted)

print(f"MSE : {mse:.2f}")
print(f"RMSE : {rmse:.2f}")
print(f"MAE : {mae:.2f}")