# Import potrebných balíčkov
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OrdinalEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import make_column_transformer
from sklearn.pipeline import make_pipeline
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
from hyperopt import hp, tpe
from hyperopt.pyll.base import scope
from hyperopt.fmin import fmin
from hyperopt import space_eval
from sklearn.model_selection import cross_validate
# Uistíme sa, že máme všetky potrebné dáta
!mkdir -p data/titanic
!wget -nc -O data/titanic.zip https://www.dropbox.com/s/u8u7vcwy3sosbar/titanic.zip?dl=1
!unzip -oq -d data/titanic data/titanic.zip
Keď už vieme, ako sa dá pomocou balíčka scikit-learn a pipelines natrénovať jednoduchý model, môžeme sa venovať téme optimalizácie hyperparametrov. Ako vieme, v podstate každá metóda strojového učenia má určité nastaviteľné konštanty, ktoré čiastočne determinujú jej správanie a ktoré nazývame hyperparametre.
Nastavenie hyperparametrov môže mať kľúčový dopad na to, ako dobre bude metóda fungovať. Navyše – pre každú úlohu môžu byť potrebné trochu iné hyperparametre. Preto je dobré poznať účinné metódy, ako hyperparametre naladiť: buď ručne alebo ešte lepšie automaticky.
Jednej takej metóde — bayesovskej optimalizácii – sa venuje tento notebook.
Ako obvykle, začneme načítaním a predspracovaním dát. Budeme znovu pracovať s dátovou množinou Titanic, ktorú sme používali v predchádzajúcom príklade. Načítanie a predspracovanie dát na tejto dátovej množine sme si už precvičili, preto to nebudeme robiť znovu v tomto notebook-u a použijeme predpripravený kód:
df = pd.read_csv("data/titanic/train.csv")
df_train, df_test = train_test_split(df, test_size=0.25,
stratify=df["Survived"], random_state=4)
categorical_inputs = ["Pclass", "Sex", "Embarked"]
numeric_inputs = ["Age", "SibSp", 'Parch', 'Fare']
output = ["Survived"]
X_train = df_train[categorical_inputs + numeric_inputs]
Y_train = df_train[output]
X_test = df_test[categorical_inputs + numeric_inputs]
Y_test = df_test[output]
input_preproc = make_column_transformer(
(make_pipeline(SimpleImputer(strategy='constant', fill_value='MISSING'),
OrdinalEncoder()), categorical_inputs),
(make_pipeline(SimpleImputer(), StandardScaler()), numeric_inputs)
)
Vstupné tréningové dáta si tento raz hneď aj predspracujeme. Budeme na nich trénovať veľa rôznych modelov, preto je lepšie to spraviť len raz hneď na začiatku. (Zároveň to znamená, že na fitting predspracovania použijeme celú tréningovú množinu a nielen jej časť, ako by sa to stalo inak, keďže budeme používať krížovú validáciu.)
X_train_preproc = input_preproc.fit_transform(X_train)
Ďalej si už prejdime časti priamo súvisiace s bayesovskou optimalizáciou. Čo potrebujeme urobiť v prvom rade je zadefinovať účelovú funkciu, ktorú má optimalizátor minimalizovať.
Keďže naším cieľom bude nájsť hyperparametre, pri ktorých náš model dosiahne najlepšie výsledky, vstupným argumentom budú tieto hyperparametre. S ich pomocou skonštruujeme model (rozhodovací strom na báze triedy DecisionTreeClassifier).
Správnosť modelu vyhodnotíme pomocou $k$-násobnej krížovej validácie. (Cross-validation. Tréningové dáta rozdelíme na $k$ častí, pričom zakaždým jednu časť použijeme na testovanie a zvyšné na trénovanie. Keď takto otestujeme model na všetkých kombináciách tréningových a testovacích množín, výslednú správnosť určíme ako priemer správností z jednotlivých behov.)
def objective(params):
model = DecisionTreeClassifier(**params)
score = cross_validate(model, X_train_preproc, Y_train,
scoring='f1_macro',
cv=10, n_jobs=10)['test_score'].mean()
print("Score {:.3f} params {}".format(score, params))
# znamienko mínus, pretože chceme čo najvyššiu správnosť,
# ale hodnota účelovej funkcie sa bude minimalizovať
return -score
Ďalej potrebujeme nakonfigurovať prehľadávaný priestor: t.j. špecifikovať, akými hyperparametrami disponuje naša metóda a určiť, aké hodnoty môžu nadobúdať. Začnime teda tým, že si zobrazíme dokumentáciu ku triede DecisionTreeClassifier:
print(DecisionTreeClassifier.__doc__)
V nasledujúcej bunke definujte prehľadávaný priestor space pre hyperparametre rozhodovacieho stromu.
Priestor sa definuje slovníkom v nasledujúcom tvare:
space = {
# kategorická premenná:
'cat_var': hp.choice("cat_var", ["opt1", "opt2", "opt3"]),
# celočíselná premenná z rovnomerného rozdelenia:
'int_var': scope.int(hp.quniform("int_var", 1, 15, 1)),
# reálnočíselná premenná z rovnomerného rozdelenia:
'float_var': hp.uniform('float_var', 0.2, 1.0),
}
Ďalšie možnosti a podrobnejšia dokumentácia ku definovaniu parametrických priestorov sa dajú nájsť na wiki balíčka hyperopt.
Ďalej už môžeme spustiť samotnú optimalizáciu. Špecifikujeme pritom účelovú funkciu, prehľadávaný priestor, maximálny počet vyhodnotení účelovej funkcie a algoritmus. My používame algoritmus tpe, tzv. Tree-structured Parzen Estimator.
best = fmin(fn=objective,
space=space,
algo=tpe.suggest,
max_evals=100
)
Funkcia fmin navráti najlepšie nájdené riešenie. Následne ho dekódujeme pomocou funkcie space_eval, čím získame reprezentáciu, ktorú je už možné priamo použiť pri vytváraní nášho modelu.
best_params = space_eval(space, best)
Keď sme identifikovali najlepšie parametre, použijeme ich teraz, aby sme natrénovali nový model: tento raz už s použitím celej tréningovej množiny:
model = make_pipeline(
input_preproc,
DecisionTreeClassifier(**best_params)
)
model = model.fit(X_train, Y_train)
Na záver si model otestujeme na testovacích dátach. Zobrazíme si maticu zámen a klasické metriky. Úspešnosť predikcie by mala byť lepšia než pri predvolených hyperparametroch, ktoré sme používali v predchádzajúcom notebook-u.
y_test = model.predict(X_test)
cm = pd.crosstab(Y_test.values.reshape(-1), y_test,
rownames=['actual'],
colnames=['predicted'])
print(cm)
print("Accuracy = {}".format(accuracy_score(Y_test, y_test)))
print("Precision = {}".format(precision_score(Y_test, y_test)))
print("Recall = {}".format(recall_score(Y_test, y_test)))
Vyskúšajte teraz celý postup zopakovať s inou klasifikačnou metódou: s metódou XGBClassifier z balíčka xgboost. Predefinovať bude potrebné najmä metódu objective, aby používala nový model a prehľadávaný priestor space tak aby zodpovedal hyperparametrom novej metódy.
from xgboost import XGBClassifier