0.Intro Es ist schwer, alles anzufangen, und dann denke ich, es ist ein Berg, um es an einen Ort zu bringen, an dem "es meine eigene Form ist" und "etwas ganz so". Es scheint, dass er die Titanic vor 7 Monaten eingereicht hat. Seitdem ist über ein halbes Jahr vergangen. Es ist nicht so, dass ich nichts getan hätte, aber ich konnte nicht genug Zeit bekommen. Glücklicherweise oder unglücklicherweise hatte ich ein wenig lange Ferien (ungefähr einen Monat), also wollte ich diese Gelegenheit nutzen, um so etwas wie Kaggles eigenen Weg zu gestalten, also nahm ich meine Bemühungen wieder auf. Infolgedessen konnte ich eine einzelne Form erstellen und beschloss, sie als Artikel zu schreiben.

1. Bevor Sie beginnen

Maschinelles Lernen muss Programmieren sein, aber es scheint ganz anders zu sein als das sogenannte gewöhnliche Programmieren. Schließlich ist die gewöhnliche Programmierung ein eklatanter Blick auf Daten, aber wie Sie wissen, hat die maschinelle Lernprogrammierung ein extrem großes Gewicht an Datenverarbeitung. Daher dauerte es einige Zeit, bis die Arbeit perfekt erledigt war.

1.1. Entwicklungsumgebung

Diesmal habe ich Ubuntu in WSL unter Windows 10 installiert und dort die Umgebung von Anaconda erstellt. Die Codierung und Codeausführung erfolgt mit VScode, und die Datenbestätigung usw. erfolgt mit Jupyter-Notebook. Es wäre eine Schande, wenn wir es in Zukunft fest entwickeln könnten, aber da es einen Server mit einem Grabber gibt, möchte ich die Entwicklungsumgebung darauf verschieben.

1.2. Codestruktur

Wenn Sie sich nicht den gesamten Code vorstellen können, bedeutet dies, dass Sie sich nicht vorstellen können, was Sie machen werden, und Sie können damit keine gute Arbeit leisten. Ergebnisse der Referenzierung verschiedener Kaggle-Kernel

def feature_create(train,test):
#Datenreinigung
#Erstellen Sie Daten wie die Dummyisierung von Variablen

def model_create(train):
#Teilen Sie die erstellten Daten in objektive Variablen und andere,
#Standardisieren und erstellen Sie ein Modell.


if __name__ == "__main__":
#Hauptlogik, Daten hier importieren und die obige Funktion
#feature_create(train,test)Und Modell_create(train)Anruf
#Wenden Sie das Modell schließlich auf die Testdaten an und erhalten Sie das Vorhersageergebnis
#Erstellen Sie CSV-Daten zum Senden.

In Form von besteht der Umriss aus drei Stufen. Ich habe diesmal nur ein paar Unterprogramme hinzugefügt, aber es scheint, dass die Haupt- und zwei Funktionen verwendet werden können.

1.3 Entwicklungsstil

Die Entwicklung des maschinellen Lernens ist stark auf die Verarbeitung von Daten ausgerichtet, sodass es nicht möglich ist, nur den Editor zu betrachten. Aufgrund verschiedener Versuche und Fehler besteht das Formular darin, die Daten mit dem Jupyter-Notizbuch zu überprüfen, den Code zu überprüfen, um die Daten darauf zu bearbeiten, und den erfolgreichen Code der Funktion feature_create in der obigen Konfiguration hinzuzufügen. Es sah gut aus.

2. Ganzes Programm

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import  cross_val_score

def feature_create(train,test):
    df_train = train.copy()
    df_test = test.copy()
    df_train["evel_set"] = 0
    df_test["evel_set"] = 1
    df_temp = pd.concat([df_train,df_test])
    del df_train,df_test
    df_temp.drop(["MiscFeature","MiscVal","PoolQC","PoolArea","Fireplaces","FireplaceQu","Alley","Fence"],axis=1,inplace=True)
    df_temp["MasVnrType"][df_temp["MasVnrType"].isnull()==True]="None"
    df_temp["MasVnrArea"][df_temp["MasVnrArea"].isnull()==True] = df_temp["MasVnrArea"].mean()
    df_temp["BsmtQual"][df_temp["BsmtQual"].isnull()==True] = "TA"
    df_temp["BsmtCond"][df_temp["BsmtCond"].isnull()==True] = "TA"
    df_temp["BsmtExposure"][df_temp["BsmtExposure"].isnull()==True] = "No"
    df_temp["BsmtFinType1"][df_temp["BsmtFinType1"].isnull()==True] = "Unf"
    df_temp["BsmtFinType2"][df_temp["BsmtFinType2"].isnull()==True] = "Unf"
    df_temp["Electrical"][df_temp["Electrical"].isnull()==True] = "SBrkr"
    df_temp["GarageType"][df_temp["GarageType"].isnull()==True] = "Attchd"
    df_temp["GarageYrBlt"][df_temp["GarageYrBlt"].isnull()==True] = df_temp["GarageYrBlt"][df_temp["GarageYrBlt"] > 2000].mean()
    df_temp["GarageFinish"][df_temp["GarageFinish"].isnull()==True] = "Unf"
    df_temp["GarageQual"][df_temp["GarageQual"].isnull()==True] = "TA"
    df_temp["GarageCond"][df_temp["GarageCond"].isnull()==True] = "TA"
    df_temp["BsmtFinSF1"][df_temp["BsmtFinSF1"].isnull()==True] = 0
    df_temp["BsmtFinSF2"][df_temp["BsmtFinSF2"].isnull()==True] = 0
    df_temp["BsmtFullBath"][df_temp["BsmtFullBath"].isnull()==True] = 0
    df_temp["BsmtHalfBath"][df_temp["BsmtHalfBath"].isnull()==True] = 0
    df_temp["BsmtUnfSF"][df_temp["BsmtUnfSF"].isnull()==True] = 0
    df_temp["Exterior1st"][df_temp["Exterior1st"].isnull()==True] = "VinylSd"
    df_temp["Exterior2nd"][df_temp["Exterior2nd"].isnull()==True] = "VinylSd"
    df_temp["Functional"][df_temp["Functional"].isnull()==True] = "Typ"
    df_temp["GarageArea"][df_temp["GarageArea"].isnull()==True] = 576
    df_temp["GarageCars"][df_temp["GarageCars"].isnull()==True] = 2
    df_temp["KitchenQual"][df_temp["KitchenQual"].isnull()==True] = "TA"
    df_temp["LotFrontage"][df_temp["LotFrontage"].isnull()==True] = 60
    df_temp["MSZoning"][df_temp["MSZoning"].isnull()==True] = "RL"
    df_temp["SaleType"][df_temp["SaleType"].isnull()==True] = "WD"
    df_temp["TotalBsmtSF"][df_temp["TotalBsmtSF"].isnull()==True] = 0
    df_temp["Utilities"][df_temp["Utilities"].isnull()==True] = "AllPub"

    #df_temp.drop(["MSSubClass","MSZoning","Street","LotShape","LandContour","Utilities","LotConfig","LandSlope","Neighborhood","Condition1","Condition2","BldgType","HouseStyle","OverallCond","RoofStyle","RoofMatl","Exterior1st","Exterior2nd","MasVnrType","ExterQual","ExterCond","Foundation","BsmtQual","BsmtCond","BsmtExposure","BsmtFinType1","BsmtFinType2","BsmtFinSF2","BsmtUnfSF","Heating","HeatingQC","CentralAir","Electrical","LowQualFinSF","BsmtFullBath","BsmtHalfBath","HalfBath","BedroomAbvGr","KitchenAbvGr","KitchenQual","Functional","GarageType","GarageYrBlt","GarageFinish","GarageQual","GarageCond","PavedDrive","EnclosedPorch","3SsnPorch","ScreenPorch","MoSold","YrSold","SaleType","SaleCondition"],axis=1,inplace=True)

    df_temp = pd.get_dummies(df_temp)
    
    df_train = df_temp[df_temp["evel_set"]==0]
    df_test = df_temp[df_temp["evel_set"]==1]
    df_train.drop("evel_set",axis=1,inplace=True)
    df_test.drop("evel_set",axis=1,inplace=True)
    del df_temp
    return df_train,df_test

def model_create(train):
    sc_x = StandardScaler()
    sc_y = StandardScaler()
    x_train = train
    y_train = train["SalePrice"]
    x_train.drop("SalePrice",axis=1,inplace=True)
    x_train.drop("Id",axis=1,inplace=True)

    x_train_std = sc_x.fit_transform(x_train)
    y_train_std = sc_y.fit_transform(y_train[:,np.newaxis]).flatten()

    gbrt = GradientBoostingRegressor(n_estimators=1000, learning_rate=.03, max_depth=3, max_features=.04, min_samples_split=4,
                                    min_samples_leaf=3, loss='huber', subsample=1.0, random_state=0)
    cv_gbrt = rmse_cv(gbrt,x_train_std, y_train_std)
    gbrt.fit(x_train_std, y_train_std)
    print('GradientBoosting CV score min: ' + str(cv_gbrt.min()) + ' mean: ' + str(cv_gbrt.mean()) 
        + ' max: ' + str(cv_gbrt.max()) )

    return gbrt,sc_y


def rmse_cv(model,X,y):
    rmse = np.sqrt(-cross_val_score(model, X, y, scoring = "neg_mean_squared_error", cv = 5))
    return(rmse)


if __name__ == "__main__":
    df_train_org = pd.read_csv("~/kaggle_train/House_Prices_Advanced/train.csv")
    df_test_org = pd.read_csv("~/kaggle_train/House_Prices_Advanced/test.csv")

    df_train,df_test = feature_create(df_train_org,df_test_org)
    del df_train_org,df_test_org
    
    model,scaler = model_create(df_train)
    sc_x = StandardScaler()
    df_test_Id = df_test["Id"]
    df_test = df_test.drop("Id",axis=1)
    df_test.drop("SalePrice",axis=1,inplace=True)

    df_test_std = sc_x.fit_transform(df_test)
    pred = model.predict(df_test_std)
    pred = scaler.inverse_transform(pred)
    df_sub_pred = pd.DataFrame(pred).rename(columns={0:"SalePrice"})
    df_submit = pd.DataFrame({
        "Id": df_test_Id,
        "SalePrice": df_sub_pred["SalePrice"]
    })
    df_submit.to_csv('submission.csv', index=False)

2.1.feature_create Wie oben erwähnt, habe ich die Methode verwendet, um den Code mit dem Jyupter-Notizbuch zu überprüfen und den erfolgreichen Code in diese Funktion einzufügen. Das Jyupter-Notizbuch, das ich während der Arbeit vor Ort hergestellt habe, war so. House_Prices_Advanced_Regression_Techniques

Erstens ist es die Kombination von Trainingsdaten und Testdaten, aber viele Menschen kombinieren sie so wie sie sind, und da die Anordnung von Trainingsdaten und Testdaten garantiert ist, wird sie durch die Anzahl der Fälle geteilt. Persönlich fühlt es sich jedoch etwas unangenehm an, deshalb habe ich eine Spalte mit dem Namen "evel_set" erstellt und die Trainingsdaten als 0 und die Testdaten als 1 gespeichert. Später übernahm ich die Methode, die Spalte zu teilen, indem ich mich darauf stützte und sie dann fallen ließ.

Die Datenbereinigung dieses Mal ist nur die Vervollständigung fehlender Daten. Für Kategoriewerte

Überprüfen Sie die Art der vorhandenen Daten und die Häufigkeit, mit der sie angezeigt werden.
Geben Sie den häufigsten Wert ein Wird wiederholt. Bei numerischen Werten gebe ich manchmal den Durchschnittswert ein.

Ich weiß, dass ich mehr tun muss, aber ich würde es gerne zu meiner nächsten Aufgabe machen.

Was die letzte Heatmap betrifft, habe ich die zu Beginn vorbereiteten Daten so wie sie sind in die Heatmap-Funktion eingefügt. Die richtige Antwort war jedoch, df_temp.corr () und einen DataFrame mit nur dem Korrelationskoeffizienten an die Heatmap-Funktion zu übergeben. Dies wurde auch alleine montiert.

Außerdem können Sie in DataFrame alle Spaltennamen, die Anzahl der Nicht-NAN-Werte (dh die Anzahl der NANs) und den Typ mit info () anzeigen. Diesmal wusste ich es zum ersten Mal.

2.2.model_create

Erhalten Sie die vorbereiteten Trainingsdaten, geben Sie alle Trainingsdaten einmal in die Zielvariable "SalePrice" y_train ein und löschen Sie die unnötige "Id" und die Zielvariable "SalePrice" als abhängige Variablen. Als nächstes kommt die Standardisierung. Diesmal habe ich Standard Scaler verwendet. Zu diesem Zeitpunkt war zunächst nur x_train standardisiert und y_train wurde unverändert gelassen. Infolgedessen wurde es kein anständiger Bewertungswert ... Als sowohl x_train als auch y_train standardisiert wurden, wurde es ein anständiger Wert. Dies war eine Falle.

Dieses Mal verwende ich den Code, den ich für die Modellierung aufgenommen habe. Eigentlich müsste ich die Parameter selbst durch Rastersuche usw. finden, aber diesmal habe ich sie gefaltet.

2.3.if name == "main": Die Daten selbst werden gelesen und an die Funktion feature_create übergeben. Übergeben Sie die zurückgegebenen bearbeiteten Daten an das nächste model_create, um einen StandardScaler-Instant zu erhalten, der das trainierte Modell und die standardisierten Ziele zurückgibt. Bearbeiten Sie dann die Prognosedaten. Da die ID der Testdaten zum Senden erforderlich ist, ist sie zum Speichern und Vorhersagen nicht erforderlich. Löschen Sie sie daher. Außerdem wird "Verkaufspreis", der beim ersten Beitritt nicht zutreffen sollte, ebenfalls als Spalte erstellt. Lassen Sie ihn also ebenfalls fallen. Ist StandardScaler nicht eine Spezifikation, die inverse_transform nur für Daten im gleichen Datenformat nach einmaliger Anpassung zulässt? Dieses Mal habe ich es etwas umständlich realisiert, indem ich eine Instanz von fit_transformed y_train erhalten habe. Kann eine andere Instanz nach dem Anpassen eines geeigneten eindimensionalen Arrays invertiert werden, da model.predict ein eindimensionales Array zurückgibt? Ich würde es gerne noch einmal versuchen (ich sollte lieber überprüfen, wie Standard Scaler richtig verwendet wird). Konvertieren Sie den vorhergesagten Wert in einen DataFrame mit einem Spaltennamen. Erstellen Sie einen DataFrame zum Senden. Erstellen Sie mit DataFrame wie mit dem "Verkaufspreis" von DataFrame, der die ID und den vorhergesagten Wert der zuvor gespeicherten Testdaten enthält. Die Aufstellung ist garantiert, also ist es ein Weg, es zu machen. Der Rest wird mit to_csv und dem Ende ausgegeben.

3. Ergebnis

Das Ergebnis war das. Da es 1638. von 5222 ist, habe ich das Gefühl, dass ich richtig teilnehme, also denke ich, dass ich einen Teilnahmepreis w bekommen kann Das Ergebnis des vor 8 Monaten eingereichten [Immobilienpreiswettbewerbs für Kaggle Learn-Benutzer] lag bei 43000 von 43230. Es scheint also besser, nichts zu tun, und ich denke, dass es von diesem Punkt an große Fortschritte gemacht hat.

3.1. Zukünftige Probleme

Da die Klassifizierung von der Titanic berührt wird, möchte ich an Zeitreihendaten arbeiten. Danach möchte ich EDA ernsthaft durchführen und in der Lage sein, Daten anzupassen und neue Funktionen hinzuzufügen. Dann möchte ich zu Deep Learning übergehen. Aber es mag besser sein, in Bezug auf die Arbeit zur Datenanalyse zu gehen, aber w

[PYTHON] Immobilienpreise: Fortgeschrittene Regressionstechniken