- ํ์ดํผ ํ๋ผ๋ฏธํฐ ์กฐ์ ์ ๋ชจ๋ ๊ธฐ๊ณ ํ์ต ํ๋ก์ ํธ์ ํ์ ๋ถ๋ถ์ด๋ฉฐ ๊ฐ์ฅ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ฆฌ๋ ์์ ์ค ํ๋์ ๋๋ค.
- ๊ฐ์ฅ ๋จ์ํ ๋ชจ๋ธ์ ๊ฒฝ์ฐ์๋ ํ๋ฃจ, ๋ช ์ฃผ ๋๋ ๊ทธ ์ด์ ์ต์ ํ ํ ์์๋ ์ ๊ฒฝ๋ง์ ์ธ๊ธํ์ง ์๊ณ ์ต์ ์ ๋งค๊ฐ ๋ณ์๋ฅผ ์ฐพ๋ ๋ฐ ๋ช ์๊ฐ์ด ๊ฑธ๋ฆด ์ ์์ต๋๋ค.
- ์ด ํํ ๋ฆฌ์ผ์์๋ Grid Search , Random Search, HyperBand, Bayesian optimization, Tree-structured Parzen Estimator(TPE)์ ๋ํด ์๊ฐํฉ๋๋ค.
- ํ์ดํผ ํ๋ผ๋ฏธํฐ ์กฐ์ ์ ํจ์ ์ต์ ํ ์์ ์ ์ง๋์ง ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ถ๋ช ํ Grid ๋๋ Random Search๊ฐ ์ ์ผํ๊ณ ์ต์์ ์๊ณ ๋ฆฌ์ฆ์ ์๋์ง๋ง ํจ์จ์ ์ธ ์๋์ ๊ฒฐ๊ณผ ์ธก๋ฉด์์ ๊พธ์คํ ์ฌ์ฉ๋ฉ๋๋ค.
- ์ด๋ก ์ ๊ด์ ์์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์ค๋ช ํ๊ณ Hyperopt ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ค์ ๋ก ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค ๊ฒ์ ๋๋ค.
- ์ด ํํ ๋ฆฌ์ผ์ ๋ง์น๋ฉด ๋ชจ๋ธ๋ง ํ๋ก์ธ์ค์ ์๋๋ฅผ ์ฝ๊ฒ ๋์ด๋ ๋ฐฉ๋ฒ์ ์๊ฒ๋ฉ๋๋ค.
- ํํ ๋ฆฌ์ผ์ ์ ์ผํ ๋ชฉํ๋ ๋งค์ฐ ๋จ์ํ ๋ ์์ ์์ Hyperparameter optimization์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์์ฐํ๊ณ ์ค๋ช ํ๋ ๊ฒ์ ๋๋ค.
- http://www.itdaily.kr/news/articleView.html?idxno=210339
- https://www.comworld.co.kr/news/articleView.html?idxno=50677
#!pip install pip install git+https://github.com/darenr/scikit-optimize
- ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ ธ ์ต๋๋ค
#!pip install lightgbm
import numpy as np
import pandas as pd
from lightgbm.sklearn import LGBMRegressor
from sklearn.metrics import mean_squared_error
%matplotlib inline
import warnings # `do not disturbe` mode
warnings.filterwarnings('ignore')
sklearn.datasets์ ๋น๋จ๋ณ ๋ฐ์ดํฐ ์ธํธ์ ๋ํ ๋ค์ํ ์๊ณ ๋ฆฌ์ฆ์ ์์ฐํ๊ณ ๋น๊ตํฉ๋๋ค. ๋ก๋ํฉ์๋ค.
์ฌ๊ธฐ์์ ๋ฐ์ดํฐ ์ธํธ์ ๋ํ ์ค๋ช ์ ์ฐพ์ ์ ์์ต๋๋ค. [https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html] add: ์ผ๋ถ ํ์ ๋ฐ ๋์ ์ธก์ ํญ๋ชฉ์ ๋ํ ์ ๋ณด๊ฐ ํฌํจ ๋ ๋ฐ์ดํฐ ์ธํธ์ ๋๋ค. "๊ธฐ์ค์ 1 ๋ ํ ์ง๋ณ ์งํ์ ์ ๋์ ์ธก์ ". ์ด ์์ ์ ๋ชฉ์ ์ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ดํดํ ํ์๋ ์์ต๋๋ค. ํ๊ท ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ์์ผ๋ฉฐ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์กฐ์ ํ๋ ค๊ณ ํ๋ค๋ ์ ์ ๋ช ์ฌํ์ญ์์ค.
from sklearn.datasets import load_diabetes
diabetes = load_diabetes()
n = diabetes.data.shape[0]
data = diabetes.data
targets = diabetes.target
- ๋ฐ์ดํฐ ์ธํธ๋ ๋งค์ฐ ์์ต๋๋ค.
- ์ด๋ฅผ ์ฌ์ฉํ์ฌ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์ฝ๊ฒ ๋ณด์ฌ์ค ์ ์๊ธฐ ๋๋ฌธ์ ์ ํํ์ต๋๋ค.( ๋ชจ๋ ๊ฒ์ด ๊ณ์ฐ ๋ ๋ ๋ช ์๊ฐ์ ๊ธฐ๋ค๋ฆด ํ์๊ฐ ์์ต๋๋ค.)
- ๋ฐ์ดํฐ ์ธํธ๋ฅผ ํ์ต ๋ฐ ํ ์คํธ ๋ถ๋ถ์ผ๋ก ๋๋ ๊ฒ์ ๋๋ค. train ๋ถ๋ถ์ 2 ๊ฐ๋ก ๋ถํ ๋๋ฉฐ, ๋งค๊ฐ ๋ณ์๋ฅผ ์ต์ ํํ๋ ๋ฐ ๋ฐ๋ผ ๊ต์ฐจ ๊ฒ์ฆ MSE๋ฅผ ์ต์ข ์ธก์ ํญ๋ชฉ์ผ๋ก ์ฌ์ฉํ ๊ฒ์ ๋๋ค.
add :์ด ๊ฐ๋จํ ์์ ๋ ์ค์ ๋ชจ๋ธ๋ง์ ์ํ ๋ฐฉ๋ฒ์ด ์๋๋๋ค. ๋น ๋ฅธ ๋ฐ๋ชจ ์๊ฐ์๋ง ์ฌ์ฉํ๋ ์์ ๋ฐ์ดํฐ ์ธํธ์ 2 ๊ฐ์ fold๋ก ์ธํด ๋ถ์์ ํ ์ ์์ต๋๋ค. ๊ฒฐ๊ณผ๋ random_state์ ๋ฐ๋ผ ํฌ๊ฒ ๋ณ๊ฒฝ๋ฉ๋๋ค.
iteration์ 50์ผ๋ก ๊ณ ์ ํฉ๋๋ค.
from sklearn.model_selection import KFold, cross_val_score
from sklearn.model_selection import train_test_split
random_state=42
n_iter=50
train_data, test_data, train_targets, test_targets = train_test_split(data, targets,
test_size=0.20, shuffle=True,
random_state=random_state)
num_folds=2
kf = KFold(n_splits=num_folds, random_state=random_state)
print('train_data : ',train_data.shape)
print('test_data : ',test_data.shape)
print('train_targets : ',train_targets.shape)
print('test_targets : ',test_targets.shape)
train_data : (353, 10)
test_data : (89, 10)
train_targets : (353,)
test_targets : (89,)
LGBMRegressor๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ด ๋๋ค. Gradient Boosting์๋ ์ต์ ํ ํ ์์๋ ๋ง์ ํ์ดํผ ํ๋ผ๋ฏธํฐ๊ฐ ์์ผ๋ฏ๋ก ๋ฐ๋ชจ์ ์ ํฉํ ์ ํ์ ๋๋ค.
model = LGBMRegressor(random_state=random_state)
๊ธฐ๋ณธ ๋งค๊ฐ ๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ธฐ์ค ๋ชจ๋ธ์ ํ์ต ํด ๋ณด๊ฒ ์ต๋๋ค.
- ์ฆ์ ์ถ๋ ฅ๋ ๋ชจ๋ธ์ ๊ฒฐ๊ณผ๋ 3532์ ๋๋ค.
%%time
score = -cross_val_score(model, train_data, train_targets, cv=kf, scoring="neg_mean_squared_error", n_jobs=-1).mean()
print(score)
3532.0822189641976
CPU times: user 23 ms, sys: 33 ms, total: 56 ms
Wall time: 806 ms
- base_estimator: ๊ธฐ๋ณธ ๋ชจํ
- n_estimators: ๋ชจํ ๊ฐฏ์. ๋ํดํธ 10
- bootstrap: ๋ฐ์ดํฐ์ ์ค๋ณต ์ฌ์ฉ ์ฌ๋ถ. ๋ํดํธ True
- max_samples: ๋ฐ์ดํฐ ์ํ ์ค ์ ํํ ์ํ์ ์ ํน์ ๋น์จ. ๋ํดํธ 1.0
- bootstrap_features: ํน์ง ์ฐจ์์ ์ค๋ณต ์ฌ์ฉ ์ฌ๋ถ. ๋ํดํธ False
- max_features: ๋ค์ฐจ์ ๋ ๋ฆฝ ๋ณ์ ์ค ์ ํํ ์ฐจ์์ ์ ํน์ ๋น์จ 1.0
์ต์ ํ ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉํ์ฌ ๋ฐ๋ชจ ๋ชฉ์ ์ผ๋ก 3 ๊ฐ์ ๋งค๊ฐ ๋ณ์ ๋ง ์กฐ์ ํ๋ ๋ชจ๋ธ์ ์ต์ ํ ํ๋ ์์ ์ ๋๋ค.
- n_estimators: from 100 to 2000
- max_depth: from 2 to 20
- learning_rate: from 10e-5 to 1
Computing power๋ ์ผ๋ฐ์ ์ธ ๋ก์ปฌ ๋ฏธ๋์๋ฒ์ ํด๋ผ์ฐ๋์ปดํจํ ํ๊ฒฝ์ ์ฌ์ฉํ์ต๋๋ค.
- ๋ก์ปฌ๋ฏธ๋์๋ฒ : AMD 2700x (1 CPU - 8Core)
- ํด๋ผ์ฐ๋์๋ฒ : (18 CPU- 162core) [Intel(R) Xeon(R) 2.00GHZ]
ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ต์ ํ๋ฅผ ์ํํ๋ ์ ํต์ ์ธ ๋ฐฉ๋ฒ์ ๊ทธ๋ฆฌ๋ ๊ฒ์ ๋๋ ๋งค๊ฐ ๋ณ์ ์ค์์ผ๋ก, ํ์ต ์๊ณ ๋ฆฌ์ฆ์ ํ์ดํผ ํ๋ผ๋ฏธํฐ ๊ณต๊ฐ์์ ์๋์ผ๋ก ์ง์ ๋ ํ์ ์งํฉ์ ํตํด ์ ์ฒด์ ์ผ๋ก ๊ฒ์ํ๋ ๊ฒ์ ๋๋ค.
- ๊ฐ์ฅ ๋จผ์ ์๋ํด ๋ณผ ์์๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ sklearn.model_selection์ ํฌํจ ๋ GridSearchCV์ ๋๋ค.์ด ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ชจ๋ ๋งค๊ฐ ๋ณ์์ ์กฐํฉ์ 1 x 1๋ก ์๋ํ๊ณ ์ต์์ ๊ต์ฐจ ๊ฒ์ฆ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ง ๊ฒ์ ์ ํํฉ๋๋ค.
์ด ์ ๊ทผ ๋ฐฉ์์๋ ๋ช ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค.
- ๋งค์ฐ ๋๋ฆฝ๋๋ค. ๋ชจ๋ ๋งค๊ฐ ๋ณ์์ ๋ชจ๋ ์กฐํฉ์ ์๋ํ๊ณ ๋ง์ ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค. ๋ณ๋ ํ ์ถ๊ฐ ๋งค๊ฐ ๋ณ์๋ ์๋ฃํด์ผํ๋ ๋ฐ๋ณต ํ์๋ฅผ ๊ณฑํฉ๋๋ค. ๊ฐ๋ฅํ ๊ฐ์ด 10 ๊ฐ์ธ ์ ๋งค๊ฐ ๋ณ์๋ฅผ ๋งค๊ฐ ๋ณ์ ๊ทธ๋ฆฌ๋์ ์ถ๊ฐํ๋ค๊ณ ๊ฐ์ ํด๋ณด์ญ์์ค.์ด ๋งค๊ฐ ๋ณ์๋ ๋ฌด์๋ฏธํ ๊ฒ์ผ๋ก ํ๋ช ๋ ์ ์์ง๋ง ๊ณ์ฐ ์๊ฐ์ 10 ๋ฐฐ ์ฆ๊ฐํฉ๋๋ค.
- ์ด์ฐ ๊ฐ์ผ๋ก ๋ง ์๋ ํ ์ ์์ต๋๋ค. ์ ์ญ ์ต์ ๊ฐ์ด n_estimators = 550์ด์ง๋ง 100 ๋จ๊ณ์์ 100์์ 1000๊น์ง GridSearchCV๋ฅผ ์ํํ๋ ๊ฒฝ์ฐ ์ต์ ์ ์ ๋๋ฌํ์ง ๋ชปํ ๊ฒ์ ๋๋ค.
- ์ ์ ํ ์๊ฐ์ ๊ฒ์์ ์๋ฃํ๋ ค๋ฉด approximate localization of the optimum๋ฅผ ์๊ณ / ์ถ์ธกํด์ผํฉ๋๋ค.
์ด๋ฌํ ๋จ์ ์ค ์ผ๋ถ๋ฅผ ๊ทน๋ณต ํ ์ ์์ต๋๋ค. ๋งค๊ฐ ๋ณ์๋ณ๋ก ๊ทธ๋ฆฌ๋ ๊ฒ์ ๋งค๊ฐ ๋ณ์๋ฅผ ์ํํ๊ฑฐ๋ ํฐ ๋จ๊ณ๊ฐ์๋ ๋์ ๊ทธ๋ฆฌ๋์์ ์์ํ์ฌ ์ฌ๋ฌ ๋ฒ ์ฌ์ฉํ๊ณ ๋ฐ๋ณต์์ ๊ฒฝ๊ณ๋ฅผ ์ขํ๊ณ ๋จ๊ณ ํฌ๊ธฐ๋ฅผ ์ค์ผ ์ ์์ต๋๋ค. ํ์ง๋ง, ์ฌ์ ํ ๋งค์ฐ ๊ณ์ฐ ์ง์ฝ์ ์ด๊ณ ๊ธธ ๊ฒ์ ๋๋ค.
- ์ฐ๋ฆฌ์ ๊ฒฝ์ฐ ๊ทธ๋ฆฌ๋ ๊ฒ์์ ์ํํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ถ์ ํด ๋ณด๊ฒ ์ต๋๋ค.
- ๊ทธ๋ฆฌ๋๊ฐ 'n_estimators'(100 ~ 2000)์ ๊ฐ๋ฅํ ๊ฐ 20 ๊ฐ,
- 'max_depth'์ 19 ๊ฐ ๊ฐ (2 ~ 20),
- 'learning_rate'(10e-4 ~ 0.1)์ 5 ๊ฐ ๊ฐ์ผ๋ก ๊ตฌ์ฑ๋๊ธฐ๋ฅผ ์ํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค.
- ์ฆ, cross_val_score 20 * 19 * 5 = 1900 ๋ฒ ๊ณ์ฐํด์ผํฉ๋๋ค. 1 ๋ฒ ๊ณ์ฐ์ 0.5 ~ 1.0 ์ด๊ฐ ๊ฑธ๋ฆฌ๋ฉด ๊ทธ๋ฆฌ๋ ๊ฒ์์ 15 ~ 30 ๋ถ ๋์ ์ง์๋ฉ๋๋ค. ~ 400 ๋ฐ์ดํฐ ํฌ์ธํธ๊ฐ์๋ ๋ฐ์ดํฐ ์ธํธ์๋ ๋๋ฌด ๋ง์ต๋๋ค.
- ์คํ ์๊ฐ์ ์ค๋ ๊ฑธ๋ฆฌ์ง ๋ง์์ผํ๋ฏ๋ก, ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ ๋ถ์ ํ ๊ตฌ๊ฐ์ ์ขํ ์ผํฉ๋๋ค. 5 * 8 * 3 = 120 ์กฐํฉ ๋ง ๋จ๊ฒผ์ต๋๋ค.
- (18 CPU- 162core) Wall time: 5.5 s
- AMD 2700x (1 CPU - 8Core) Wall time: 6.7 s
%%time
from sklearn.model_selection import GridSearchCV
param_grid={'max_depth': np.linspace(5,12,8,dtype = int),
'n_estimators': np.linspace(800,1200,5, dtype = int),
'learning_rate': np.logspace(-3, -1, 3),
'random_state': [random_state]}
gs=GridSearchCV(model, param_grid, scoring='neg_mean_squared_error', n_jobs=-1, cv=kf, verbose=False)
gs.fit(train_data, train_targets)
gs_test_score=mean_squared_error(test_targets, gs.predict(test_data))
print('===========================')
print("Best MSE = {:.3f} , when params {}".format(-gs.best_score_, gs.best_params_))
print('===========================')
===========================
Best MSE = 3319.975 , when params {'learning_rate': 0.01, 'max_depth': 5, 'n_estimators': 800, 'random_state': 42}
===========================
CPU times: user 1.58 s, sys: 21 ms, total: 1.6 s
Wall time: 6.3 s
๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ํ์ง๋ง, ๊ทธ๊ฒ์ ๋ง์ ์๊ฐ์ ๋ณด๋์ต๋๋ค. ๋งค๊ฐ ๋ณ์๊ฐ ๋ฐ๋ณต์์ ๋ฐ๋ณต์ผ๋ก ์ด๋ป๊ฒ ๋ณ๊ฒฝ๋์๋์ง ์ดํด ๋ณด๊ฒ ์ต๋๋ค.
- ์๋ ๊ทธ๋ฆผ์์, (MSE๊ฐ ๋ฎ์๋ ๊ฐ ๋ณ์๊ด๊ณ ์ฐธ์กฐ)
- ์๋ฅผ ๋ค์ด max_depth๋ ์ ์์ ํฌ๊ฒ ์ํฅ์์ฃผ์ง ์๋ ๊ฐ์ฅ ๋ ์ค์ํ ๋งค๊ฐ ๋ณ์์์ ์ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ max_depth์ 8 ๊ฐ์ง ๋ค๋ฅธ ๊ฐ์ ๊ฒ์ํ๊ณ ๋ค๋ฅธ ๋งค๊ฐ ๋ณ์์ ๋ํ ๊ณ ์ ๊ฐ ๊ฒ์์ ์ฌ์ฉํฉ๋๋ค. ์๊ฐ๊ณผ ์์์ ๋ญ๋น์ ๋๋ค.
gs_results_df=pd.DataFrame(np.transpose([-gs.cv_results_['mean_test_score'],
gs.cv_results_['param_learning_rate'].data,
gs.cv_results_['param_max_depth'].data,
gs.cv_results_['param_n_estimators'].data]),
columns=['score', 'learning_rate', 'max_depth', 'n_estimators'])
gs_results_df.plot(subplots=True,figsize=(10, 10))
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6fc7898>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6febe80>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6f96898>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6fd2828>],
dtype=object)
Research Paper Random Search
- Random Search๋ ๊ทธ๋ฆฌ๋ ๊ฒ์๋ณด๋ค ํ๊ท ์ ์ผ๋ก ๋ ํจ๊ณผ์ ์ ๋๋ค.
- ์๋ฏธ์๋ ๋งค๊ฐ ๋ณ์์ ์๊ฐ์ ์๋นํ์ง ์์. ๋ชจ๋ ๋จ๊ณ์์ ๋ฌด์์ ๊ฒ์์ ๋ชจ๋ ๋งค๊ฐ ๋ณ์๋ฅผ ๋ณ๊ฒฝํฉ๋๋ค.
- ํ๊ท ์ ์ผ๋ก ๊ทธ๋ฆฌ๋ ๊ฒ์๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๊ฒ ~ ์ต์ ์ ๋งค๊ฐ ๋ณ์๋ฅผ ์ฐพ์ต๋๋ค.
- ์ฐ์ ๋งค๊ฐ ๋ณ์๋ฅผ ์ต์ ํ ํ ๋ ๊ทธ๋ฆฌ๋์ ์ํด ์ ํ๋์ง ์์ต๋๋ค.
- ๊ทธ๋ฆฌ๋์์ ๊ธ๋ก๋ฒ ์ต์ ๋งค๊ฐ ๋ณ์๋ฅผ ์ฐพ์ง ๋ชปํ ์ ์์ต๋๋ค.
- ๋ชจ๋ ๋จ๊ณ๋ ๋ ๋ฆฝ์ ์ ๋๋ค. ๋ชจ๋ ํน์ ๋จ๊ณ์์ ์ง๊ธ๊น์ง ์์ง ๋ ๊ฒฐ๊ณผ์ ๋ํ ์ ๋ณด๋ฅผ ์ฌ์ฉํ์ง ์์ต๋๋ค.
์์ ๋, sklearn.model_selection์์ RandomizedSearchCV๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๋งค์ฐ ๋์ ๋งค๊ฐ ๋ณ์ ๊ณต๊ฐ์ผ๋ก ์์ํ์ฌ 50 ๊ฐ์ ๋ฌด์์ ๋จ๊ณ ๋ง ๋ง๋ค ๊ฒ์ ๋๋ค.
์ํ์๋:
- (18 CPU- 162core) Wall time: 2.51 s
- AMD 2700x (1 CPU - 8Core) Wall time: 3.08 s
%%time
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint
param_grid_rand={'learning_rate': np.logspace(-5, 0, 100),
'max_depth': randint(2,20),
'n_estimators': randint(100,2000),
'random_state': [random_state]}
rs=RandomizedSearchCV(model, param_grid_rand, n_iter = n_iter, scoring='neg_mean_squared_error',
n_jobs=-1, cv=kf, verbose=False, random_state=random_state)
rs.fit(train_data, train_targets)
rs_test_score=mean_squared_error(test_targets, rs.predict(test_data))
print('===========================')
print("Best MSE = {:.3f} , when params {}".format(-rs.best_score_, rs.best_params_))
print('===========================')
===========================
Best MSE = 3200.402 , when params {'learning_rate': 0.0047508101621027985, 'max_depth': 19, 'n_estimators': 829, 'random_state': 42}
===========================
CPU times: user 1.16 s, sys: 25 ms, total: 1.19 s
Wall time: 3.15 s
๊ฒฐ๊ณผ๋ GridSearchCV๋ณด๋ค ๋ซ์ต๋๋ค. ๋ ์ ์ ์๊ฐ์ ์๋นํ๊ณ ๋ ์์ ํ ๊ฒ์์ํ์ต๋๋ค. ์๊ฐํ๋ฅผ ์ดํด ๋ณด๊ฒ ์ต๋๋ค.
- random search์ ๋ชจ๋ ๋จ๊ณ๋ ์์ ํ ๋ฌด์์์ ๋๋ค. ์ธ๋ชจ์๋ ๋งค๊ฐ ๋ณ์์ ์๊ฐ์ ์๋นํ์ง ์๋ ๋ฐ ๋์์ด๋์ง๋ง ์ฌ์ ํ ์ฒซ ๋ฒ์งธ ๋จ๊ณ์์ ์์ง ๋ ์ ๋ณด๋ฅผ ์ฌ์ฉํ์ฌ ํ์์ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ํ์ง ์์ต๋๋ค.
rs_results_df=pd.DataFrame(np.transpose([-rs.cv_results_['mean_test_score'],
rs.cv_results_['param_learning_rate'].data,
rs.cv_results_['param_max_depth'].data,
rs.cv_results_['param_n_estimators'].data]),
columns=['score', 'learning_rate', 'max_depth', 'n_estimators'])
rs_results_df.plot(subplots=True,figsize=(10, 10))
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6dfd4a8>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6d44668>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6d78630>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6d2c630>],
dtype=object)
Research Paper HyperBand
Abstract ๋ฐ์ท: ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ์ข์ ํ์ดํผ ํ๋ผ๋ฏธํฐ ์งํฉ์ ์๋ณํ๋ ๋ฐ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ต๊ทผ ์ ๊ทผ ๋ฐฉ์์ ๋ฒ ์ด์ง์ ์ต์ ํ๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌ์ฑ์ ์ ์ ์ ์ผ๋ก ์ ํํ์ง๋ง ์ ์ ํ ๋ฆฌ์์ค ํ ๋น ๋ฐ ์กฐ๊ธฐ ์ค์ง๋ฅผ ํตํด ์์ ๊ฒ์ ์๋๋ฅผ ๋์ด๋ ๋ฐ ์ค์ ์ ๋ก๋๋ค. ๋ฐ๋ณต, ๋ฐ์ดํฐ ์ํ ๋๋ ๊ธฐ๋ฅ๊ณผ ๊ฐ์ ์ฌ์ ์ ์ ๋ ๋ฆฌ์์ค๊ฐ ๋ฌด์์๋ก ์ํ๋ง ๋ ๊ตฌ์ฑ์ ํ ๋น๋๋ ์์ ํ์ ๋น ํ๋ฅ ์ ๋ฌดํ ๋ฌด์ฅ ๋ฐด๋ํธ ๋ฌธ์ ๋ก ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ต์ ํ๋ฅผ ๊ณต์ํํฉ๋๋ค. ์ด ํ๋ ์ ์ํฌ์ ๋ํด ์๋ก์ด ์๊ณ ๋ฆฌ์ฆ ์ธ Hyperband๋ฅผ ๋์ ํ๊ณ ์ด๋ก ์ ์์ฑ์ ๋ถ์ํ์ฌ ๋ช ๊ฐ์ง ๋ฐ๋์งํ ๋ณด์ฅ์ ์ ๊ณตํฉ๋๋ค. ๋ํ, ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ต์ ํ ๋ฌธ์ ๋ชจ์์ ๋ํด Hyperband๋ฅผ ์ธ๊ธฐ์๋ ๋ฒ ์ด์ง์ ์ต์ ํ ๋ฐฉ๋ฒ๊ณผ ๋น๊ตํฉ๋๋ค. Hyperband๋ ๋ค์ํ ๋ฅ ๋ฌ๋ ๋ฐ ์ปค๋ ๊ธฐ๋ฐ ํ์ต ๋ฌธ์ ์ ๋ํด ๊ฒฝ์ ์ ์ฒด๋ณด๋ค ํจ์ฌ ๋น ๋ฅธ ์๋๋ฅผ ์ ๊ณต ํ ์ ์์ต๋๋ค. ยฉ 2018 Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh ๋ฐ Ameet Talwalkar.
- Hyperband Search๋ ์ต์ ํ ๊ฒ์ ์๋์ ์ค์ ์ ๋ก๋๋ค.
- n๊ฐ์ ํ์ดํผํ๋ผ๋ฏธํฐ ์กฐํฉ์ ๋๋ค ์ํ๋ง.
- ์ ์ฒด resource๋ฅผ n๊ฐ๋ก ๋ถํ ํ๊ณ , ํ์ดํผ ํ๋ผ๋ฏธํฐ ์กฐํฉ์ ๊ฐ๊ฐ ํ ๋นํ์ฌ ํ์ต
- ๊ฐ ํ์ต ํ๋ก์ธ์ค๋ ์ผ์ ๋น์จ ์ด์์ ์์ ์กฐํฉ์ ๋จ๊ธฐ๊ณ ๋ฒ๋ฆผ.
์ํ์๋:
- (18 CPU- 162core) Wall time: 2.51 s
- AMD 2700x (1 CPU - 8Core) Wall time: 1.19 s
cloud์์์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๋ถ์ฐ ์์์ ์ค๋น ์๊ฐ์ด ์๋์ ์ผ๋ก ๊ธด๊ฒ์ ๋ณผ์ ์์์.
!git clone https://github.com/thuijskens/scikit-hyperband.git 2>/dev/null 1>/dev/null
!cp -r scikit-hyperband/* .
!python setup.py install 2>/dev/null 1>/dev/null
%%time
from hyperband import HyperbandSearchCV
from scipy.stats import randint as sp_randint
from sklearn.preprocessing import LabelBinarizer
param_hyper_band={'learning_rate': np.logspace(-5, 0, 100),
'max_depth': randint(2,20),
'n_estimators': randint(100,2000),
#'num_leaves' : randint(2,20),
'random_state': [random_state]
}
hb = HyperbandSearchCV(model, param_hyper_band, max_iter = n_iter, scoring='neg_mean_squared_error', resource_param='n_estimators', random_state=random_state)
#%time search.fit(new_training_data, y)
hb.fit(train_data, train_targets)
hb_test_score=mean_squared_error(test_targets, hb.predict(test_data))
print('===========================')
print("Best MSE = {:.3f} , when params {}".format(-hb.best_score_, hb.best_params_))
print('===========================')
===========================
Best MSE = 3431.685 , when params {'learning_rate': 0.13848863713938717, 'max_depth': 12, 'n_estimators': 16, 'random_state': 42}
===========================
CPU times: user 13.4 s, sys: 64 ms, total: 13.5 s
Wall time: 2.06 s
hb_results_df=pd.DataFrame(np.transpose([-hb.cv_results_['mean_test_score'],
hb.cv_results_['param_learning_rate'].data,
hb.cv_results_['param_max_depth'].data,
hb.cv_results_['param_n_estimators'].data]),
columns=['score', 'learning_rate', 'max_depth', 'n_estimators'])
hb_results_df.plot(subplots=True,figsize=(10, 10))
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6c3f7f0>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6c2a358>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6bd4320>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbdc6b882b0>],
dtype=object)
Research Paper Bayesian optimization
Random ๋๋ Grid Search์ ๋ฌ๋ฆฌ ๋ฒ ์ด์ง์ ์ ๊ทผ ๋ฐฉ์์ ๋ชฉํ ํจ์์ ์ ์ ํ๋ฅ ์ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ๋งคํํ๋ ํ๋ฅ ๋ชจ๋ธ์ ํ์ฑํ๋๋ฐ ์ฌ์ฉํ๋ ๊ณผ๊ฑฐ ํ๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ถ์ ํฉ๋๋ค.
P(Score | Hyperparameters)
๋ ผ๋ฌธ์์ ์ด ๋ชจ๋ธ์ ๋ชฉ์ ํจ์์ ๋ํ "surrogate"๋ผ๊ณ ํ๋ฉฐ p (y | x)๋ก ํ์๋ฉ๋๋ค. surrogate ํจ์๋ ๋ชฉ์ ํจ์๋ณด๋ค ์ต์ ํํ๊ธฐ ํจ์ฌ ์ฌ์ฐ ๋ฉฐ ๋ฒ ์ด์ง์ ๋ฐฉ๋ฒ์ ๋๋ฆฌ ํจ์์์ ๊ฐ์ฅ ์ ์ํ๋๋ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ ํํ์ฌ ์ค์ ๋ชฉ์ ํจ์๋ฅผ ํ๊ฐํ ๋ค์ ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ธํธ๋ฅผ ์ฐพ๋ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค.
pseudo code๋ก ์ ๋ฆฌํ๋ฉด:
- ๋ชฉ์ ํจ์์ ๋๋ฆฌ ํ๋ฅ ๋ชจ๋ธ ๊ตฌ์ถ
- surrogate์์ ๊ฐ์ฅ ์ ์ํ๋๋ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐพ์ต๋๋ค.
- ์ด๋ฌํ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ค์ ๋ชฉ์ ํจ์์ ์ ์ฉ
- ์ ๊ฒฐ๊ณผ๋ฅผ ํตํฉํ๋ ๋๋ฆฌ ๋ชจ๋ธ ์ ๋ฐ์ดํธ
- ์ต๋ ๋ฐ๋ณต ๋๋ ์๊ฐ์ ๋๋ฌ ํ ๋๊น์ง 2-4 ๋จ๊ณ๋ฅผ ๋ฐ๋ณตํฉ๋๋ค.
๋ ๊น์ด์๋ ๋ฒ ์ด์ง์ ์ต์ ํ์ ๋ํ ํ๋ฅญํ ์ปค๋์ ์ฌ๊ธฐ ์ฐธ์กฐ: https://www.kaggle.com/artgor/bayesian-optimization-for-robots
-
Surrogate Model : ํ์ฌ๊น์ง ์กฐ์ฌ๋ ์ ๋ ฅ๊ฐ-ํจ์ซ๊ฐ ์ ๋คย ${(๐ฅ_1,f(๐ฅ_1)), ..., (๐ฅ_๐ก,f(๐ฅ_๐ก))}$ ๋ฅผ ๋ฐํ์ผ๋ก, ๋ฏธ์ง์ ๋ชฉ์ ํจ์์ ํํ์ ๋ํ ํ๋ฅ ์ ์ธ ์ถ์ ์ ์ํํ๋ ๋ชจ๋ธ
-
Acquisition Function: ๋ชฉ์ ํจ์์ ๋ํ ํ์ฌ๊น์ง์ ํ๋ฅ ์ ์ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ์ผ๋ก, โ์ต์ ์ ๋ ฅ๊ฐย ${๐ฅ^โ}$๋ฅผ ์ฐพ๋ ๋ฐ ์์ด ๊ฐ์ฅ ์ ์ฉํ ๋งํโ ๋ค์ ์ ๋ ฅ๊ฐ ํ๋ณดย ${๐ฅ_(๐ก+1)}$์ ์ถ์ฒํด ์ฃผ๋ ํจ์ Expected Improvement(EI) ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
์ํ์๋:
- (18 CPU- 162core) Wall time: 2min 24s
- AMD 2700x (1 CPU - 8Core) Wall time: 1min 36s
์๋์ ์ผ๋ก ๋ก์ปฌํ ์คํธ์ ์ํ ์๋๊ฐ ๋น ๋ฅธ๊ฒ์ ๋ณผ์์์๋ค.
#! pip install scikit-optimize
#https://towardsdatascience.com/hyperparameter-optimization-with-scikit-learn-scikit-opt-and-keras-f13367f3e796
from skopt import BayesSearchCV
from skopt.space import Real, Categorical, Integer
%%time
search_space={'learning_rate': np.logspace(-5, 0, 100),
"max_depth": Integer(2, 20),
'n_estimators': Integer(100,2000),
'random_state': [random_state]}
def on_step(optim_result):
"""
Callback meant to view scores after
each iteration while performing Bayesian
Optimization in Skopt"""
score = bayes_search.best_score_
print("best score: %s" % score)
if score >= 0.98:
print('Interrupting!')
return True
bayes_search = BayesSearchCV(model, search_space, n_iter=n_iter, # specify how many iterations
scoring='neg_mean_squared_error', n_jobs=-1, cv=5)
bayes_search.fit(train_data, train_targets, callback=on_step) # callback=on_step will print score after each iteration
bayes_test_score=mean_squared_error(test_targets, bayes_search.predict(test_data))
print('===========================')
print("Best MSE = {:.3f} , when params {}".format(-bayes_search.best_score_, bayes_search.best_params_))
print('===========================')
best score: -4415.920614880022
best score: -4415.920614880022
best score: -4415.920614880022
best score: -4415.920614880022
best score: -4116.905834420919
best score: -4116.905834420919
best score: -4116.905834420919
best score: -4116.905834420919
best score: -4116.905834420919
best score: -3540.855689828868
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3467.4059934906645
best score: -3465.869585251784
best score: -3462.4668073239764
best score: -3462.4668073239764
best score: -3462.4668073239764
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3460.603434822278
best score: -3459.5705953392157
best score: -3456.063877875675
best score: -3456.063877875675
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
best score: -3454.9987003394112
===========================
Best MSE = 3454.999 , when params OrderedDict([('learning_rate', 0.005336699231206307), ('max_depth', 2), ('n_estimators', 655), ('random_state', 42)])
===========================
CPU times: user 1min 59s, sys: 3min 34s, total: 5min 33s
Wall time: 1min 26s
bayes_results_df=pd.DataFrame(np.transpose([
-np.array(bayes_search.cv_results_['mean_test_score']),
np.array(bayes_search.cv_results_['param_learning_rate']).data,
np.array(bayes_search.cv_results_['param_max_depth']).data,
np.array(bayes_search.cv_results_['param_n_estimators']).data
]),
columns=['score', 'learning_rate', 'max_depth', 'n_estimators'])
bayes_results_df.plot(subplots=True,figsize=(10, 10))
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd6bfcc208>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd68640470>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd686b97f0>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd686f1c50>],
dtype=object)
- ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ค๋ฃจ๊ธฐ ์ํด hyperopt [https://github.com/hyperopt/hyperopt] ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
- ํ์ฌ, ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ต์ ํ๋ฅผ์ํ ์ต์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ค ํ๋์ ๋๋ค.
#!pip install hyperopt
์ฐ์ hyperopt์์ ๋ช ๊ฐ์ง ์ ์ฉํ ํจ์๋ฅผ ์๊ฐํฉ๋๋ค.
- fmin : ์ต์ํ ๋ฉ์ธ ๋ชฉ์ ํจ์
- tpe and anneal : optimization ์ ๊ทผ๋ฐฉ์
- hp : ๋ค์ํ ๋ณ์๋ค์ ๋ถํฌ ํฌํจ
- Trials : logging์ ์ฌ์ฉ
from hyperopt import fmin, tpe, hp, anneal, Trials
hyperop.fmin์ ์ธํฐํ์ด์ค๋ Grid ๋๋ Randomized search์ ๋ค๋ฆ ๋๋ค. ๋จผ์ , ์ต์ํ ํ ํจ์๋ฅผ ์ ์ํฉ๋๋ค.
- ์๋๋ 'learning_rate', 'max_depth', 'n_estimators'์ ๊ฐ์ ๋ค์ํ ๋งค๊ฐ ๋ณ์๋ฅผ ์ต์ํํ๋ gb_mse_cv () ํจ์๊ฐ ์์ต๋๋ค.
def gb_mse_cv(params, random_state=random_state, cv=kf, X=train_data, y=train_targets):
# the function gets a set of variable parameters in "param"
params = {'n_estimators': int(params['n_estimators']),
'max_depth': int(params['max_depth']),
'learning_rate': params['learning_rate']}
# we use this params to create a new LGBM Regressor
model = LGBMRegressor(random_state=random_state, **params)
# and then conduct the cross validation with the same folds as before
score = -cross_val_score(model, X, y, cv=cv, scoring="neg_mean_squared_error", n_jobs=-1).mean()
return score
Research Paper TPE
TPE๋ Hyperopt์ ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์ต์ ํ๋ฅผ ์ํด ๋ฒ ์ด์ง์ ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉํฉ๋๋ค. ๋ชจ๋ ๋จ๊ณ์์ ํจ์์ ํ๋ฅ ๋ชจ๋ธ์ ๊ตฌ์ถํ๊ณ ๋ค์ ๋จ๊ณ์์ ๊ฐ์ฅ ์ ๋งํ ๋งค๊ฐ ๋ณ์๋ฅผ ์ ํํ๋ ค๊ณ ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด๋ฌํ ์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์๊ณผ ๊ฐ์ด ์๋ํฉ๋๋ค.
- 1.์์์ initial point ์์ฑ
${x^*}$ - 2.${F(x^*)}$ ๊ณ์ฐ
- 3.trials ๋ก๊น ์ด๋ ฅ์ ์ฌ์ฉํด์, ์กฐ๊ฑด๋ถ ํ๋ฅ ๋ชจ๋ธ
$P(F | x)$ ๋ฅผ ์์ฑ- 4.$ P (F | x) $์ ๋ฐ๋ผ $ {F (x_i)} $๊ฐ ๋ ๋์์ง ๊ฐ๋ฅ์ฑ์ด ๊ฐ์ฅ ๋์ $ {x_i} $๋ฅผ ์ ํํฉ๋๋ค.
- 5.$ {F (x_i)} $์ real values๋ฅผ ๊ณ์ฐํฉ๋๋ค.
- 6.์ค์ง ๊ธฐ์ค ์ค ํ๋๊ฐ ์ถฉ์กฑ ๋ ๋๊น์ง 3-5 ๋จ๊ณ๋ฅผ ๋ฐ๋ณตํฉ๋๋ค (์ : i> max_eval).
์๋ฅผ ๋ค์ด ํน์ TPE ์๊ณ ๋ฆฌ์ฆ์ ๋ํ ์์ธํ ์ ๋ณด๋ ์๋ ๋งํฌ ์ฐธ์กฐ. (์ด ๋งํฌ ๋ด์ฉ์ ์์ธ๋ฒ์ ์ผ๋ก, ํํ ๋ฆฌ์ผ์ ๋ฒ์๋ฅผ ๋ฒ์ด๋ฉ๋๋ค.)
- fmin์ ์ฌ์ฉ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋งค๊ฐ ๋ณ์์ ๊ฐ๋ฅํ ๊ณต๊ฐ์ ์ ์ํ๊ณ ํจ์๋ฅผ ํธ์ถํ๊ธฐ ๋งํ๋ฉด๋ฉ๋๋ค.
์ํ์๋:
- (18 CPU- 162core) Wall time: 7.3s
- AMD 2700x (1 CPU - 8Core) Wall time: 7.98s
%%time
# possible values of parameters
space={'n_estimators': hp.quniform('n_estimators', 100, 2000, 1),
'max_depth' : hp.quniform('max_depth', 2, 20, 1),
'learning_rate': hp.loguniform('learning_rate', -5, 0)
}
# trials will contain logging information
trials = Trials()
best=fmin(fn=gb_mse_cv, # function to optimize
space=space,
algo=tpe.suggest, # optimization algorithm, hyperotp will select its parameters automatically
max_evals=n_iter, # maximum number of iterations
trials=trials, # logging
rstate=np.random.RandomState(random_state) # fixing random state for the reproducibility
)
# computing the score on the test set
model = LGBMRegressor(random_state=random_state, n_estimators=int(best['n_estimators']),
max_depth=int(best['max_depth']),learning_rate=best['learning_rate'])
model.fit(train_data,train_targets)
tpe_test_score=mean_squared_error(test_targets, model.predict(test_data))
print("Best MSE {:.3f} params {}".format( gb_mse_cv(best), best))
100%|โโโโโโโโโโ| 50/50 [00:06<00:00, 8.32trial/s, best loss: 3186.7910608402444]
Best MSE 3186.791 params {'learning_rate': 0.026975706032324936, 'max_depth': 20.0, 'n_estimators': 168.0}
CPU times: user 784 ms, sys: 37 ms, total: 821 ms
Wall time: 6.08 s
Best MSE 3186๋ก RandomizedSearch์ ๋นํด ์๊ฐ์ ๊ฑธ๋ฆฌ์ง๋ง, ์ข ๋ ๋์ ์๋ฃจ์ ์ ์ฐพ์์ต๋๋ค.
tpe_results=np.array([[x['result']['loss'],
x['misc']['vals']['learning_rate'][0],
x['misc']['vals']['max_depth'][0],
x['misc']['vals']['n_estimators'][0]] for x in trials.trials])
tpe_results_df=pd.DataFrame(tpe_results,
columns=['score', 'learning_rate', 'max_depth', 'n_estimators'])
tpe_results_df.plot(subplots=True,figsize=(10, 10))
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd5e386c88>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd5e2f9828>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd5e3f7828>,
<matplotlib.axes._subplots.AxesSubplot object at 0x7fbd5e426c88>],
dtype=object)
๋ชจ๋ ์ ๊ทผ ๋ฐฉ์์ ๋ํด iterations ์์ ๋ฐ๋ฅธ best_cumulative_score๋ฅผ ์๊ฐํ ํด๋ด ๋๋ค.
scores_df=pd.DataFrame(index=range(n_iter))
scores_df['Grid Search']=gs_results_df['score'].cummin()
scores_df['Random Search']=rs_results_df['score'].cummin()
scores_df['Hyperband']=hb_results_df['score'].cummin()
scores_df['Bayesian optimization ']=bayes_results_df['score'].cummin()
scores_df['TPE']=tpe_results_df['score'].cummin()
ax = scores_df.plot()
ax.set_xlabel("number_of_iterations")
ax.set_ylabel("best_cumulative_score")
Text(0, 0.5, 'best_cumulative_score')
-
Random Search๋ ๋จ์ํ๋ฉด์, ์๊ฐ์ ๋น์ฉ์ ๋ฐ๋ฅธ ์ค์ฝ์ด๊ฐ ๋์ ๊ฒ์ ์ ์ ์์์ต๋๋ค.
-
TPE ์๊ณ ๋ฆฌ์ฆ์ ์ค์ ๋ก ์ดํ ๋จ๊ณ์์๋ ์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ๊ฒ์ ๊ฒฐ๊ณผ๋ฅผ ์ง์์ ์ผ๋ก ๊ฐ์ ํ๋ ๋ฐ๋ฉด, Random search๋ ์ฒ์์ ์๋นํ ์ข์ ์๋ฃจ์ ์ ๋ฌด์์๋ก ์ฐพ์ ๋ค์ ๊ฒฐ๊ณผ๋ฅผ ์ฝ๊ฐ๋ง ๊ฐ์ ํ์ต๋๋ค.
-
TPE์ RandomizedSearch ๊ฒฐ๊ณผ์ ํ์ฌ ์ฐจ์ด๋ ๋งค์ฐ ์์ง๋ง, ๋ ๋ค์ํ ๋ฒ์์ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ผ๋ถ ์ค์ ์ ํ๋ฆฌ์ผ์ด์ ์์ hyperopt๋ ์๋นํ ์๊ฐ ๋๋น ์ ์ ํฅ์์ ์ ๊ณต ํ ์ ์์ผ๋ฆฌ๋ผ ๋ด ๋๋ค.
-
์ฐธ๊ณ : ์ค์ ์ํ์์๋ ๋น๊ต๋ฅผ ์ํด ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณตํ์ง ์๊ณ ์๊ฐ์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์ ํํ์ง๋ง ์ฅ๋๊ฐ ์์ ์์๋ tpe ๋ฐ ์ด๋๋ง์ ์ถ๊ฐ ๊ณ์ฐ์ ์์๋๋ ์๊ฐ์ ๋น์จ์ด cross_val_score ๊ณ์ฐ ์๊ฐ์ ๋นํด ๋์ผ๋ฏ๋ก ๋ฐ๋ณต ํ์์ ๊ด๋ จํ์ฌ ํ์ดํผ ์ตํธ ๋ฐ ํ๋กฏ ์ ์์ ๊ณ์ฐ ์๋์ ๋ํด ์คํดํ์ง ์๊ธฐ๋ก ๊ฒฐ์ ํ์ต๋๋ค.
์ค์ Evaluate ํ ์คํธ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํด ๊ฒฐ๊ณผ๋ฅผ ๋น๊ตํ๊ณ ๊ต์ฐจ ๊ฒ์ฆ ๊ฒฐ๊ณผ์ inline ํ์ธํ๊ฒ ์ต๋๋ค.
print('Test MSE scored:')
print("Grid Search : {:.3f}".format(gs_test_score))
print("Random Search : {:.3f}".format(rs_test_score))
print("Hyperband : {:.3f}".format(hb_test_score))
print("Bayesian optimization : {:.3f}".format(bayes_test_score))
print("TPE : {:.3f}".format(tpe_test_score))
Test MSE scored:
Grid Search : 3045.329
Random Search : 2877.117
Hyperband : 2852.900
Bayesian optimization : 2710.621
TPE : 2942.574
Test data์ evaluation์์๋ Bayesian optimization ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ ํ์ดํผํ๋ผ๋ฏธํฐ์ ๋ชจ๋ธ MSE ์ ์๊ฐ ๊ฐ์ฅ ๋ฎ์๊ฒ์ผ๋ก ๋ํ๋ฌ์ต๋๋ค. (์คํ์ฉ Toy dataset์ผ๋ก ์คํ์ ๋ฐ๋ผ ๊ฒฐ๊ณผ์์ ์ฐธ๊ณ )
- Accuinsight+์ modeler AutoDL์ ์ ์ฉํ ๋ค์ํ ํ์ดํผ ํ๋ผ๋ฏธํฐ ์ต์ ํ ์ ๊ทผ ๋ฐฉ์์ ๋ํด ์์๋ดค์ต๋๋ค.
- ์ต์ hyperopt์ TPE์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ๋ฐฉ๋ฒ์ ์ ์ ์์์ต๋๋ค.
- ์ค์ ๋ชจ๋ธ๋ง ํ๊ฒฝ์์๋, ์ค์ ๋ก ์ด๋ค ์ ๊ทผ ๋ฐฉ์์ด ๊ฐ์ฅ ์ข์์ง ๋ฏธ๋ฆฌ ์ ์ ์์ผ๋ฉฐ, ๋๋ก๋ ๊ฐ๋จํ RandomizedSearch๊ฐ ์ข์ ์ ํ์ด ๋ ์ ์์ผ๋ฏ๋ก ํญ์ ์์๋๋ฉด ์ ์ฉํฉ๋๋ค.
- ์ด ํํ ๋ฆฌ์ผ์ด ํฅํ ML, DL ํ๋ก์ ํธ์์ ๋ง์ ์๊ฐ์ ์ ์ฝํ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.