Prédiction du prix des maisons avec Sklearn
Ensuite, nous utilisons sklearn pour prédire les prix des logements à Pékin.
Nous allons procéder étape par étape, du chargement des données, de l'analyse exploratoire et de l'ingénierie des fonctionnalités à l'entraînement et à l'optimisation du modèle, en démontrant comment utiliser les outils et bibliothèques de sklearn pour accomplir la tâche de prédiction.
Aperçu :
1. Génération et inspection des données
- Un dictionnaire est utilisé pour créer des données simulées, puis il est converti en
pandas DataFrame。 - Les données contiennent la surface de la maison, le nombre de pièces, l'étage, l'année de construction, l'emplacement (variable catégorielle) et le prix de la maison (variable cible).
- Via
df.head()etdf.describe()pour vérifier la structure de base et les informations statistiques des données.
2. Prétraitement des données
- Sélection des caractéristiques: Les caractéristiques liées au prix de la maison (surface, nombre de pièces, étage, année de construction, emplacement) sont sélectionnées à partir des données d'origine.
- Division des données: Utiliser
train_test_splitpour diviser le jeu de données en un ensemble d'entraînement de 80% et un ensemble de test de 20%. - Standardisation des caractéristiques numériques: Utilisez
StandardScalerpour standardiser les caractéristiques numériques. - Encodage des caractéristiques catégorielles: Utilisez
OneHotEncoderpour les caractéristiques catégorielles (location) effectuer un encodage One-Hot. ColumnTransformerIntégrez le traitement des caractéristiques numériques et catégorielles en une seule étape.
3. Entraînement du modèle
- Utiliser
Pipelinepour combiner le prétraitement des données avec les étapes d'entraînement du modèle, en garantissant que l'ensemble du processus est en pipeline. - Utilisez le modèle de régression linéaire (
LinearRegression) pour l'entraînement.
4. Évaluation du modèle
- En
mean_squared_erroren calculant l'erreur quadratique moyenne (MSE), et enr2_scorecalculant le coefficient de détermination (R²). - Afficher les résultats d'évaluation pour visualiser la précision de prédiction du modèle.
5. Optimisation du modèle
- Utiliser
GridSearchCVpour régler les hyperparamètres de la régression linéaire. Le principal réglage estfit_intercept(s'il faut ajuster l'ordonnée à l'origine). - Trouver les meilleurs hyperparamètres par recherche sur grille, et utiliser le meilleur modèle pour prédire sur l'ensemble de test.
- Recalculer les métriques d'évaluation (MSE et R²) du modèle optimisé.
1. Génération et inspection des données
Nous construisons d'abord un DataFrame simulé contenant quelques caractéristiques courantes de prédiction des prix immobiliers, telles que la surface de la maison, le nombre de pièces, l'étage, l'année de construction et l'emplacement géographique (variable catégorielle).
Exemple
import numpy as np
# Données simulées : surface de la maison (mètres carrés), nombre de pièces, étage, année de construction, emplacement (variable catégorielle)
data = {
'area': [70, 85, 100, 120, 60, 150, 200, 80, 95, 110],
'rooms': [2, 3, 3, 4, 2, 5, 6, 3, 3, 4],
'floor': [5, 2, 8, 10, 3, 15, 18, 7, 9, 11],
'year_built': [2005, 2010, 2012, 2015, 2000, 2018, 2020, 2008, 2011, 2016],
'location': ['Chaoyang', 'Haidian', 'Chaoyang', 'Dongcheng', 'Fengtai', 'Haidian', 'Chaoyang', 'Fengtai', 'Dongcheng', 'Haidian'],
'price': [5000000, 6000000, 6500000, 7000000, 4500000, 10000000, 12000000, 5500000, 6200000, 7500000] # Prix de la maison (variable cible)
}
# Créer un DataFrame
df = pd.DataFrame(data)
# Afficher les données
print("Aperçu des données :")
print(df.head())
Sortie :
数据预览: area rooms floor year_built location price 0 70 2 5 2005 Chaoyang 5000000 1 85 3 2 2010 Haidian 6000000 2 100 3 8 2012 Chaoyang 6500000 3 120 4 10 2015 Dongcheng 7000000 4 60 2 3 2000 Fengtai 4500000
2. Prétraitement des données
Le prétraitement des données comprend généralement la sélection des caractéristiques, la transformation des caractéristiques, le traitement des valeurs manquantes, la standardisation des données, etc. Nous allons standardiser les caractéristiques numériques et encoder en one-hot les caractéristiques catégorielles.
Exemple
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
# Sélection des caractéristiques
X = df[['area', 'rooms', 'floor', 'year_built', 'location']] # Caractéristiques
y = df['price'] # Variable cible
# Diviser l'ensemble d'entraînement et l'ensemble de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Construire les étapes de prétraitement
numeric_features = ['area', 'rooms', 'floor', 'year_built']
categorical_features = ['location']
numeric_transformer = Pipeline(steps=[
('scaler', StandardScaler()) # Standardiser les caractéristiques numériques
])
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore')) # Gérer les nouvelles catégories dans l'ensemble de test
])
# Combiner dans ColumnTransformer
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
]
)
# Afficher la structure après le prétraitement des données
X_train_transformed = preprocessor.fit_transform(X_train)
print("Données d'entraînement prétraitées :")
print(X_train_transformed)
Le résultat de sortie est:
tianqixin@Mac-mini example-test % python3 test.py 预处理后的训练数据: [[ 0.89826776 1.0440738 1.14636101 0.96800387 0. 0. 0. 1. ] [-0.95622052 -1.23390539 -0.98640366 -1.04544418 1. 0. 0. 0. ] [-0.72440948 -0.474579 -0.55985073 -0.58080232 0. 0. 1. 0. ] [-0.26078741 -0.474579 -0.34657426 0.03872015 1. 0. 0. 0. ] [-0.02897638 0.2847474 0.29325514 0.65824263 0. 0. 0. 1. ] [-1.18803155 -1.23390539 -1.4129566 -1.81984727 0. 0. 1. 0. ] [ 0.20283466 0.2847474 0.07997868 0.50336201 0. 1. 0. 0. ] [ 2.05732294 1.80340019 1.78619041 1.2777651 1. 0. 0. 0. ]]
3. Construction du modèle
Ensuite, nous utilisons un modèle de régression linéaire pour prédire les prix des maisons. Nous utilisons un Pipeline pour intégrer les étapes de prétraitement et d'entraînement du modèle.
Exemple
# Construire un Pipeline contenant le prétraitement et un modèle de régression
model_pipeline = Pipeline(steps=[
('preprocessor', preprocessor), # Étapes de prétraitement des données
('regressor', LinearRegression()) # Modèle de régression
])
# Entraîner le modèle
model_pipeline.fit(X_train, y_train)
# Faire des prédictions
y_pred = model_pipeline.predict(X_test)
# Afficher les résultats de prédiction
print("\nRésultats de prédiction :")
print(y_pred)
Le résultat de sortie est:
预测结果: [6375000.00000001 4874999.99999998]
4. Évaluation du modèle
Dans l'évaluation de modèle, nous utilisons généralement l'erreur quadratique moyenne (MSE) et le coefficient de détermination (R²) pour évaluer les performances d'un modèle de régression.
Exemple
# Calculer l'erreur quadratique moyenne (MSE) et le coefficient de détermination (R²)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
# Afficher les résultats d'évaluation
print("\nÉvaluation du modèle :")
print(f"Erreur quadratique moyenne (MSE) : {mse:.2f}")
print(f"Coefficient de détermination (R²) : {r2:.2f}")
Le résultat de sortie est:
预测结果: [6375000.00000001 4874999.99999998] tianqixin@Mac-mini example-test % python3 test.py 模型评估: 均方误差 (MSE): 648125000000.03 决定系数 (R²): -63.81
5. Optimisation du modèle (recherche sur grille)
Pour améliorer les performances du modèle, nous pouvons utiliser GridSearchCV pour régler les hyperparamètres du modèle. Dans cet exemple, nous n'ajustons pas les paramètres de la régression linéaire car elle n'a pas beaucoup d'hyperparamètres à régler. Pour les modèles plus complexes (par exemple, Random Forest, XGBoost, etc.), nous pouvons trouver les meilleurs paramètres via une recherche sur grille.
Exemple
# 5. Optimisation du modèle : utiliser la recherche sur grille pour régler les hyperparamètres
# Régler les hyperparamètres de la régression linéaire (ajuster uniquement 'fit_intercept')
param_grid = {
'regressor__fit_intercept': [True, False], # Indique s'il faut ajuster l'ordonnée à l'origine
}
grid_search = GridSearchCV(model_pipeline, param_grid, cv=5, scoring='neg_mean_squared_error', verbose=1)
grid_search.fit(X_train, y_train)
# Afficher les meilleurs paramètres et résultats
print("\nMeilleurs paramètres :")
print(grid_search.best_params_)
# Utiliser le meilleur modèle pour faire des prédictions
best_model = grid_search.best_estimator_
y_pred_optimized = best_model.predict(X_test)
# Afficher les résultats d'évaluation optimisés
mse_opt = mean_squared_error(y_test, y_pred_optimized)
r2_opt = r2_score(y_test, y_pred_optimized)
print("\nÉvaluation du modèle optimisé :")
print(f"Erreur quadratique moyenne (MSE) : {mse_opt:.2f}")
print(f"Coefficient de détermination (R²) : {r2_opt:.2f}")
Le résultat de sortie est:
Fitting 5 folds for each of 2 candidates, totalling 10 fits
最佳参数:
{'regressor__fit_intercept': True}
优化后的模型评估:
均方误差 (MSE): 648125000000.03
决定系数 (R²): -63.81
Code complet
Code complet pour la prédiction des prix des logements à Pékin :
Exemple
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Données simulées : contient la surface de la maison, le nombre de pièces, l'étage, l'année de construction, l'emplacement (variable catégorielle) et le prix de la maison (variable cible)
data = {
'area': [70, 85, 100, 120, 60, 150, 200, 80, 95, 110],
'rooms': [2, 3, 3, 4, 2, 5, 6, 3, 3, 4],
'floor': [5, 2, 8, 10, 3, 15, 18, 7, 9, 11],
'year_built': [2005, 2010, 2012, 2015, 2000, 2018, 2020, 2008, 2011, 2016],
'location': ['Chaoyang', 'Haidian', 'Chaoyang', 'Dongcheng', 'Fengtai', 'Haidian', 'Chaoyang', 'Fengtai', 'Dongcheng', 'Haidian'],
'price': [5000000, 6000000, 6500000, 7000000, 4500000, 10000000, 12000000, 5500000, 6200000, 7500000] # Prix de la maison (variable cible)
}
# Créer un DataFrame
df = pd.DataFrame(data)
# Afficher les données
print("Aperçu des données :")
print(df.head())
# Sélection des caractéristiques
X = df[['area', 'rooms', 'floor', 'year_built', 'location']] # Données de caractéristiques
y = df['price'] # Variable cible
# Diviser l'ensemble d'entraînement et l'ensemble de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Prétraitement des données : standardiser les caractéristiques numériques, encoder en One-Hot les caractéristiques catégorielles
numeric_features = ['area', 'rooms', 'floor', 'year_built']
categorical_features = ['location']
# Prétraitement des caractéristiques numériques : standardisation
numeric_transformer = Pipeline(steps=[
('scaler', StandardScaler())
])
# Prétraitement des caractéristiques catégorielles : encodage One-Hot, définir handle_unknown='ignore'
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore')) # Gérer les nouvelles catégories dans l'ensemble de test
])
# Fusionner les étapes de traitement pour les caractéristiques numériques et catégorielles
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
]
)
# 3. Construire le modèle
# Utiliser un modèle de régression linéaire, combiné à des étapes de prétraitement des données
model_pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('regressor', LinearRegression())
])
# Entraîner le modèle
model_pipeline.fit(X_train, y_train)
# Faire des prédictions
y_pred = model_pipeline.predict(X_test)
# Afficher les résultats de prédiction
print("\nRésultats de prédiction :")
print(y_pred)
# 4. Évaluation du modèle : calculer l'erreur quadratique moyenne (MSE) et le coefficient de détermination R²
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print("\nÉvaluation du modèle :")
print(f"Erreur quadratique moyenne (MSE) : {mse:.2f}")
print(f"Coefficient de détermination (R²) : {r2:.2f}")
# 5. Optimisation du modèle : utiliser la recherche sur grille pour régler les hyperparamètres
# Régler les hyperparamètres de la régression linéaire (ajuster uniquement 'fit_intercept')
param_grid = {
'regressor__fit_intercept': [True, False], # Indique s'il faut ajuster l'ordonnée à l'origine
}
grid_search = GridSearchCV(model_pipeline, param_grid, cv=5, scoring='neg_mean_squared_error', verbose=1)
grid_search.fit(X_train, y_train)
# Afficher les meilleurs paramètres et résultats
print("\nMeilleurs paramètres :")
print(grid_search.best_params_)
# Utiliser le meilleur modèle pour faire des prédictions
best_model = grid_search.best_estimator_
y_pred_optimized = best_model.predict(X_test)
# Afficher les résultats d'évaluation optimisés
mse_opt = mean_squared_error(y_test, y_pred_optimized)
r2_opt = r2_score(y_test, y_pred_optimized)
print("\nÉvaluation du modèle optimisé :")
print(f"Erreur quadratique moyenne (MSE) : {mse_opt:.2f}")
print(f"Coefficient de détermination (R²) : {r2_opt:.2f}")
Après l'exécution de ce code, la sortie est :
数据预览:
area rooms floor year_built location price
0 70 2 5 2005 Chaoyang 5000000
1 85 3 2 2010 Haidian 6000000
2 100 3 8 2012 Chaoyang 6500000
3 120 4 10 2015 Dongcheng 7000000
4 60 2 3 2000 Fengtai 4500000
预测结果:
[6375000.00000001 4874999.99999998]
模型评估:
均方误差 (MSE): 648125000000.03
决定系数 (R²): -63.81
Fitting 5 folds for each of 2 candidates, totalling 10 fits
最佳参数:
{'regressor__fit_intercept': True}
优化后的模型评估:
均方误差 (MSE): 648125000000.03
决定系数 (R²): -63.81
Autres extensions