[PYTHON] Signate_ Revue du 1er Concours Limité Débutant

introduction

J'ai participé au 1er Concours Limité Débutant (https://signate.jp/competitions/292) qui s'est tenu à SIGNATE en août. C'était la première fois que j'avais une compétition solide, mais le score final était AUC = 0,8588949, qui était la 13e place (même si c'était un résultat très semi-fini ...). Dans cette compétition, si le score était supérieur à une certaine valeur, j'ai pu être promu de débutant à intermédiaire et j'ai été promu avec succès.

Je voudrais résumer ce que j'ai fait et ce que j'aurais dû me rappeler à l'avenir.

Le modèle et les résultats de l'analyse de ce concours sont publiés conformément à la politique de divulgation d'informations.

Aperçu de la compétition

Les données sont des données de campagne pour les dépôts à terme auprès des institutions financières. La source des données est ici, mais je pense qu'elle a été légèrement traitée. L'indice d'évaluation est AUC. Voir le lien ci-dessus pour plus de détails.

environnement

$sw_vers 
ProductName:	Mac OS X
ProductVersion:	10.13.6
BuildVersion:	17G14019

$python --version
Python 3.7.3

Ce que j'ai fait

0. Déterminez random_seed

C'est comme se laver les mains avant de cuisiner, mais c'est important car cela peut ne pas être reproduit plus tard. Assignez toujours lorsque vous utilisez une fonction qui a un argument de random_seed ou `` random_state pour vous assurer que le résultat est reproduit.

1. Voyons à quoi il ressemble (H2O)

Je l'ai mis dans H2O et vérifié les informations des données et le type d'algorithme qui arrive en haut lorsqu'il est activé par AutoML. Pour H2O, voir Articles précédents. À la suite de l'exécution avec AutoML tout en regardant les données à ce stade, l'algorithme du système d'arbre de décision est arrivé au sommet, donc à l'avenir LightGBM J'ai décidé de partir avec.

2. Créer un flux de l'acquisition de données à la construction de modèles d'apprentissage automatique en passant par la prédiction (JupyterNotebook)

Les fichiers Notebook sont préparés séparément pour le traitement des données et la construction du modèle (car si un fichier est utilisé, la visibilité peut être mauvaise ou un traitement inutile peut être effectué à chaque fois).

2-1. Partie informatique

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import category_encoders as ce


%matplotlib inline
pd.set_option('display.max_columns', None)
random_state = 1234

df = pd.read_csv('./0_rawdata/train.csv')

J'écrirai du code pour vérifier les données. Vérifiez le type de données et la présence ou l'absence de null ↓

df.info()
df.describe()

Visualisation des données numériques ↓

df.hist( figsize=(14, 10), bins=20)

Visualisation des données de chaînes de caractères ↓

plt.figure( figsize = (20, 15))

cols = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'poutcome']
for i, col in enumerate(cols):
    plt.subplot(3,3,i+1)
    df[col].value_counts().plot.bar()
    plt.title(col)

Dans la visualisation ci-dessus, bien sûr, id, mais `balance``` et` pdayssemblaient avoir une distribution uniforme, nous l'utiliserons donc pour un apprentissage ultérieur. Supprimer des données.default```Puisque la plupart des données étaient non, supprimez-les. De plus, nous avons créé des données d'apprentissage en ajoutant des traitements pour numériser des chaînes de caractères et des données de catégorie.

df2 = df.copy()
df2 = df2.drop( columns=['id', 'balance', 'pdays', 'default'])

# month
month_map={
    'jan':1,
    'feb':2,
    'mar':3,
    'apr':4,
    'may':5,
    'jun':6,
    'jul':7,
    'aug':8,
    'sep':9,
    'oct':10,
    'nov':11}
df2['month'] = df2['month'].fillna(0)
df2['month'] = df2['month'].map(month_map)

# job, marital, education, housing, loan, contact, poutcome
cols = ['job', 'marital', 'education', 'housing', 'loan', 'contact', 'poutcome']
ce_onehot = ce.OneHotEncoder(cols=cols,handle_unknown='impute')
ce_onehot.fit( df2 )
df2 = ce_onehot.transform( df2 )

df2['duration'] = df2['duration'] / 3600

df2.to_csv('mytrain.csv', index=False)

2-2. Partie construction / prédiction du modèle

import pandas as pd
import numpy as np
import category_encoders as ce
import lightgbm as lgb
#import optuna
from optuna.integration import lightgbm as lgb_optuna
from sklearn import preprocessing
from sklearn.model_selection import train_test_split,StratifiedKFold,cross_validate
from sklearn.metrics import roc_auc_score

pd.set_option('display.max_columns', None)

random_state = 1234
version = 'v1'

Divisez les données pour la formation et la validation (8: 2).

df_train = pd.read_csv('mytrain.csv')

X = df_train.drop( columns=['y'] )
y = df_train['y']
X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.2, random_state=random_state)

Les méthodes suivantes ont été utilisées pour la construction du modèle et la vérification de l'exactitude.

• Validation croisée en divisant les données d'entraînement en 5 par extraction stratifiée
• Le réglage des hyperparamètres (ci-après, para haut) est laissé à optuna
• L'index utilisé pour l'optimisation est la perte de log.
• Retrainer le modèle avec toutes les données d'entraînement et calculer l'AUC à l'aide des données de vérification

def build():
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
    
    lgb_train = lgb_optuna.Dataset(X_train, y_train)
    
    lgbm_params = {
        'objective': 'binary',
        'metric': 'binary_logloss',
        'random_state':random_state,
        'verbosity': 0
    }
    
    tunecv = lgb_optuna.LightGBMTunerCV(
        lgbm_params,
        lgb_train,
        num_boost_round=100,
        early_stopping_rounds=20,
        seed = random_state,
        verbose_eval=20,
        folds=kf
    )
    
    tunecv.run()
    
    print( 'Best score = ',tunecv.best_score)
    print( 'Best params= ',tunecv.best_params)
    
    return tunecv

tunecv = build()

Reconditionnez le modèle avec toutes les données d'entraînement et calculez l'AUC à l'aide des données de vérification ↓

train_data = lgb.Dataset( X_train, y_train )
eval_data = lgb.Dataset(X_holdout, label=y_holdout, reference= train_data)
clf = lgb.train( tunecv.best_params, 
                train_data,
                valid_sets=eval_data,
                num_boost_round=50,
                verbose_eval=0
               )
y_pred = clf.predict( X_holdout )
print('AUC: ', roc_auc_score(y_holdout, y_pred))
# AUC:  0.8486429810797091

3. Essai et erreur lors de l'examen des données et de l'exactitude

J'ai essayé de modifier d'autres détails en plus de ce qui précède, mais la précision ne s'est pas améliorée. De plus, c'est ennuyeux d'enregistrer à chaque fois ... On a l'impression que la période de compétition est terminée.

Ce que j'aurais dû faire

• Système de traitement des données ――Si vous examinez attentivement les données, y compris un peu plus de tabulation croisée, vous avez peut-être découvert quelque chose.
• Essayez de fusionner avec les données d'origine (UCI) (probablement partiellement traitées, donc une certaine ingéniosité est requise) --Considération du terme d'interaction
• Système de modèle
• Vous pouvez essayer l'ensemble avec LightGBM qui a changé random_state. --Système d'interprétation ――J'aurais dû enquêter sur l'endroit où la précision était mauvaise (il y avait une partie où je pouvais catégoriser `` âge```, mais si je pouvais le faire un peu plus) --Outils et autres systèmes --Git va bien, mais j'aurais dû utiliser un outil de gestion de code ―― De même, j'aurais dû inclure un outil de gestion d'expériences (comme MLOps)

à la fin

Il y a beaucoup d'autres choses à faire. Je vous serais reconnaissant si vous pouviez commenter. Quand je vais au prochain concours, j'aimerais incorporer la technique en faisant référence à cette réflexion et au noyau kaggle.