[PYTHON] Kaggle House Preise ② ～ Modellierung ～

Erstellen Sie ein Modell mit den unten erstellten Funktionen. Kaggle House-Preise Feature ~ Feature Engineering ~

Bibliothek laden

import numpy as np
import pandas as pd
import lightgbm as lgb
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
from sklearn.externals import joblib

Daten lesen

def load_x_train() -> pd.DataFrame:
    """Lesen Sie die Funktionsmenge der zuvor erstellten Trainingsdaten

    :return:Merkmale von Trainingsdaten
    """
    return joblib.load('train_x.pkl')

def load_y_train() -> pd.Series:
    """Lesen Sie die Zielvariable der zuvor erstellten Trainingsdaten

    :return:Objektive Variable der Trainingsdaten
    """
    #Lesen Sie die Zielvariable
    train_y = joblib.load('train_y.pkl')
    #Logistische Umrechnung der Zielvariablen
    train_y = np.log1p(train_y)
    return train_y

Kreuzvalidierung

def load_index_fold(i_fold: int) -> np.array:
    """Gibt den Index des entsprechenden Datensatzes mit Falz in der Kreuzvalidierung zurück

    :param i_fold:Falznummer
    :return:Index der Datensätze entsprechend der Falte
    """
    #Gibt einen Index zurück, der Trainingsdaten und Validierungsdaten trennt
    #Hier wird die Zufallszahl jedes Mal festgelegt und erstellt, es gibt jedoch auch eine Methode, um sie in einer Datei zu speichern.
    train_y = load_y_train()
    kf = KFold(n_splits=4, random_state=6, shuffle=True)
    return list(kf.split(train_y))[i_fold]

def train_fold(i_fold):
    """Führen Sie das Lernen / die Bewertung durch, indem Sie die Falz-Kreuzvalidierung angeben

Neben dem Aufruf von anderen Methoden wird es auch zur Bestätigung und Parameteranpassung selbst verwendet

    :param i_fold:Falznummer
    :return:Tupple (Modellinstanz, Datensatzindex, vorhergesagter Wert, Bewertung nach Bewertung)
    """
    #Trainingsdaten lesen
    train_x = load_x_train()
    print(train_x.shape)
    train_y = load_y_train()

    #Legen Sie Trainingsdaten und Validierungsdaten fest
    tr_idx, va_idx = load_index_fold(i_fold)
    print(tr_idx.shape)
    print(va_idx.shape)
    tr_x, tr_y = train_x.iloc[tr_idx], train_y.iloc[tr_idx]
    va_x, va_y = train_x.iloc[va_idx], train_y.iloc[va_idx]

    #Lerne
    params_lgbm = {
        "boosting_type": "gbdt",
        "objective": "regression",
        "metric": "rmse",
        "learning_rate": 0.05,
        "max_depth": 4,
        "colsample_bytree": 0.9,
        "subsample": 0.9,
        "reg_alpha": 0.1,
        "reg_lambda": 0.0,
        "min_child_weight": 1,
        "num_leaves": 31
    }
    lgb_train = lgb.Dataset(tr_x, tr_y)
    lgb_eval = lgb.Dataset(va_x, va_y, reference=lgb_train)

    model = lgb.train(
        params_lgbm, lgb_train,
        #Übergeben Sie die Modellbewertungsdaten
        valid_sets=lgb_eval,
        #Lerne bis zu 1000 Runden
        num_boost_round=1000,
        #Hören Sie auf zu lernen, wenn sich die Leistung nach 10 Runden nicht verbessert
        early_stopping_rounds=10
    )

    #Validierungsdaten vorhersagen und auswerten
    va_pred = model.predict(va_x)
    score = np.sqrt(mean_squared_error(va_y, va_pred))

    #Gibt Modell, Index, vorhergesagten Wert, Bewertung zurück
    return model, va_idx, va_pred, score

Führen Sie Training und Modellierung durch

#Führen Sie ein Kreuzvalidierungslernen und eine Evaluierung durch
scores = []
va_idxes = []
preds = []
n_fold = 4

#Lerne in jeder Falte
for i_fold in range(n_fold):
    #Lerne
    print(f'fold {i_fold} - start training')
    model, va_idx, va_pred, score = train_fold(i_fold)
    print(f'fold {i_fold} - end training - score {score}')

    #Speichern Sie das Modell
    # model.save_model()
    joblib.dump(model, f'model-{i_fold}.pkl')

    #Halten Sie das Ergebnis
    va_idxes.append(va_idx)
    scores.append(score)
    preds.append(va_pred)

#Fassen Sie die Ergebnisse jeder Falte zusammen
va_idxes = np.concatenate(va_idxes)
order = np.argsort(va_idxes)
preds = np.concatenate(preds, axis=0)
preds = preds[order]

print(f'end training cv - score {np.mean(scores)}')

#Vorhersageergebnisse speichern
joblib.dump(preds, 'pred-train.pkl')

#Resultate der Auswertung
print('result_scores', scores)