[PYTHON] Ich möchte nicht nach High Para suchen, da es sich um IQ1 handelt (wie man lightgbm_tuner verwendet).

Dieser Artikel wurde in IQ1s 2. Adventskalender 2019 veröffentlicht.

IQ1 maschinelles Lernen

Vorverarbeitung von Daten und High-Para-Suche des Modells sind für maschinelles Lernen unvermeidlich. Aber da IQ 1 ist, möchte ich es nicht tun, wenn ich die Daten vorverarbeiten und nach hohem Para suchen kann. Wenn Sie die Datenvorverarbeitung in diesen zeitlich abgestuften Algorithmus für das Gradienten-Boosting-Tree-System (LightGBM usw.) einfügen, können Sie die fehlenden Werte so behandeln, wie sie sind, und Sie müssen die kategorialen Variablen nicht vorverarbeiten, sodass es sich um eine relativ IQ1-freundliche Welt handelt. Ich tat. Andererseits ist eine hohe Para-Suche für IQ1 zu schwierig. Es ist sehr schwierig, weil Sie wissen müssen, was jeder hohe Para des Modells ist und wie viel Reichweite zu suchen ist.

lightgbm_tuner Vor kurzem hat optuna ein Modul namens "optuna.integration.lightgbm_tuner" veröffentlicht, um die High-Para-Suche von lightgbm zu automatisieren. Dieses Modul ist aus verschiedenen Gründen auch IQ1-freundlich.

1. Vollautomatische Suche nach High Para
2. Suchen Sie schrittweise (suchen Sie nach jedem Parameter), damit Sie mit hoher Geschwindigkeit suchen können
3. Sie können es sofort verwenden, indem Sie den vorhandenen lightgbm-Code an mehreren Stellen (später beschrieben) neu schreiben.

IQ1 automatische High-Para-Suche

Bitte installieren Sie die neueste Version von optuna. Ich denke es war 0.19.0. Geben Sie mit pip install optuna --upgrade ein.

Datensatz vorbereiten

Der diesmal verwendete Datensatz ist Kaggles Hauspreise. (https://www.kaggle.com/c/house-prices-advanced-regression-techniques/overview) Dieser Datensatz ist ein Datensatz, der den Preis des Hauses anhand von Grundstücks- oder Gebäudeinformationen vorhersagt.

Laden Sie zunächst die Daten mithilfe der API von kaggle herunter

$ kaggle competitions download -c house-prices-advanced-regression-techniques

Wenn Sie die Zip-Datei ordnungsgemäß entpacken, werden train.csv und test.csv angezeigt. Dieses Mal ist das Senden nervig, daher werde ich nur train.csv verwenden. Sie können jedes Jupyter-Notizbuch verwenden. Öffnen Sie also Python und lesen Sie es mit Pandas.

import pandas as pd

df=pd.read_csv("train.csv")
print(df.shape)

.out

(1460, 81)

Wir haben festgestellt, dass die 1460-Daten 81 Spalten enthalten. Da der SalePrice, der die ID vorhersagt, darin enthalten ist, kann eine Feature-Menge von 79 Dimensionen verwendet werden.

Lassen Sie uns die Spalten löschen, die vorerst nicht benötigt werden, und die Zielvariable separat festlegen

y=df.SalePrice
X=df.drop(["Id","SalePrice"],axis=1)

Überprüfen Sie als nächstes die fehlenden Werte. Es wird jedoch nicht verarbeitet, da es in lightgbm eintaucht. Nur Bestätigung.

X.loc[:,pd.isnull(X).any(axis=0)].columns

.out

Index(['LotFrontage', 'Alley', 'MasVnrType', 'MasVnrArea', 'BsmtQual',
       'BsmtCond', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinType2',
       'Electrical', 'FireplaceQu', 'GarageType', 'GarageYrBlt',
       'GarageFinish', 'GarageQual', 'GarageCond', 'PoolQC', 'Fence',
       'MiscFeature'],
      dtype='object')

Als nächstes codiert label die Spalte, deren Element "String" ist, als kategoriale Variable in lightgbm und setzt dtype auf "category". Kurz gesagt, die Beschriftungscodierung ersetzt die Zeichenfolge einfach durch einen ganzzahligen Wert, damit die Elemente nicht dupliziert werden.

from sklearn.preprocessing import LabelEncoder

for name in X.columns:
    if X[name].dtype=="object":
        #NaN kann nicht in LabelEncoder eingegeben werden"NAN"Zu
        X[name]=X[name].fillna("NAN")
        le = LabelEncoder()
        le.fit(X[name])
        encoded = le.transform(X[name])
        X[name] = pd.Series(encoded).astype('category')

Lerne mit gewöhnlichem Licht gbm

Lassen Sie lightgbm lernen, da die Vorverarbeitung abgeschlossen ist. Dieser Code ist, als ich in ein normales Licht GBM stürzte

import lightgbm as lgb
from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=1)

train_dataset=lgb.Dataset(X_train,y_train)
valid_dataset=lgb.Dataset(X_test,y_test,reference=train_dataset)

#Zur Zeitmessung
#%%time
params={"objective":"regression",
                    "learning_rate":0.05}
model=lgb.train(params,
                train_set=train_dataset,
                valid_sets=[valid_dataset],
                num_boost_round=300,
                early_stopping_rounds=50)

.out

...(Kürzung)...
Early stopping, best iteration is:
[113]	valid_0's l2: 6.65263e+08

CPU times: user 3.11 s, sys: 537 ms, total: 3.65 s
Wall time: 4.47 s

Ich konnte lernen. Die Lernzeit betrug 4,47 Sekunden. Übrigens, als ich das Vorhersageergebnis zeichnete, sah es so aus. Die horizontale Achse ist der vorhergesagte Wert und die vertikale Achse ist der wahre Wert.

Lerne mit lightgbm_tuner

Schreiben Sie den obigen Code neu, um nach IQ1 high para zu suchen

import lightgbm as lgb
import optuna.integration.lightgbm_tuner as lgb_tuner
from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=1)

train_dataset=lgb.Dataset(X_train,y_train)
valid_dataset=lgb.Dataset(X_test,y_test,reference=train_dataset)

params={"objective":"regression",
                    "learning_rate":0.05,
                    "metric":"l2"}
model=lgb_tuner.train(params,
                      train_set=train_dataset,
                      valid_sets=[valid_dataset],
                      num_boost_round=300,
                      early_stopping_rounds=50)

Wissen Sie, wo es umgeschrieben wurde? Auf der Suche nach Fehlern in IQ1.

Die umgeschriebenen Stellen sind die folgenden 3 Stellen

1. Importanweisung hinzufügen
2. Wechseln Sie von lgb.train zu lgb_tuner.train
3. Fügen Sie den Wert "metric" hinzu, um "params" zu optimieren

Die Lernzeit ist übrigens wie folgt. Es war langsamer als ich erwartet hatte ...

.out

CPU times: user 3min 24s, sys: 33.8 s, total: 3min 58s
Wall time: 3min 48s

Die Bewertung der Validierungsdaten ist wie folgt.

model.best_score

.out

defaultdict(dict, {'valid_0': {'l2': 521150494.1730755}})

Wenn man die Ergebnisse dieses Experiments vergleicht, sieht es so aus. Nach dem Einstellen hat sich die Leistung richtig verbessert.

Selbst wenn Sie sich die Handlung ansehen, können Sie sehen, dass die mit dem höheren Preis (die rechts) besser aussieht.

Ende

Wenn Sie dies verwenden, können Sie anscheinend sogar mit IQ1 maschinelles Lernen durchführen! !! Übrigens, als ich das damit hergestellte Modell einreichte, war es ungefähr 2000 .. (Da die Teilnehmerzahl sample_submission.csv oder mehr und 4900 Personen beträgt, gab es viele Personen mit IQ 1 oder weniger)

Nachtrag

Als ich in meiner Stimmung eine hohe Para-Suche mit optuna versuchte, stieg der Validierungswert, aber der Einreichungswert wurde etwas schlechter. (Wenn Sie einreichen, lernen Sie mit learning_rate = 0.05, num_boosting_round = 1000, Early_stopping_rounds = 50 neu.) Haben Sie die Validierungsdaten überpasst? Immerhin ist es schwierig, in IQ1 nach High Para zu suchen.

** Wenn Sie praktische High-Para-Explorationsratschläge haben, kommentieren Sie diese bitte! !! ** ** **

Die Abstimmungsstrategie ist diesmal wie folgt.

――Die Parameter, die eingestellt werden können, sind in einem weiten Bereich angeordnet.

• Setzen Sie learning_rate grob, um die Anzahl der Versuche zu erhöhen

(Je niedriger die Punktzahl, desto besser)

--Defoparas Lightgbm-Einreichungspunktzahl: 0,13852

• Eingereichtes Ergebnis mit lightgbm_tuner: 0.13174
• Eingereichtes Ergebnis in Optuna: 0,13401

import optuna

def objective(trial):
    '''
    trial:set of hyperparameter    
    '''
    # hypyer param
    bagging_fraction = trial.suggest_uniform("bagging_fraction",0,1)
    bagging_freq = trial.suggest_int("bagging_freq",0,10)
    feature_fraction = trial.suggest_uniform("feature_fraction",0,1)
    lambda_l1 = trial.suggest_uniform("lambda_l1",0,50)
    lambda_l2 = trial.suggest_uniform("lambda_l2",0,50)
    min_child_samples = trial.suggest_int("min_child_samples",1,50)
    num_leaves = trial.suggest_int("num_leaves",2,50)
    max_depth = trial.suggest_int("max_depth",0,8)
    params={"learning_rate":0.5,
                    "objective":"regression",
                    "bagging_fraction":bagging_fraction,
                    "bagging_freq":bagging_freq,
                    "feature_fraction":feature_fraction,
                    "lambda_l1":lambda_l1,
                    "lambda_l2":lambda_l2,
                    "min_child_samples":min_child_samples,
                    "num_leaves":num_leaves,
                    "max_depth":max_depth}

    model_opt = lgb.train(params,train_set=train_dataset,valid_sets=[valid_dataset],
                          num_boost_round=70,early_stopping_rounds=10)
 
    return model_opt.best_score["valid_0"]["l2"]

study = optuna.create_study()
study.optimize(objective, n_trials=500)

...(Kürzung)...
[I 2019-12-01 15:02:35,075] Finished trial#499 resulted in value: 537618254.528029. Current best value is 461466711.4731979 with parameters: {'bagging_fraction': 0.9973929186258068, 'bagging_freq': 2, 'feature_fraction': 0.9469601028256658, 'lambda_l1': 10.1589501379876, 'lambda_l2': 0.0306013767707684, 'min_child_samples': 2, 'num_leaves': 35, 'max_depth': 2}.

Der Validierungswert betrug 4,61467e + 08