[PYTHON] Signate_ Rückblick auf den 1. Beginner Limited Competition

Einführung

Ich habe am 1. Beginner Limited-Wettbewerb (https://signate.jp/competitions/292) teilgenommen, der im August bei SIGNATE stattfand. Dies war das erste Mal, dass ich einen gut abgeschlossenen Wettbewerb absolvierte, aber das Endergebnis war AUC = 0,8588949, was den 13. Platz bedeutete (obwohl es ein sehr halbfertiges Ergebnis war ...). Wenn in diesem Wettbewerb die Punktzahl höher als ein bestimmter Wert war, konnte ich vom Anfänger zum Mittelstufe befördert werden, und ich wurde erfolgreich befördert.

Ich möchte zusammenfassen, was ich getan habe und worauf ich in Zukunft zurückblicken sollte.

Das Modell und die Analyseergebnisse dieses Wettbewerbs werden gemäß den Richtlinien zur Offenlegung von Informationen veröffentlicht.

Überblick über den Wettbewerb

Die Daten sind Kampagnendaten für Termineinlagen bei Finanzinstituten. Die Quelle der Daten ist hier, aber ich denke, sie wurden leicht verarbeitet. Der Bewertungsindex ist AUC. Siehe den Link oben für Details.

Umgebung

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

$python --version
Python 3.7.3

Was ich getan habe

0. Bestimmen Sie random_seed

Es ist wie Händewaschen vor dem Kochen, aber es ist wichtig, weil es später möglicherweise nicht reproduziert wird. Stellen Sie sicher, dass Sie eine Funktion zuweisen, die das Argument `random_seed``` oder random_state``` verwendet, damit das Ergebnis immer wiedergegeben wird.

1. Mal sehen, wie es aussieht (H2O)

Ich legte es in H2O und überprüfte die Informationen der Daten und welche Art von Algorithmus an die Spitze kommt, wenn es von AutoML gedreht wird. Informationen zu H2O finden Sie in Frühere Artikel. Als Ergebnis der Ausführung mit AutoML beim Betrachten der Daten zu diesem Zeitpunkt kam der Algorithmus des Entscheidungsbaumsystems an die Spitze, also in Zukunft LightGBM. Ich entschied mich mit zu gehen.

2. Erstellen Sie einen Fluss von der Datenerfassung über die Erstellung von Modellen für maschinelles Lernen bis zur Vorhersage (JupyterNotebook).

Notebook-Dateien werden separat für die Datenverarbeitung und Modellkonstruktion vorbereitet (da bei Verwendung einer Datei die Sichtbarkeit schlecht sein kann oder jedes Mal eine unnötige Verarbeitung durchgeführt werden kann).

2-1. Datenverarbeitungsteil

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')

Ich werde einen Code zum Überprüfen der Daten schreiben. Überprüfen Sie den Datentyp und das Vorhandensein oder Fehlen von Null ↓

df.info()
df.describe()

Visualisierung numerischer Daten ↓

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

Visualisierung von Zeichenkettendaten ↓

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)

In der obigen Visualisierung schien, ganz zu schweigen von "id", aber "balance" und "pdays", eine gleichmäßige Verteilung zu haben, so dass wir sie für späteres Lernen verwenden werden. Aus den Daten löschen. defaultDa die meisten Daten nein waren, löschen Sie sie. Darüber hinaus haben wir Lerndaten erstellt, indem wir die Verarbeitung zum Digitalisieren von Zeichenketten und Kategoriedaten hinzugefügt haben.

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. Modellbau- / Vorhersage-Teil

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'

Teilen Sie die Daten für Training und Validierung (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)

Die folgenden Methoden wurden zur Modellkonstruktion und zur Überprüfung der Genauigkeit verwendet.

• Kreuzvalidierung durch Aufteilung der Trainingsdaten in 5 durch geschichtete Extraktion
• Die Einstellung des Hyperparameters (im Folgenden: High Para) bleibt [optuna] überlassen (https://preferred.jp/ja/projects/optuna/).
• Der für die Optimierung verwendete Index ist logloss.
• Trainieren Sie das Modell mit den gesamten Trainingsdaten neu und berechnen Sie die AUC anhand der Verifizierungsdaten

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()

Trainieren Sie das Modell mit den gesamten Trainingsdaten neu und berechnen Sie die AUC anhand der Verifizierungsdaten ↓

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. Versuch und Irrtum beim Betrachten von Daten und Genauigkeit

Ich habe versucht, andere Details als die oben genannten zu ändern, aber die Genauigkeit hat sich nicht verbessert. Außerdem ist es ärgerlich, jedes Mal aufzunehmen ... Es scheint, als wäre die Wettbewerbsperiode vorbei.

Was ich hätte tun sollen

• Datenverarbeitungssystem ――Wenn Sie sich die Daten genau ansehen, einschließlich einer etwas größeren Kreuztabelle, haben Sie möglicherweise etwas entdeckt. --Versuchen Sie das Zusammenführen mit den Originaldaten (UCI) (wahrscheinlich teilweise verarbeitet, daher ist ein gewisser Einfallsreichtum erforderlich).
• Berücksichtigung des Interaktionsbegriffs
• Modellsystem
• Sie können das Ensemble mit LightGBM ausprobieren, das random_state geändert hat.
• Interpretationssystem ――Ich hätte den Ort untersuchen sollen, an dem die Genauigkeit schlecht war (Es gab einen Teil, in dem ich das Alter kategorisieren konnte, aber wenn ich es etwas mehr tun könnte)
• Werkzeuge und andere Systeme
• Git ist in Ordnung, aber ich hätte ein Code-Management-Tool verwenden sollen ――Ein ähnliches hätte ich ein Experimentmanagement-Tool einbinden sollen (das auch MLOps ist).

schließlich

Es gibt viele andere Dinge, die Sie tun sollten. Ich würde mich freuen, wenn Sie einen Kommentar abgeben könnten. Wenn ich zum nächsten Wettbewerb gehe, möchte ich die Technik einbeziehen, während ich mich auf diese Reflexion und den Kaggle-Kernel beziehe.