L'apprentissage automatique transforme divers secteurs, dont l'immobilier. Une tâche courante consiste à prédire les prix des logements en fonction de diverses caractéristiques telles que le nombre de chambres, de salles de bains, la superficie en pieds carrés et l'emplacement. Dans cet article, nous explorerons comment créer un modèle d'apprentissage automatique à l'aide de scikit-learn pour prédire les prix de l'immobilier, couvrant tous les aspects, du prétraitement des données au déploiement du modèle.

Table des matières

1. Introduction à Scikit-learn
2. Définition du problème
3. Collecte de données
4. Prétraitement des données
5. Sélection des fonctionnalités
6. Formation de modèle
7. Évaluation du modèle
8. Réglage du modèle (optimisation des hyperparamètres)
9. Déploiement de modèles
10. Conclusion

1. Introduction à Scikit-learn

Scikit-learn est l'une des bibliothèques les plus utilisées pour l'apprentissage automatique en Python. Il propose des outils simples et efficaces pour l’analyse et la modélisation des données. Qu'il s'agisse de classification, de régression, de clustering ou de réduction de dimensionnalité, scikit-learn fournit un ensemble complet d'utilitaires pour vous aider à créer des modèles d'apprentissage automatique robustes.

Dans ce guide, nous allons créer un modèle de régression en utilisant scikit-learn pour prédire les prix de l'immobilier. Passons en revue chaque étape du processus.

2. Définition du problème

La tâche à accomplir est de prédire le prix d'une maison en fonction de ses caractéristiques telles que :

• Nombre de chambres
• Nombre de salles de bain
• Superficie (en pieds carrés)
• Emplacement

Il s'agit d'un problème d'apprentissage supervisé où la variable cible (prix de l'immobilier) est continue, ce qui en fait une tâche de régression. Scikit-learn fournit une variété d'algorithmes de régression, tels que Régression linéaire et Random Forest, que nous utiliserons dans ce projet.

3. Collecte de données

Vous pouvez soit utiliser un ensemble de données du monde réel comme l'ensemble de données Kaggle House Prices, soit collecter vos propres données à partir d'une API publique.

Voici un exemple de ce à quoi pourraient ressembler vos données :

La variable cible ici est le Prix.

4. Prétraitement des données

Avant d'introduire les données dans un modèle d'apprentissage automatique, nous devons les prétraiter. Cela inclut la gestion des valeurs manquantes, l'encodage des caractéristiques catégorielles et la mise à l'échelle des données.

Gestion des données manquantes

Les données manquantes sont courantes dans les ensembles de données du monde réel. Nous pouvons soit remplir les valeurs manquantes avec une mesure statistique comme la médiane, soit supprimer les lignes avec les données manquantes :

data.fillna(data.median(), inplace=True)

Encodage des fonctionnalités catégorielles

Étant donné que les modèles d'apprentissage automatique nécessitent une saisie numérique, nous devons convertir les fonctionnalités catégorielles telles que l'emplacement en nombres. Label Encoding attribue un numéro unique à chaque catégorie :

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
data['Location'] = encoder.fit_transform(data['Location'])

Mise à l'échelle des fonctionnalités

Il est important de mettre à l'échelle des fonctionnalités telles que la zone et le prix pour garantir qu'elles sont sur la même échelle, en particulier pour les algorithmes sensibles à l'ampleur des fonctionnalités. Voici comment nous appliquons la mise à l'échelle :

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

5. Sélection des fonctionnalités

Toutes les fonctionnalités ne contribuent pas de manière égale à la variable cible. La sélection des fonctionnalités aide à identifier les fonctionnalités les plus importantes, ce qui améliore les performances du modèle et réduit le surajustement.

Dans ce projet, nous utilisons SelectKBest pour sélectionner les 5 principales fonctionnalités en fonction de leur corrélation avec la variable cible :

from sklearn.feature_selection import SelectKBest, f_regression
selector = SelectKBest(score_func=f_regression, k=5)
X_new = selector.fit_transform(X, y)

6. Formation sur modèle

Maintenant que nous avons prétraité les données et sélectionné les meilleures fonctionnalités, il est temps d'entraîner le modèle. Nous utiliserons deux algorithmes de régression : Régression linéaire et Random Forest.

Régression linéaire

La régression linéaire trace une ligne droite à travers les données, minimisant ainsi la différence entre les valeurs prédites et réelles :

from sklearn.linear_model import LinearRegression
linear_model = LinearRegression()
linear_model.fit(X_train, y_train)

Forêt aléatoire

Random Forest est une méthode d'ensemble qui utilise plusieurs arbres de décision et fait la moyenne de leurs résultats pour améliorer la précision et réduire le surajustement :

from sklearn.ensemble import RandomForestRegressor
forest_model = RandomForestRegressor(n_estimators=100)
forest_model.fit(X_train, y_train)

Répartition Train-Test

Pour évaluer dans quelle mesure nos modèles se généralisent, nous divisons les données en ensembles de formation et de test :

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_new, y, test_size=0.2, random_state=42)

7. Évaluation du modèle

Après avoir entraîné les modèles, nous devons évaluer leurs performances à l'aide de métriques telles que Erreur quadratique moyenne (MSE) et R-carré (R²).

Erreur quadratique moyenne (MSE)

MSE calcule la différence quadratique moyenne entre les valeurs prédites et réelles. Un MSE inférieur indique de meilleures performances :

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_test, y_pred)

R carré (R²)

R² nous indique dans quelle mesure le modèle explique la variance de la variable cible. Une valeur de 1 signifie une prédiction parfaite :

from sklearn.metrics import r2_score
r2 = r2_score(y_test, y_pred)

Comparez les performances des modèles de régression linéaire et de forêt aléatoire à l'aide de ces métriques.

8. Réglage du modèle (optimisation des hyperparamètres)

Pour améliorer encore les performances du modèle, nous pouvons affiner les hyperparamètres. Pour Random Forest, les hyperparamètres tels que n_estimators (nombre d'arbres) et max_degree (profondeur maximale des arbres) peuvent avoir un impact significatif sur les performances.

Voici comment utiliser GridSearchCV pour l'optimisation des hyperparamètres :

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20]
}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5)
grid_search.fit(X_train, y_train)

best_model = grid_search.best_estimator_

9. Déploiement du modèle

Une fois que vous avez formé et réglé le modèle, l'étape suivante est le déploiement. Vous pouvez utiliser Flask pour créer une application Web simple qui sert des prédictions.

Voici une application Flask de base pour servir de prévisions sur les prix de l'immobilier :

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# Load the trained model
model = joblib.load('best_model.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    prediction = model.predict([data['features']])
    return jsonify({'predicted_price': prediction[0]})

if __name__ == '__main__':
    app.run()

Enregistrez le modèle entraîné à l'aide de joblib :

import joblib
joblib.dump(best_model, 'best_model.pkl')

De cette façon, vous pouvez faire des prédictions en envoyant des requêtes à l'API.

10. Conclusion

Dans ce projet, nous avons exploré l'ensemble du processus de création d'un modèle d'apprentissage automatique utilisant scikit-learn pour prédire les prix de l'immobilier. Du prétraitement des données et de la sélection des fonctionnalités à la formation, à l'évaluation et au déploiement du modèle, chaque étape a été couverte par des exemples de code pratiques.

Que vous soyez nouveau dans l'apprentissage automatique ou que vous cherchiez à appliquer scikit-learn à des projets du monde réel, ce guide fournit un flux de travail complet que vous pouvez adapter à diverses tâches de régression.

N'hésitez pas à expérimenter différents modèles, ensembles de données et techniques pour améliorer les performances et la précision de votre modèle.

Régression #AI ​​#DataAnalysis #DataPreprocessing #MLModel #RandomForest #LinearRegression #Flask #APIDevelopment #RealEstate #TechBlog #Tutorial #DataEngineering #DeepLearning #PredictiveAnalytics #DevCommunity