1. Zweck

In Wettbewerben wie Kaggle wird häufig ein Gradienten-Boosting wie xgboost und LGBM verwendet. Ich hatte jedoch das Gefühl, dass es nur wenige Artikel und Websites gibt, die als Referenz für diese verwendet werden können, und ich hatte große Probleme, sie selbst zu implementieren. Daher möchte ich dieses Mal beschreiben, was ich über xgboost versucht habe und welche Bedeutung die einzelnen Parameter haben. Zweck.

Nachschlagewerk Dieses Mal wird es im Wesentlichen gemäß diesem Buch implementiert. "Mit der Kaggle-Datenanalysetechnologie gewinnen" https://www.amazon.co.jp/Kaggle%E3%81%A7%E5%8B%9D%E3%81%A4%E3%83%87%E3%83%BC%E3%82%BF%E5%88%86%E6%9E%90%E3%81%AE%E6%8A%80%E8%A1%93-%E9%96%80%E8%84%87-%E5%A4%A7%E8%BC%94/dp/4297108437

2. Vorteile der Gradientenverstärkung

・ Fehlende Werte müssen nicht vervollständigt werden ・ Es gibt kein Problem, selbst wenn redundante Funktionen vorhanden sind (selbst wenn es erklärende Variablen mit hoher Korrelation gibt, können sie so verwendet werden, wie sie sind).

-Der Unterschied zum zufälligen Wald besteht darin, dass die Bäume in Reihe geschaltet werden.

Mit den oben genannten Merkmalen scheint häufig eine Gradientenverstärkung verwendet zu werden.

3. Versuchen Sie es mit xgboost

Dieses Mal werde ich es mit Kaggles Hauspreis implementieren.

https://www.kaggle.com/c/house-prices-advanced-regression-techniques

(1) Vorbehandlung

(I) Importieren

import numpy as np
import pandas as pd

#Zur Datenaufteilung
from sklearn.model_selection import train_test_split

#XGBoost
import xgboost as xgb

(Ii) Lesen / Kombinieren von Daten

#Daten gelesen
df_train = pd.read_csv("train.csv")
df_test = pd.read_csv("test.csv")

#Datenverbindung
df_train["TrainFlag"] = True
df_test["TrainFlag"] = False

df_all = df_train.append(df_test)
df_all.index = df_all["Id"]
df_all.drop("Id", axis = 1, inplace = True)

(Iii) Dummy-Variable

df_all = pd.get_dummies(df_all, drop_first=True)

(Iv) Datenaufteilung

#df_Teilen Sie alles erneut in Trainingsdaten und Testdaten auf
df_train = df_all[df_all["TrainFlag"] == True]
df_train = df_train.drop(["TrainFlag"], axis = 1)

df_test = df_all[df_all["TrainFlag"] == False]
df_test = df_test.drop(["TrainFlag"], axis = 1)
df_test = df_test.drop(["SalePrice"], axis = 1)

#Datenaufteilung
y = df_train["SalePrice"].values
X = df_train.drop("SalePrice", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

(2) Versuchen Sie es mit xg boost

(I) Erstellung von xgboost-Daten

dtrain = xgb.DMatrix(X_train, label=y_train)
dvalid = xgb.DMatrix(X_test, label=y_test)
dtest = xgb.DMatrix(df_test.values)

Um xgboost verwenden zu können, müssen eigene Daten mit "xgb.DMatrix" verarbeitet werden.

※wichtiger Punkt※

In der dritten Zeile steht "df_test.values". Beachten Sie, dass dies daran liegt, dass df_test im DataFrame-Format vorliegt. Wenn Sie es also nicht als Wert (Numpy-Array) in .values festlegen, tritt beim späteren Modelltraining ein Fehler auf.

(Ii) Parametereinstellung

params = {
        'objective': 'reg:squarederror','silent':1, 'random_state':1234, 
        #Indikatoren für das Lernen(RMSE)
        'eval_metric': 'rmse',
    }
num_round = 500
watchlist = [(dtrain, 'train'), (dvalid, 'eval')]#Legen Sie die Trainingsdaten als dtrain und die Testdaten für die Auswertung als dvalid fest

* Erklärung der Parameter *

-Ziel: Angabe der zu minimierenden Verlustfunktion. Der Standardwert ist linear. -Silent: Geben Sie an, wie das Modellausführungsprotokoll aufgezeichnet werden soll. Der Standardwert ist 0 (Ausgabeprotokoll). -Eval_metric: Ein Auswertungsindex von Daten. Es gibt rmse und logloss. -Num_round: Maximale Anzahl von Lernvorgängen.

(Iii) Modelltraining

model = xgb.train(params,
                    dtrain,#Trainingsdaten
                    num_round,#Stellen Sie die Anzahl der Lernvorgänge ein
                    early_stopping_rounds=20,
                    evals=watchlist,
                    )

-Early_stopping_rounds: Bedeutet, dass das Lernen gestoppt wird, wenn sich die Genauigkeit nicht 20 Mal hintereinander verbessert. Die maximale Anzahl von Lernvorgängen wird in num_round festgelegt. Wenn die Genauigkeit jedoch nicht durch die zuvor hier festgelegte Anzahl von Early_stopping_rounds verbessert wird, wird sie gestoppt.

(Iv) Prognose

#Prognose
prediction_XG = model.predict(dtest, ntree_limit = model.best_ntree_limit)

#Rundungsfraktionen
prediction_XG = np.round(prediction_XG)

・ Über ntree_limit Sie können die Anzahl der Bäume mit der besten Genauigkeit festlegen, indem Sie model.best_ntree_limit festlegen.

(V) Erstellen einer Datei zur Einreichung

submission = pd.DataFrame({"id": df_test.index, "SalePrice": prediction_XG})

Das ist alles!

4. Fazit

Was haben Sie gedacht. Sie können es implementieren, indem Sie den Code kopieren, aber ich halte es für sehr wichtig zu wissen, was jeder Code bedeutet, da es sich um eine grobe Idee handelt.

Ich hoffe, es wird Ihnen helfen, Ihr Verständnis zu vertiefen.

[PYTHON] [Kaggle] Versuchen Sie es mit xg boost