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.
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.
Die vorliegende Aufgabe besteht darin, den Preis eines Hauses anhand seiner Merkmale vorherzusagen, wie zum Beispiel:
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.
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:
| Bedrooms | Bathrooms | Area (sq.ft) | Location | Price ($) |
|---|---|---|---|---|
| 3 | 2 | 1500 | Boston | 300,000 |
| 4 | 3 | 2000 | Seattle | 500,000 |
Die Zielvariable ist hier der Preis.
Bevor wir die Daten in ein maschinelles Lernmodell einspeisen, müssen wir sie vorverarbeiten. Dazu gehört der Umgang mit fehlenden Werten, die Kodierung kategorialer Merkmale und die Skalierung der Daten.
Fehlende Daten kommen in realen Datensätzen häufig vor. Wir können fehlende Werte entweder mit einem statistischen Maß wie dem Median füllen oder Zeilen mit fehlenden Daten löschen:
data.fillna(data.median(), inplace=True)
Da Modelle für maschinelles Lernen numerische Eingaben erfordern, müssen wir kategoriale Merkmale wie den Standort in Zahlen umwandeln. Label Encoding weist jeder Kategorie eine eindeutige Nummer zu:
from sklearn.preprocessing import LabelEncoder encoder = LabelEncoder() data['Location'] = encoder.fit_transform(data['Location'])
Es ist wichtig, Merkmale wie Fläche und Preis zu skalieren, um sicherzustellen, dass sie im gleichen Maßstab liegen, insbesondere bei Algorithmen, die empfindlich auf die Merkmalsgröße reagieren. So wenden wir die Skalierung an:
from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_scaled = scaler.fit_transform(X)
Nicht alle Funktionen tragen gleichermaßen zur Zielvariablen bei. Die Feature-Auswahl hilft bei der Identifizierung der wichtigsten Features, was die Modellleistung verbessert und Überanpassungen reduziert.
In diesem Projekt verwenden wir SelectKBest, um die fünf wichtigsten Funktionen basierend auf ihrer Korrelation mit der Zielvariablen auszuwählen:
from sklearn.feature_selection import SelectKBest, f_regression selector = SelectKBest(score_func=f_regression, k=5) X_new = selector.fit_transform(X, y)
Da wir nun die Daten vorverarbeitet und die besten Funktionen ausgewählt haben, ist es an der Zeit, das Modell zu trainieren. Wir verwenden zwei Regressionsalgorithmen: Lineare Regression und Random Forest.
Die lineare Regression passt eine gerade Linie durch die Daten und minimiert so die Differenz zwischen den vorhergesagten und tatsächlichen Werten:
from sklearn.linear_model import LinearRegression linear_model = LinearRegression() linear_model.fit(X_train, y_train)
Random Forest ist eine Ensemble-Methode, die mehrere Entscheidungsbäume verwendet und deren Ergebnisse mittelt, um die Genauigkeit zu verbessern und Überanpassungen zu reduzieren:
from sklearn.ensemble import RandomForestRegressor forest_model = RandomForestRegressor(n_estimators=100) forest_model.fit(X_train, y_train)
Um zu bewerten, wie gut unsere Modelle verallgemeinern, teilen wir die Daten in Trainings- und Testsätze auf:
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)
Nachdem wir die Modelle trainiert haben, müssen wir ihre Leistung anhand von Metriken wie Mittlerer quadratischer Fehler (MSE) und R-Quadrat (R²) bewerten.
MSE berechnet die durchschnittliche quadratische Differenz zwischen den vorhergesagten und den tatsächlichen Werten. Ein niedrigerer MSE weist auf eine bessere Leistung hin:
from sklearn.metrics import mean_squared_error mse = mean_squared_error(y_test, y_pred)
R² sagt uns, wie gut das Modell die Varianz der Zielvariablen erklärt. Ein Wert von 1 bedeutet perfekte Vorhersage:
from sklearn.metrics import r2_score r2 = r2_score(y_test, y_pred)
Vergleichen Sie die Leistung der Modelle „Lineare Regression“ und „Random Forest“ anhand dieser Metriken.
Um die Modellleistung weiter zu verbessern, können wir die Hyperparameter feinabstimmen. Für Random Forest können Hyperparameter wie n_estimators (Anzahl der Bäume) und max_ Depth (maximale Tiefe der Bäume) die Leistung erheblich beeinträchtigen.
So verwenden Sie GridSearchCV für die Hyperparameteroptimierung:
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_
Sobald Sie das Modell trainiert und optimiert haben, ist der nächste Schritt die Bereitstellung. Sie können Flask verwenden, um eine einfache Webanwendung zu erstellen, die Vorhersagen liefert.
Hier ist eine einfache Flask-App zur Vorhersage von Immobilienpreisen:
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()
Speichern Sie das trainierte Modell mit joblib:
import joblib joblib.dump(best_model, 'best_model.pkl')
Auf diese Weise können Sie Vorhersagen treffen, indem Sie Anfragen an die API senden.
In diesem Projekt haben wir den gesamten Prozess der Erstellung eines maschinellen Lernmodells mithilfe von Scikit-Learn zur Vorhersage von Immobilienpreisen untersucht. Von der Datenvorverarbeitung und Funktionsauswahl bis hin zum Modelltraining, der Evaluierung und der Bereitstellung wurde jeder Schritt mit praktischen Codebeispielen abgedeckt.
Ganz gleich, ob Sie neu im Bereich maschinelles Lernen sind oder scikit-learn in realen Projekten anwenden möchten, dieser Leitfaden bietet einen umfassenden Workflow, den Sie für verschiedene Regressionsaufgaben anpassen können.
Experimentieren Sie gerne mit verschiedenen Modellen, Datensätzen und Techniken, um die Leistung und Genauigkeit Ihres Modells zu verbessern.
Das obige ist der detaillierte Inhalt vonVorhersage von Immobilienpreisen mit Scikit-learn: Ein vollständiger Leitfaden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
