[PYTHON] Prix des maisons Kaggle ② ～ Modélisation ～

Créez un modèle à l'aide des fonctionnalités créées ci-dessous. Prix Kaggle House ① ~ Feature Engineering ~

Charger la bibliothèque

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

Lire les données

def load_x_train() -> pd.DataFrame:
    """Lire la quantité de fonctionnalités des données d'entraînement créées à l'avance

    :return:Caractéristiques des données d'entraînement
    """
    return joblib.load('train_x.pkl')

def load_y_train() -> pd.Series:
    """Lire la variable objectif des données d'entraînement créées au préalable

    :return:Variable objective des données d'entraînement
    """
    #Lire la variable objectif
    train_y = joblib.load('train_y.pkl')
    #Conversion logistique de la variable objective
    train_y = np.log1p(train_y)
    return train_y

Validation croisée

def load_index_fold(i_fold: int) -> np.array:
    """Renvoie l'index de l'enregistrement correspondant avec repli en validation croisée

    :param i_fold:numéro de pli
    :return:Index des enregistrements correspondant au pli
    """
    #Renvoie un index qui sépare les données d'entraînement et les données de validation
    #Ici, le nombre aléatoire est fixé et créé à chaque fois, mais il existe également une méthode pour l'enregistrer dans un fichier.
    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):
    """Effectuer l'apprentissage / l'évaluation en spécifiant un pli dans la validation croisée

En plus d'appeler à partir d'autres méthodes, il est également utilisé pour la confirmation et le réglage des paramètres par lui-même

    :param i_fold:numéro de pli
    :return:Tupple (instance de modèle, index d'enregistrement, valeur prédite, score par évaluation)
    """
    #Lecture des données d'entraînement
    train_x = load_x_train()
    print(train_x.shape)
    train_y = load_y_train()

    #Définir les données d'entraînement et les données de validation
    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]

    #Apprenez
    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,
        #Transmettre les données d'évaluation du modèle
        valid_sets=lgb_eval,
        #Apprenez jusqu'à 1000 tours
        num_boost_round=1000,
        #Arrêtez d'apprendre si les performances ne s'améliorent pas après 10 tours
        early_stopping_rounds=10
    )

    #Prédire et évaluer les données de validation
    va_pred = model.predict(va_x)
    score = np.sqrt(mean_squared_error(va_y, va_pred))

    #Renvoie le modèle, l'indice, la valeur prédite, la note
    return model, va_idx, va_pred, score

Effectuer la formation et la modélisation

#Effectuer un apprentissage et une évaluation de validation croisée
scores = []
va_idxes = []
preds = []
n_fold = 4

#Apprenez dans chaque pli
for i_fold in range(n_fold):
    #Apprenez
    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}')

    #Enregistrer le modèle
    # model.save_model()
    joblib.dump(model, f'model-{i_fold}.pkl')

    #Tenez le résultat
    va_idxes.append(va_idx)
    scores.append(score)
    preds.append(va_pred)

#Résumez les résultats de chaque pli
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)}')

#Sauvegarde des résultats de prédiction
joblib.dump(preds, 'pred-train.pkl')

#Résultats de l'évaluation
print('result_scores', scores)