Apprentissage automatique - Prédiction du prix des maisons

Lorsqu’on achète une maison, on porte généralement un jugement global : emplacement, surface, âge du bien, nombre de pièces, densité de population, conditions de transport, etc. Chaque facteur influence le prix, mais cette influence n’est ni linéaire ni unique ; elle résulte plutôt d’une accumulation, de compromis et d’une concurrence entre les facteurs.

En apprentissage automatique,les problèmes de régressiontransforment, par essence, ce « jugement fondé sur l’expérience » en un modèle mathématique calculable, réutilisable et évaluable.

Ce chapitre partira de zéro et parcourra le pipeline standard complet d’apprentissage automatique deprédiction du prix des maisons: compréhension des données → analyse des caractéristiques → entraînement du modèle → évaluation du modèle → optimisation du modèle. L’objectif n’est pas de mémoriser les API, mais de comprendre ce que fait chaque étape et pourquoi elle est effectuée.

Partie 1 : Préparation du projet et configuration de l’environnement

1.1 Outils principaux utilisés

  • NumPy: un outil de calcul numérique de bas niveau qui fournit des opérations efficaces sur les tableaux.
  • Pandas: un outil essentiel pour l’analyse de données tabulaires, indispensable aux premières étapes de l’apprentissage automatique.
  • Matplotlib / Seaborn: visualisation de données, utilisée pour comprendre les distributions et les relations des données.
  • Scikit-learn: une boîte à outils d’apprentissage automatique couvrant les jeux de données, les modèles et les méthodes d’évaluation.

1.2 Installation des dépendances

pip install numpy pandas matplotlib seaborn scikit-learn

Partie 2 : Chargement et compréhension du jeu de données

Les premiers tutoriels utilisaient souvent le jeu de données Boston Housing, mais il a été déprécié. Ici, nous utilisons le jeu de données officiellement recommandéCalifornia Housing, qui a le même concept mais des données plus standardisées.

Exemple : Chargement des données

import pandas as pd
from sklearn.datasets import fetch_california_housing

# Charger le jeu de données des prix des logements en Californie
data = fetch_california_housing()

# Données de caractéristiques (X)
df_features = pd.DataFrame(
    data.data,
    columns=data.feature_names
)

# Variable cible (y) : valeur médiane des logements
df_target = pd.DataFrame(
    data.target,
    columns=['MedHouseVal']
)

print(df_features.head())
print(df_target.head())

Sortie :

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

À ce stade, vous devez avoir compris trois choses :

  • Chaque ligne correspond aux caractéristiques statistiques d'une maison
  • Chaque colonne est une variable qui peut être utilisée pour la prédiction
  • MedHouseValest la cible que nous voulons prédire

Partie 3 : Analyse exploratoire des données (EDA)

Avant d'entraîner le modèle, vous devez d'abord répondre à une question :Les données valent-elles la peine d'être utilisées pour l'apprentissage ?

3.1 Vérification de la structure des données et des valeurs manquantes

Exemple : Aperçu des données

print("Dimensions des caractéristiques :", df_features.shape)
print("Dimensions de la cible :", df_target.shape)

print("\n"Types de données et valeurs manquantes :")
df_features.info()

print("\n"Statistiques des valeurs manquantes :")
print(df_features.isnull().sum())

Conclusion :

  • Taille d'échantillon suffisante (environ 20,000 entrées)
  • Toutes les caractéristiques sont numériques
  • Aucune valeur manquante, on peut directement construire le modèle

3.2 Relation entre une caractéristique unique et le prix des maisons

L'apprentissage automatique n'est pas une boîte noire ; au moins au stade introductif, vous devez savoir ce que le modèle apprend.

Exemple : Relation entre le nombre de pièces et le prix des maisons

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 6))
plt.scatter(df_features['AveRooms'], df_target['MedHouseVal'], alpha=0.4)
plt.xlabel('Nombre moyen de pièces')
plt.ylabel('Valeur médiane des logements')
plt.title('Nombre de pièces vs prix des logements')
plt.grid(True)
plt.show()

Conclusion intuitive : plus il y a de pièces, plus le prix des logements est globalement élevé, mais il y a une dispersion importante. C'est exactement l'objectif d'un modèle de régression.

3.3 Analyse de corrélation des caractéristiques

Exemple : carte de chaleur des corrélations

import seaborn as sns

df_all = pd.concat([df_features, df_target], axis=1)
corr = df_all.corr()

plt.figure(figsize=(10, 8))
sns.heatmap(corr, cmap='coolwarm', center=0)
plt.title('Carte de chaleur des corrélations des caractéristiques')
plt.show()

Le but de cette étape n'est pas de « sélectionner un modèle », mais de confirmer : il existe bien une relation statistique qui peut être apprise.

Partie 4 : Construction du premier modèle de régression

4.1 Séparation de l'ensemble d'entraînement et de l'ensemble de test

Le modèle ne peut pas utiliser le même lot de données à la fois pour apprendre et pour être testé ; sinon, les résultats de l'évaluation n'ont pas de sens.

Exemple : fractionnement du jeu de données

from sklearn.model_selection import train_test_split

X = df_features
y = df_target['MedHouseVal']

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

print("Ensemble d'entraînement :", X_train.shape)
print("Ensemble de test :", X_test.shape)

4.2 Entraînement d'un modèle de régression linéaire

Exemple : entraînement du modèle

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)

print("Ordonnée à l'origine :", model.intercept_)
print("Coefficients :")
for name, coef in zip(X.columns, model.coef_):
    print(f"{name}: {coef:.4f}")

L'avantage de la régression linéaire est :une forte interprétabilité,adaptée à la compréhension de l'essence des problèmes de régression.

Partie 5 : Prédiction et évaluation du modèle

5.1 Comparaison des résultats de prédiction

Exemple : Prédictions vs. Valeurs réelles

y_pred = model.predict(X_test)

result = pd.DataFrame({
    "Actual": y_test.values,
    "Predicted": y_pred
})

print(result.head())

5.2 Quantification du modèle avec des métriques d'évaluation

Exemple : Métriques d'évaluation

from sklearn.metrics import mean_squared_error, r2_score

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print("MSE:", mse)
print("R2:", r2)

Explication :

  • Plus la MSE est petite, plus l'erreur de prédiction est faible
  • Plus R² est proche de 1, plus le pouvoir explicatif du modèle est fort

Partie 6 : Optimisation du modèle – Standardisation et régression Ridge

6.1 Pourquoi standardiser ?

Des différences énormes dans les échelles des caractéristiques conduiront le modèle à privilégier les caractéristiques ayant des valeurs plus élevées.

Exemple : standardisation des caractéristiques

from sklearn.preprocessing import StandardScaler

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

6.2 Utilisation de la régression Ridge pour supprimer le surapprentissage

Exemple : régression Ridge

from sklearn.linear_model import Ridge

ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)

y_pred_ridge = ridge.predict(X_test_scaled)

print("Ridge MSE:", mean_squared_error(y_test, y_pred_ridge))
print("Ridge R2:", r2_score(y_test, y_pred_ridge))

Partie 7 : Révision complète du pipeline

Autres extensions