1. Objet

Dans des compétitions comme Kaggle, le boosting de gradient comme xgboost et LGBM est souvent utilisé. Cependant, j'ai senti qu'il y avait peu d'articles et de sites qui pouvaient être utilisés comme référence pour ceux-ci, et j'ai eu beaucoup de mal à les mettre en œuvre moi-même, alors cette fois, j'aimerais décrire ce que j'ai essayé sur xgboost et la signification de chaque paramètre. Objectif.

Livre de référence Cette fois, il est essentiellement mis en œuvre selon ce livre. "Gagner avec la technologie d'analyse de données Kaggle" 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. Avantages de l'augmentation de gradient

・ Pas besoin de compléter les valeurs manquantes ・ Il n'y a pas de problème même s'il y a des fonctionnalités redondantes (même s'il y a des variables explicatives avec une forte corrélation, elles peuvent être utilisées telles quelles)

-La différence avec la forêt aléatoire est que les arbres sont fabriqués en série.

Avec les fonctionnalités ci-dessus, le renforcement du gradient semble être souvent utilisé.

3. Essayez d'utiliser xgboost

Cette fois, je vais l'implémenter en utilisant Houseprice de Kaggle.

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

(1) Prétraitement

(I) Importer

import numpy as np
import pandas as pd

#Pour la division des données
from sklearn.model_selection import train_test_split

#XGBoost
import xgboost as xgb

(Ii) Lecture / combinaison de données

#Lecture des données
df_train = pd.read_csv("train.csv")
df_test = pd.read_csv("test.csv")

#Jointure de données
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) Variable fictive

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

(Iv) Division des données

#df_Divisez tout en données d'entraînement et testez à nouveau les données
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)

#Répartition des données
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) Essayez d'utiliser xg boost

(I) Création de données xgboost

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

Pour utiliser xgboost, il est nécessaire de traiter ses propres données avec "xgb.DMatrix".

※point important※

La troisième ligne dit "df_test.values". Notez que cela est dû au fait que df_test est au format DataFrame, donc si vous ne le définissez pas comme valeur (tableau Numpy) dans .values, une erreur se produira lors de la formation ultérieure du modèle.

(Ii) Réglage des paramètres

params = {
        'objective': 'reg:squarederror','silent':1, 'random_state':1234, 
        #Indicateurs d'apprentissage(RMSE)
        'eval_metric': 'rmse',
    }
num_round = 500
watchlist = [(dtrain, 'train'), (dvalid, 'eval')]#Définir les données d'entraînement comme dtrain et les données de test pour évaluation comme dvalid

* Explication des paramètres *

-Objectif: Spécification de la fonction de perte à minimiser. La valeur par défaut est linéaire. -Silent: spécifiez comment enregistrer le journal d'exécution du modèle. La valeur par défaut est 0 (journal de sortie). -Eval_metric: Un index d'évaluation des données. Il y a rmse et logloss. -Num_round: Nombre maximum d'apprentissage.

(Iii) Formation sur modèle

model = xgb.train(params,
                    dtrain,#Données d'entraînement
                    num_round,#Définir le nombre d'apprentissage
                    early_stopping_rounds=20,
                    evals=watchlist,
                    )

-Early_stopping_rounds: signifie que l'apprentissage est arrêté si la précision ne s'améliore pas 20 fois de suite. Le nombre maximum d'apprentissage est défini dans num_round, mais si la précision n'est pas améliorée par le nombre de early_stopping_rounds défini ici avant cela, il sera arrêté.

(Iv) Prévision

#Prévoir
prediction_XG = model.predict(dtest, ntree_limit = model.best_ntree_limit)

#Arrondir les fractions
prediction_XG = np.round(prediction_XG)

・ À propos de ntree_limit Vous pouvez définir le nombre d'arbres avec la meilleure précision en définissant model.best_ntree_limit.

(V) Création d'un fichier à soumettre

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

C'est tout!

4. Conclusion

Qu'as-tu pensé. Vous pouvez l'implémenter en copiant le code, mais je pense qu'il est très important de savoir ce que signifie chaque code car c'est une idée approximative.

J'espère que cela vous aidera à approfondir votre compréhension.

[Kaggle] Essayez d'utiliser xg boost