Prédire les prix des logements avec Scikit-learn : un guide complet

Maschinelles Lernen verändert verschiedene Branchen, darunter auch die Immobilienbranche. Eine häufige Aufgabe besteht darin, Immobilienpreise anhand verschiedener Merkmale wie der Anzahl der Schlafzimmer, Badezimmer, der Quadratmeterzahl und der Lage vorherzusagen. In diesem Artikel untersuchen wir, wie man mithilfe von scikit-learn ein Modell für maschinelles Lernen erstellt, um Immobilienpreise vorherzusagen, das alle Aspekte von der Datenvorverarbeitung bis zur Modellbereitstellung abdeckt.

Inhaltsverzeichnis

1. Einführung in Scikit-learn
2. Problemdefinition
3. Datenerfassung
4. Datenvorverarbeitung
5. Funktionsauswahl
6. Modeltraining
7. Modellbewertung
8. Modelloptimierung (Hyperparameteroptimierung)
9. Modellbereitstellung
10. Fazit

1. Einführung in Scikit-learn

Scikit-learn ist eine der am häufigsten verwendeten Bibliotheken für maschinelles Lernen in Python. Es bietet einfache und effiziente Werkzeuge zur Datenanalyse und -modellierung. Egal, ob Sie sich mit Klassifizierung, Regression, Clustering oder Dimensionsreduktion befassen, scikit-learn bietet eine umfangreiche Reihe von Dienstprogrammen, die Sie beim Aufbau robuster Modelle für maschinelles Lernen unterstützen.

In diesem Leitfaden erstellen wir ein Regressionsmodell mithilfe von scikit-learn, um Immobilienpreise vorherzusagen. Lassen Sie uns jeden Schritt des Prozesses durchgehen.

2. Problemdefinition

Die vorliegende Aufgabe besteht darin, den Preis eines Hauses anhand seiner Merkmale vorherzusagen, wie zum Beispiel:

• Anzahl der Schlafzimmer
• Anzahl der Badezimmer
• Fläche (in Quadratfuß)
• Standort

Dies ist ein überwachtes Lernproblem, bei dem die Zielvariable (Hauspreis) kontinuierlich ist, was es zu einer Regressionsaufgabe macht. Scikit-learn bietet eine Vielzahl von Algorithmen für die Regression, wie zum Beispiel Lineare Regression und Random Forest, die wir in diesem Projekt verwenden werden.

3. Datenerfassung

Sie können entweder einen realen Datensatz wie den Kaggle House Prices-Datensatz verwenden oder Ihre eigenen Daten von einer öffentlichen API sammeln.

Hier ist ein Beispiel dafür, wie Ihre Daten aussehen könnten:

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 caractéristiques 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 meilleures 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 Forêt aléatoire.

Régression linéaire

La régression linéaire trace une ligne droite à travers les données, minimisant 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 d'entraînement 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 le 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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!