인공재환

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import warnings
from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier
import warnings
warnings.simplefilter(action= 'ignore', category=FutureWarning)

오늘은 부스팅이 해보고 싶어서 XGB Classifier를 이용하여 분류해보고자 한다.

하이퍼파라미터탐색은 GridSearch를 이용하겠다.

전처리된 데이터를 준비하고,

train = pd.read_csv('1차 최종 train.csv')
test = pd.read_csv('test.csv')

혹시 모르니 info()를 통해 타입을 살펴보자.

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8125 entries, 0 to 8124
Data columns (total 13 columns):
 #   Column        Non-Null Count  Dtype
---  ------        --------------  -----
 0   Unnamed: 0    8125 non-null   int64
 1   HomePlanet    8125 non-null   int64
 2   CryoSleep     8125 non-null   int64
 3   Cabin         8125 non-null   int64
 4   Destination   8125 non-null   int64
 5   Age           8125 non-null   int64
 6   VIP           8125 non-null   int64
 7   RoomService   8125 non-null   int64
 8   FoodCourt     8125 non-null   int64
 9   ShoppingMall  8125 non-null   int64
 10  Spa           8125 non-null   int64
 11  VRDeck        8125 non-null   int64
 12  Transported   8125 non-null   int64
dtypes: int64(13)

이제 input과 target 데이터로 나누자.

train_input = train.drop('Transported',axis=1)
train_target = train['Transported']
train_input.info()

[ 하이퍼 파라미터 탐색 / 튜닝]

params = {'learning_rate':(0.01,1),
          'gamma':(0,1),
          'max_depth':(3,10),
          'sub_sample':(0.5,1),
          'min_child_weight': (1, 5),
          'colsample_bytree':(0.1,1),
          'n_estimators' : (50,200)}

gs = GridSearchCV(XGBClassifier(random_state = 42), param_grid=params ,n_jobs=-1)

gs.fit(train_input, train_target)

[15:35:27] WARNING: C:/buildkite-agent/builds/buildkite-windows-cpu-autoscaling-group-i-0fc7796c793e6356f-1/xgboost/xgboost-ci-windows/src/learner.cc:767: 
Parameters: { "sub_sample" } are not used.

GridSearchCV(estimator=XGBClassifier(base_score=None, booster=None,
                                     callbacks=None, colsample_bylevel=None,
                                     colsample_bynode=None,
                                     colsample_bytree=None,
                                     early_stopping_rounds=None,
                                     enable_categorical=False, eval_metric=None,
                                     feature_types=None, gamma=None,
                                     gpu_id=None, grow_policy=None,
                                     importance_type=None,
                                     interaction_constraints=None,
                                     learning_rate=None, max_b...
                                     max_delta_step=None, max_depth=None,
                                     max_leaves=None, min_child_weight=None,
                                     missing=nan, monotone_constraints=None,
                                     n_estimators=100, n_jobs=None,
                                     num_parallel_tree=None, predictor=None,
                                     random_state=42, ...),
             n_jobs=-1,
             param_grid={'colsample_bytree': (0.1, 1), 'gamma': (0, 1),
                         'learning_rate': (0.01, 1), 'max_depth': (3, 10),
                         'min_child_weight': (1, 5), 'n_estimators': (50, 200),
                         'sub_sample': (0.5, 1)})

gs.best_params_

{'colsample_bytree': 1,
 'gamma': 1,
 'learning_rate': 0.01,
 'max_depth': 10,
 'min_child_weight': 5,
 'n_estimators': 50,
 'sub_sample': 0.5}

params = gs.best_params_
xgb = XGBClassifier(random_state=42, **params)
xgb.fit(train_input,train_target)
xgb.score(train_input,train_target)

[15:47:29] WARNING: C:/buildkite-agent/builds/buildkite-windows-cpu-autoscaling-group-i-0fc7796c793e6356f-1/xgboost/xgboost-ci-windows/src/learner.cc:767: 
Parameters: { "sub_sample" } are not used.

0.8016

그리드 서치를 통해 params의 범위를 지정 후 탐색 한 후 가장 높은 점수를 얻은 최적의

하이퍼 파라미터 조합을 사용해 XGB Classifier을 사용했다

예측 성공률은 80%가 나왔다.

처음 돌린것 치고 괜찮은것 같다.

XGB를 다시 사용하고,

 그리드서치를 베이지안 옵티마이저로 변경하여 하이퍼 파라미터만 바꿔서 다시 돌려보자.

from sklearn.model_selection import cross_val_score
# Define the hyperparameters and their ranges to be optimized
params = {'max_depth': (3, 10),
          'learning_rate': (0.01, 1),
          'n_estimators': (50, 200),
          'min_child_weight': (1, 5),
          'subsample': (0.5, 1),
          'gamma': (0, 1),
          'colsample_bytree': (0.1, 1)}

# Define the objective function to be optimized by Bayesian Optimization
def xgb_cv(max_depth, learning_rate, n_estimators, min_child_weight, subsample, gamma, colsample_bytree):
    xgb.set_params(max_depth=int(max_depth),
                   learning_rate=learning_rate,
                   n_estimators=int(n_estimators),
                   min_child_weight=int(min_child_weight),
                   subsample=subsample,
                   gamma=gamma,
                   colsample_bytree=colsample_bytree)
    return cross_val_score(xgb, train_input, train_target, cv=5, scoring='accuracy').mean()

# Define the Bayesian Optimization object
xgbBO = BayesianOptimization(xgb_cv, params)

# Optimize the hyperparameters using Bayesian Optimization
xgbBO.maximize(n_iter=50, init_points=5)

# Print the best hyperparameters and their corresponding score
print(xgbBO.max)

베이지안 옵티마이저 ( 하이퍼 파라미터 탐색 (서치)) 는 그리드와 다르게

함수를 따로 설정해줘야 하는것 같다. def xgb_cv :

하이퍼 파라미터를 입력으로 가져가서 XGB 분류기의 교차 검증된 정확도 점수를 반환하는

"xgb_cv"라는 목적 함수를 정의한다.

목적 함수는 sikit-learn의 "cross_val_score" 함수를 사용하여 5배 교차 검증을 수행한다.

그런 다음 "xgbB"라는 베이지안 최적화 개체를 만든다."  목적 함수와 하이퍼 파라미터를 인수로 전달한다.

우리는 베이지안 최적화를 사용하여 하이퍼 파라미터를 최적화하기 위해

베이지안 최적화 객체의 "최대화" 방법을 부른다.

마지막으로 베이지안 최적화 개체의 "max" 속성을 사용하여 최상의 하이퍼 파라미터와 해당 점수를 print한다.

 탐색 과정 보기

|   iter    |  target   | colsam... |   gamma   | learni... | max_depth | min_ch... | n_esti... | subsample |
-------------------------------------------------------------------------------------------------------------
| 1         | 0.6103    | 0.6987    | 0.1225    | 0.1515    | 8.224     | 2.78      | 88.54     | 0.8106    |
| 2         | 0.5686    | 0.6152    | 0.4665    | 0.6057    | 4.602     | 4.858     | 83.59     | 0.7877    |
| 3         | 0.5669    | 0.6712    | 0.5453    | 0.9401    | 7.787     | 1.631     | 84.9      | 0.7387    |
| 4         | 0.5202    | 0.2059    | 0.7044    | 0.0881    | 7.868     | 2.342     | 148.1     | 0.916     |
| 5         | 0.5641    | 0.518     | 0.08341   | 0.9347    | 6.403     | 2.885     | 142.2     | 0.9287    |
| 6         | 0.7503    | 0.7642    | 0.2208    | 0.01476   | 7.224     | 2.787     | 89.72     | 0.7512    |
| 7         | 0.6741    | 0.6956    | 0.2691    | 0.04304   | 7.473     | 2.803     | 90.27     | 0.7354    |
| 8         | 0.6111    | 0.3772    | 0.1156    | 0.1722    | 6.862     | 2.909     | 89.46     | 0.5736    |
| 9         | 0.5589    | 0.996     | 0.3121    | 0.7178    | 6.272     | 1.441     | 197.7     | 0.9347    |
| 10        | 0.7438    | 1.0       | 0.2819    | 0.01      | 7.435     | 2.692     | 89.73     | 0.888     |
| 11        | 0.6028    | 0.935     | 0.7813    | 0.3266    | 7.275     | 2.008     | 89.35     | 0.9696    |
| 12        | 0.5586    | 0.8707    | 0.4239    | 0.9497    | 7.755     | 2.939     | 90.22     | 0.8634    |
| 13        | 0.7199    | 0.9006    | 0.3698    | 0.03016   | 7.438     | 2.105     | 90.24     | 0.5563    |
| 14        | 0.5978    | 0.6174    | 0.7405    | 0.2071    | 7.302     | 2.448     | 89.83     | 0.9597    |
| 15        | 0.6238    | 0.5315    | 0.3929    | 0.05831   | 5.405     | 1.407     | 139.3     | 0.9426    |
| 16        | 0.5623    | 0.9584    | 0.5933    | 0.7928    | 5.375     | 2.849     | 173.5     | 0.8334    |
| 17        | 0.5706    | 0.5806    | 0.2061    | 0.8379    | 8.009     | 3.695     | 96.87     | 0.5719    |
| 18        | 0.6091    | 0.969     | 0.6108    | 0.5672    | 8.644     | 4.891     | 123.8     | 0.7119    |
| 19        | 0.5499    | 0.4206    | 0.9338    | 0.9778    | 4.152     | 2.256     | 142.6     | 0.8824    |
| 20        | 0.6901    | 0.685     | 0.01052   | 0.03924   | 7.289     | 2.735     | 90.7      | 0.5096    |
| 21        | 0.6047    | 0.6388    | 0.07058   | 0.1224    | 6.596     | 2.135     | 90.52     | 0.6906    |
| 22        | 0.7596    | 1.0       | 0.05041   | 0.01      | 7.305     | 2.524     | 89.87     | 0.5584    |
| 23        | 0.5822    | 0.8653    | 0.4866    | 0.3237    | 7.976     | 1.363     | 90.84     | 0.9786    |
| 24        | 0.5978    | 0.9655    | 0.1968    | 0.2951    | 7.567     | 2.518     | 89.95     | 0.505     |
| 25        | 0.6135    | 0.7961    | 0.8492    | 0.1947    | 7.032     | 1.907     | 90.26     | 0.5117    |
| 26        | 0.5785    | 0.2114    | 0.9544    | 0.9256    | 6.561     | 4.046     | 93.02     | 0.9875    |
| 27        | 0.5724    | 0.3869    | 0.213     | 0.126     | 8.753     | 1.661     | 195.6     | 0.9378    |
| 28        | 0.6228    | 0.7242    | 0.4029    | 0.1495    | 6.745     | 3.011     | 90.32     | 0.6581    |
| 29        | 0.6012    | 0.6911    | 0.2479    | 0.5442    | 7.269     | 2.962     | 89.39     | 0.6084    |
| 30        | 0.5546    | 0.2324    | 0.2779    | 0.3053    | 7.547     | 2.212     | 90.49     | 0.5984    |
| 31        | 0.5579    | 0.8693    | 0.7293    | 0.5319    | 7.034     | 2.044     | 90.46     | 0.6849    |
| 32        | 0.7332    | 0.7667    | 0.3579    | 0.02248   | 7.386     | 1.447     | 89.73     | 0.8661    |
| 33        | 0.5915    | 0.9329    | 0.4795    | 0.7687    | 7.461     | 1.033     | 89.7      | 0.9438    |
| 34        | 0.5662    | 0.2785    | 0.8665    | 0.6453    | 8.654     | 2.789     | 160.3     | 0.7509    |
| 35        | 0.6073    | 0.7983    | 0.1568    | 0.4487    | 6.283     | 3.771     | 160.9     | 0.886     |
| 36        | 0.521     | 0.1814    | 0.7958    | 0.09026   | 9.277     | 4.778     | 134.8     | 0.8938    |
| 37        | 0.6261    | 0.4929    | 0.6858    | 0.05002   | 7.517     | 1.226     | 89.75     | 0.9839    |
| 38        | 0.5979    | 0.6657    | 0.7642    | 0.2697    | 6.881     | 1.312     | 89.71     | 0.6174    |
| 39        | 0.7503    | 0.9457    | 0.07201   | 0.01      | 7.16      | 2.515     | 89.88     | 0.8681    |
| 40        | 0.7575    | 1.0       | 0.0       | 0.01      | 7.228     | 2.885     | 89.85     | 0.7391    |
| 41        | 0.6132    | 0.7363    | 0.1436    | 0.3085    | 7.023     | 2.021     | 89.61     | 0.5638    |
| 42        | 0.624     | 0.891     | 0.06212   | 0.1219    | 7.22      | 3.854     | 90.19     | 0.883     |
| 43        | 0.5767    | 0.7601    | 0.25      | 0.2714    | 7.582     | 1.709     | 89.91     | 0.9229    |
| 44        | 0.614     | 0.3562    | 0.5391    | 0.214     | 7.684     | 3.257     | 91.44     | 0.5431    |
| 45        | 0.6106    | 0.6325    | 0.3444    | 0.1795    | 7.056     | 2.479     | 91.33     | 0.6597    |
| 46        | 0.7557    | 0.8779    | 0.2409    | 0.0188    | 5.539     | 4.755     | 93.72     | 0.755     |
| 47        | 0.6015    | 0.5372    | 0.0837    | 0.1466    | 7.103     | 2.961     | 89.7      | 0.9337    |
| 48        | 0.581     | 0.9351    | 0.1166    | 0.4818    | 9.327     | 1.28      | 78.47     | 0.5416    |
| 49        | 0.5762    | 0.599     | 0.5343    | 0.6791    | 4.135     | 4.219     | 50.72     | 0.7866    |
| 50        | 0.609     | 0.3763    | 0.9039    | 0.2149    | 5.726     | 4.672     | 79.75     | 0.7045    |
| 51        | 0.5929    | 0.37      | 0.6496    | 0.7564    | 4.512     | 3.833     | 190.0     | 0.6005    |
| 52        | 0.6017    | 0.9499    | 0.5243    | 0.5982    | 5.635     | 4.218     | 94.03     | 0.5944    |
| 53        | 0.6108    | 0.8254    | 0.2186    | 0.1845    | 6.988     | 2.436     | 90.58     | 0.6205    |
| 54        | 0.5652    | 0.5436    | 0.9611    | 0.901     | 8.289     | 3.423     | 79.72     | 0.751     |
| 55        | 0.5876    | 0.7708    | 0.5102    | 0.7385    | 5.594     | 3.223     | 153.1     | 0.5488    |
=============================================================================================================
{'target': 0.7596307692307692, 'params': {'colsample_bytree': 1.0, 'gamma': 0.050406580268173413, 'learning_rate': 0.01, 'max_depth': 7.305157214715147, 'min_child_weight': 2.5238667272883433, 'n_estimators': 89.87424334757735, 'subsample': 0.5583965007292178}}

params = xgbBO.max['params']
params['max_depth'] = int(round(params['max_depth']))
params['n_estimators'] = int(round(params['n_estimators']))
params['gamma'] = int(round(params['gamma']))
params['min_child_weight'] = int(round(params['min_child_weight']))
xgb = XGBClassifier(random_state = 42, **params)
xgb.fit(train_input, train_target)



XGBClassifier(base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=1.0, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=0, gpu_id=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=0.01, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=7, max_leaves=None,
              min_child_weight=3, missing=nan, monotone_constraints=None,
              n_estimators=90, n_jobs=None, num_parallel_tree=None,
              predictor=None, random_state=42, ...)

score를 출력해보자.

xgb.score(train_input, train_target)	

0.8045538461538462

RMS Prop    /      ADAM

출처 : https://velog.io/@cha-suyeon/DL-%EC%B5%9C%EC%A0%81%ED%99%94-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-RMSProp-Adam

지수 가중 이동 평균

예시는 런던의 1년 일별 기온입니다.

θ1,...,365​로 표현이 되었고 그래프에 파란색 점으로 찍혔습니다.

그리고 지수 가중 이동 평균을 구합니다.

식은 오른쪽을 참고하시면 되고

이전 기온의 지수가중이동평균에 0.9를 곱하고, 현재 기온에는 0.1을 곱합니다.

이전 값에 더 많은 가중치(0.9)를 주고, 현재 기온에는 0.1이라는 작은 가중치를 주는 방식입니다.

Vt​=β∗Vt−1​+(1−β)θt​

vt​는 $\frac{1}{1−β} 기간 동안 기온의 평균을 의미합니다.

• β=0.9일 때 10일의 기온 평균
• β=0.5일 때 2일의 기온 평균

그러나 곡선이 올바른 값에서 더 멀어집니다. 그래서 기온이 바뀔 경우 지수가중평균 공식은 더 느리게 적응합니다.

β가 0.98이면 이전 값에 많은 가중치를 주고, 현재의 기온에는 작은 가중치를 주게 됩니다.

따라서 기온이 올라가거나 내려가는데 더 느리게 반응하게 됩니다.

만약 β값을 0.5로 낮춘다면 1−β1​ 식에 따라 2일의 기온을 평균내는 것과 같습니다.

그렇다면 2일의 기온만 평균내서 더 노이즈가 많고 이상치에 민감한 형태가 됩니다. 기온 변화에는 더 빠르게 적응을 하게 됩니다.

Vt​=β∗Vt−1​+(1−β)θt​

이 식은 Exponentially Weighted Averages(지수가중이동평균)이라 부르며,

parameter 혹은 학습 알고리즘의 hyper parameter 값을 바꾸면서 달라지는 효과를 얻게 되고 이를 통해 가장 잘 작동하는 값을 찾게 됩니다.

여기서 β 값이 hyper parameter 값입니다. 보통 사용하는 값은 0.9 입니다.

이렇게 희한하게 계산되는 지수가중이동평균은 왜 쓰일까요?

지수가중이동평균은 최근 데이터에 더 많은 영향을 받는 데이터들의 평균 흐름을 계산하기 위해 구합니다. 그리고 최근 데이터 지점에 더 높은 가중치를 줍니다.

갑자기 최적화 알고리즘 공부하기 전, 지수가중이동평균을 공부한 이유는 RMSProp에서 쓰이기 때문입니다.

RMSProp

RMSProp은 AdaGrad에서 학습이 안 되는 문제를 해결하기 위해 hyper parameter인 β가 추가되었습니다.

변화량이 더 클수록 학습률이 작아져서 조기 종료되는 문제를 해결하기 위해 학습률 크기를 비율로 조정할 수 있도록 제안된 방법입니다.

RMSProp은 최근 경로의 곡면 변화량을 측정하기 위해 지수가중이동평균을 사용합니다.

RMSProp의 장점은 미분값이 큰 곳에서는 업데이트 할 때 큰 값으로 나눠주기 때문에 기존 학습률 보다 작은 값으로 업데이트 됩니다.

따라서 진동을 줄이는데 도움이 됩니다.

반면 미분값이 작은 곳에서는 업데이트시 작은 값으로 나눠주기 때문에 기존 학습률 보다 큰 값으로 업데이트 됩니다.

이는 조기 종료를 막으면서도 더 빠르게 수렴하는 효과를 불러옵니다.

따라서 최근 경로의 gradient는 많이 반영되고 오래된 경로의 gradient는 작게 반영됩니다.

gradient 제곱에 곱해지는 가중치가 지수승으로 변화하기 때문에 지수가중평균이라 부릅니다.

매번 새로운 gradient 제곱의 비율을 반영하여 평균을 업데이트 하는 방식입니다.

Adam

드디어 마지막 Adam입니다!

Adam은 Momentum과 RMSProp이 합쳐진 형태입니다.

진행하던 속도에 관성도 주고, 최근 경로의 곡면의 변화량에 따른 적응적 학습률을 갖는 알고리즘입니다.

'관성' + '적응적 학습률' = Adam

Momentum처럼 진행하던 속도에 관성을 주고, RMSProp과 같이 학습률을 적응적으로 조정하는 알고리즘

이 방법은 모멘텀이 있는 경사 하강법의 효과와 RMSProp이 있는 경사 하강법의 효과를 합친 결과가 나옵니다.

이것은 매우 넓은 범위의 아키텍처를 가진 서로 다른 신경망에서 잘 작동한다는 것이 증명되었습니다.

그래서 일반적 알고리즘에서 현재 가장 많이 사용되고 있습니다.

이 알고리즘은 출발 지점에서 멀리 떨어진 곳으로 이동하는 초기 경로의 편향 문제가 있는 RMSProp의 단점을 제거하였습니다.

천천히 살펴보겠습니다.

개념

• 1차 관성으로 속도를 계산합니다. 속도에 마찰 계수 ρ 대신에 가중치 β1​을 곱해서 gradient의 지수가중이동평균을 구하는 형태로 수정되었습니다.
• 2차 관성으로 (gradient)2의 지수가중이동평균을 구합니다.
• 마지막은 parameter 업데이트 식으로 1, 2차 관성을 사용합니다.

초기 경로에서 편향이 발생하는 이유

훈련을 시작할 때 1차 관성 v0​, 2차 관성 r0​ 모두 0으로 초기화합니다.

이 상태에서 첫 번째 단계를 시행하면

각각 0.1, 0.01이 곱해져서 값이 작아집니다.

r1​이 작아지면 적응적 학습률이 커져 출발 지점에서 멀리 떨어진 곳으로 이동하게 되고,

최적해에 도달하지 못할 수도 있습니다.

그래서 도입한 방법이 해당 방법입니다. 이렇게 알고리즘을 개선했을 때,

식이 상쇄되기 때문에 r1​은 (gradient)2이 되어 아주 작아질 일이 없습니다.

이 방법으로 학습 초반에 학습률이 급격히 커지는 편향이 제거되고, 훈련이 진행될 수록 (1−β1t​)와 $(1-\beta^t_2)는 1에 수렴하므로 원래 알고리즘 형태로 돌아옵니다.

수식에 대한 이해가 어렵다면 그냥 넘어가도 될듯 하옵니다.

hyperparameter

이때까지 본 optimizer와 비교해서 Adam이 가장 특별한 점은 이 hyper parameter 값이 많다는 점인데요.

하나씩 살펴보겠습니다.

• α:학습률. 매우 중요하고 보정될 필요가 있으므로 다양한 값을 시도해서 잘 맞는 값을 찾아야 합니다.
• β1​: 기본적으로 0.9를 사용. 모멘텀에 관한 항
• β1​: 기본적으로 0.99나 0.999를 이용(논문에서는 0.999를 추천)
• ϵ: Adam 논문에서는 10−8을 추천. 분모가 0이 되는 것을 막기 위해 더해주는 상수. 하지만 이 값을 설정하지 않아도 전체 성능에는 영향이 없습니다.

보통 β1​, β2​, ϵ의 세 가지 값은 고정 시켜두고, α을 여러 값을 시도해가면서 가장 잘 작동되는 최적의 값을 찾습니다.

Adam은 Adaptive moment estimation에서 온 용어입니다.

β1​이 도함수의 평균을 계산하므로 첫 번째 momentum이고,

β2​는 지수가중평균의 제곱을 계산하므로 두 번째 momentum입니다.

이 모두를 Adma optimizer algorithm라 부릅니다.

베이지안 최적화 

- 용도 : 하이퍼파라미터 최적해 찾기 ( 엑셀 해찾기 기능)

베이지안 최적화를 보기 전, 파라미터와 하이퍼 파라미터를 다시 생각해보자.

파라미터는 데이터를 통해 구해지며, 모델 내부적으로 결정되는 값이다.

예를 들면 , 한 클래스에 속해 있는 학생들의 키에 대한 정규분포를 그린다고 해보자. 정규분포를 그리면 평균(μ)과 표준편차(σ) 값이 구해지는데, 여기서 평균과 표준편차를 파라미터(parameter)라고 한다.

하이퍼 파라미터는 모델링할 때 사용자가 직접 세팅해주는 값을 뜻한다.

하이퍼 파라미터는 정해진 최적의 값이 없다. 휴리스틱한 방법이나 경험 법칙(rules of thumb)에 의해 결정하는 경우가 많다.

변수(입력 데이터)가 5개 있다고 가정했을 때, 변수1의 값을 설정해놓고, 변수 2, 3,4...이렇게 찾는것이 아니다.

변수 1의 최적값은 변수 2의 값이 바뀌면 또 바뀐다. 따라서 변수들을 동시에 바꿔가며 최적의 값을 찾는 것이다.

이렇게 최적값을 찾는것은 매우 복잡하고 시간이 오래 걸리는 작업이므로 해결하기 위한 방법들이 있다.

1. 그리드 서치

그리드 서치는 하이퍼 파라미터의 최적값을 교차 검증을 통해 찾아준다. (그리드 서치를 사용하면 cross_validate를 따로 호출 할 필요가 없다.)

그리드 서치에 대한 자세한 설명은 참조 : https://woghkszhf.tistory.com/10

• 즉, 모든 parameter의 경우의 수에 대해 cross-validation 결과가 가장 좋은 parameter를 고르는 방법이다.
• 전체 탐색 대상 구간을 어떻게 설정할지, 간격은 어떻게 설정할지 등을 결정하는 데 있어 여전히 사람의 손이 필요하나
• 앞선 Manual Search와 비교하면 좀 더 균등하고 전역적인 탐색이 가능하다는 장점이 있다.
• 하지만 탐색하고자하는 hyperparameter의 개수를 한 번에 여러 종류로 가져갈수록, 전체 탐색 시간이 기하급수적으로 증가한다는 단점이 있다.

2. 랜덤 서치

• Random Search는 Grid Search와 큰 맥락은 유사하나
• 탐색 대상 구간 내의 후보 hyperparameter 값들을 랜덤 샘플링을 통해 선정한다는 점이 다르다.
• Random Search는 Grid Search에 비해 불필요한 반복 수행 횟수를 대폭 줄이면서, 동시에 정해진 간격(grid) 사이에 위치한 값들에 대해서도 확률적으로 탐색이 가능하므로, 최적 값을 더 빨리 찾을 수 있는 것으로 알려져 있다.
• 즉, 랜덤서치는 모든 grid를 전부 찾는 대신, 랜덤하게 일부의 파라미터 들만 관측한 후, 그 중에서 가장 좋은 파라미터를 고른다.
• 그리드 서치는 중요한/ 안중요한 파라미터들을 동일하게 관측해야하기 때문에, 정작 중요한 파라미터를 다양하게 시도해볼 수 있는 기회가 적지만
• 랜덤서치는 grid로 제한되지 않기 때문에 확률적으로 중요 변수들을 더 살펴볼 수 있는 기회를 받게 됩니다.
• 그럼에도 불구하고, 랜덤 서치에서도 '여전히 약간의 불필요한 탐색을 반복하는 것 같다’는 느낌을 지우기 어려우실 것이라고 생각합니다.
• 왜냐하면 그리드 서치와 랜덤 서치 모두, 바로 다음 번 시도할 후보 hyperparameter 값을 선정하는 과정에서, 이전까지의 조사 과정에서 얻어진 하이퍼파라미터 값들의 성능 결과에 대한 ‘사전 지식’이 전혀 반영되어 있지 않기 때문입니다.
• 매 회 새로운 하이퍼 파라미터 값에 대한 조사를 수행할 시 ‘사전 지식’을 충분히 반영하면서, 동시에 전체적인 탐색 과정을 체계적으로 수행할 수 있는 방법론으로, 베이지안 옵티마이저를 들 수 있습니다.

3. 베이지안 옵티마이저

• Bayesian Optimization 은 어느 입력값(x)를 받는 미지의 목적 함수(f(x))를 상정하여,
• 해당 함숫값(f(x))을 최대로 만드는 최적해를 찾는 것을 목적으로 합니다.
  • 즉, 목적 함수(탐색대상함수)와 하이퍼파라미터 쌍(pair)을 대상으로 Surrogate Model(대체 모델) 을 만들고,
  • 순차적으로 하이퍼 파라미터를 업데이트해 가면서 평가를 통해 최적의 하이퍼파라미터 조합을 탐색합니다.
  • 이 때의 목점 함수를 black-box function 이라고 합니다.
• Bayesian Optimization 에는 두 가지 필수 요소가 존재합니다.
  • 먼저 Surrogate Model 은, 현재까지 조사된 입력값-함숫결과값 점들 (x1, f(x1)),...,(xt, f(xt)) 을 바탕으로, 미지의 목적 함수의 형태에 대한 확률적인 추정을 수행하는 모델을 지칭합니다.
  • 그리고 Acquisition Function 은, 목적 함수에 대한 현재까지의 확률적 추정 결과를 바탕으로, ‘최적 입력값을 찾는 데 있어 가장 유용할 만한’ 다음 입력값 후보를 추천해 주는 함수를 지칭합니다.

Bayesian Optimization 수행 과정

• 자세한 수행 과정
  1. 입력값, 목적 함수 및 그 외 설정값들을 정의한다.
     • 입력값 x : 여러가지 hyperparameter
     • 목적 함수 f(x) : 설정한 입력값을 적용해 학습한, 딥러닝 모델의 성능 결과 수치(e.g. 정확도)
     • 입력값 x 의 탐색 대상 구간 : (a,b)
     • 입력값-함숫결과값 점들의 갯수 : n
     • 조사할 입력값-함숫결과값 점들의 갯수 : N
  2. 설정한 탐색 대상 구간 (a,b) 내에서 처음 n 개의 입력값들을 랜덤하게 샘플링하여 선택한다.
  3. 선택한 n 개의 입력값 x1, x2, ..., xn 을 각각 모델의 하이퍼 파라미터로 설정하여 딥러닝 모델을 학습한 뒤, 학습이 완료된 모델의 성능 결과 수치를 계산한다.
     • 이들을 각각 함숫결과값 f(x1), f(x2), ..., f(xn) 으로 간주한다.
  4. 입력값-함숫결과값 점들의 모음 (x1, f(x1)), (x2, f(x2)), ..., (xn, f(xn)) 에 대하여 Surrogate Model(대체 모델) 로 확률적 추정을 수행합니다.
  5. 조사된 입력값-함숫결과값 점들이 총 N 개에 도달할 때까지, 아래의 과정을 반복적으로 수행한다.
     • 기존 입력값-함숫결과값 점들의 모음 (x1, f(x1)),(x2, f(x2)), ..., (xt, f(xt)) 에 대한 Surrogate Model (대체 모델)의 확률적 추정 결과를 바탕으로, 입력값 구간 (a,b) 내에서의 EI 의 값을 계산하고, 그 값이 가장 큰 점을 다음 입력값 후보 x1 로 선정한다.
     • 다음 입력값 후보 x1 를 hyperparameter 로 설정하여 딥러닝 모델을 학습한 뒤, 학습이 완료된 모델의 성능 결과 수치를 계산하고, 이를 f(x1) 값으로 간주한다.
     • 새로운 점 (x2, f(x2)) 을 기존 입력값-함숫결과값 점들의 모음에 추가하고, 갱신된 점들의 모음에 대하여 Surrogate Model 로 확률적 추정을 다시 수행한다.
  6. 총 N 개의 입력값-함숫결과값 점들에 대하여 확률적으로 추정된 목적 함수 결과물을 바탕으로, 평균 함수 μ(x) 을 최대로 만드는 최적해를 최종 선택합니다. 추후 해당값을 하이퍼파라미터로 사용하여 딥러닝 모델을 학습하면, 일반화 성능이 극대화된 모델을 얻을 수 있다.

데이콘 FIFA 선수 이적료 예측 모델 만드는 대회에서

XGBoost와 베이지안 옵티마이저를 사용했는데, 그 당시에는 베이지안 옵티마이저에 대해 몰랐었지만, 공부하며 알아보니 신기하고 재밌었다. 오늘 일기끝