[The Based Models 4] Model Tuning

🌀 Hyperparmeter Tuning

알고리즘을 사용하여 모델링 할 때 최적화하기 위해 조절해보자.

튜닝에 정답은 없음 !!! 

 

Tuning의 기본 요소

1. 튜닝 대상 모델 
2. 범위
3. 조합 선택 방법 ex) random 선택, exhaustive(모든 조합시도)
4. 검증 방법 ex) cross validation , validation set 제공 등
5. scoring metric (명확히 정의하지 않으면, 의도하지 않은 하이퍼파리미터 조합이 선택될 수 있다.) : metric 값이 가장 우수한 hyperparameter 조합 선택!

 

직접 튜닝

다른 툴들 사용하기 전, 하이퍼파라미터 범위 등에 대해 대략적으로 감을 잡기 위해 필수적인 과정

추천 방법

1. hyperparameter들을 default값으로 두고, 3개 이내의 중요한 hyperparmeter를 바꿔가며 성능 변화 확인
2. 대다수의 hyperparam들이 모델의 복잡성과 관련된 것이다. 과적합 / 과소적합의 여부를 확인하고, 모델의 복잡성을 조절한다.

 

 

Exhaustive Grid Search

파라미터 값 범위를 모두 사용하는 grid serach 모델 선언 후 학습, 가장 좋은 성능을 보인 파라미터 값으로 자동 학습.

시간은 오래걸려도 마음은 편하지..

from sklearn.model_selection import GridSearchCV
from category_encoders import OrdinalEncoder
from xgboost import XGBClassifier
from sklearn.pipeline import make_pipeline

# pipeline 구성
pipe = make_pipeline(OrdinalEncoder(),
                     SimpleImputer(strategy='median'),
                     XGBClassifier(objective='binary:logistic',
                                   eval_metric='error',
                                   n_estimators=200,
                                   learning_rate=0.1,
                                   use_label_encoder=False,
                                   n_jobs=-1))

# 매개변수 꼭 범위를 dict 형태로 선언!!
params = {'xgbclassifier__max_depth':[2,4,6],
          'xgbclassifier__min_child_weight':[2,4,6],
          'xgbclassifier__colsample__bytree':[0.6,0.8,1.0]}

grid_search = GridSearchCV(pipe,
                           param_grid=parms, 
                           scoring='roc_auc', # 평가지표(default:accuracy)
                           cv=3, # k-fold cv (default:cv=5)
                           verbose=3) # 학습과정 표시 정도
                           
grid_search.fit(x_train, y_train)
grid_search.best_params_ # 최적의 하이퍼파라미터
>> {'xgbclassifier__colsample_bytree': 0.6, 'xgbclassifier__max_depth': 4, 'xgbclassifier__min_child_weight': 4}

grid_search.best_score_ # 최적 AUC
>> 0.8204

# 수행시, grid_search는 최적의 하이퍼파라미터로 자동 학습이 완료된 모델이다.

# 특성 중요도 확인시, grid_search.best_estimator_ 이용
tmp = pd.DataFrame()
tmp['feature'] = list(x_train)
tmp['importance'] = grid_search.best_estimator_[1].feature_importances_
tmp.sort_values(by='importance', inplace=True)

plt.barh(y=tmp['feature'], width=tmp['importance']);

 

 

Randomized Search

파라미터 값 범위에서 몇 개 선택할 지 정하여 random search 모델 선언 후 학습, 가장 좋은 성능을 보인 파라미터 값으로 자동 학습.

빨리 할 수 있지만, 운에 맡기는 느낌..

cross validation 방법으로 탐색 진행

하이퍼파라미터 범위로 값을 지정해줄 수도 있고, scipy.stats의 분포로도 지정 가능

설정해주는 하이퍼파라미터의 범위는 넓지만, fitting은 설정해 준 n_iter만큼만 진행됨.

# 이번엔, pipeline 사용안하고 해보자
from scipy.stats.distributions import uniform
from sklearn.model_selection import RandomizedSearchCV

# 파라미터 딕셔너리 선언
param = {'strategy':['median','mean'],
         'max_depth':[2,4,6],
         'min_child_weight':[2,4,8],
         'colsample_bytree':uniform(loc=0.5, scale=0.5)} # 0.5-1사이의 uniform 분포로 범위 지정

# 기본 모델 선언
dst_model = DesicionTreeClassifier()

# random search 선언
model = RandomizedSearchCV(dst_model,
                           param,
                           cv=3, 
                           n_iter=20, # 20개 뽑아냄
                           scoring='accuracy') 
# default값이라도 써주는 게 좋다. 한눈에 알기 위해서.
# 분류시 accuracy, 회귀시 r2 잊지 말기!

model.fit(x_train, y_train)

# 수행 정보
model.cv_results_
# 최적 파라미터 
model.best_params_
# 최고 성능
model.best_scores_

random으로 했는데 6 나왔으면, 6 주위값만 이용해 grid search 수행
수상하면, 그 근처값을 grid search 해줄 수 있는 방법도 써먹어보자!

 

 

Bayesian Search

이전에 탐색한 조합들의 성능을 기반으로 성능이 잘 나오는 조합들을 중심으로 확률적으로 탐색

sklearn에서는 이 기능 제공하지 않으며, hyperpot 라이브러리에서 제공하는 stochastic expresssions로 지정해줘야함.

자주 사용하는 expression들

• hp.choice(label, options) : 리스트나 튜플 형태의 선택지 중 하나 선택
• hp.randint(label, upper) : [0,upper]범위 내의 정수값 랜덤 선택
• hp.uniform(label, low, high) : [low, high]범위 내의 실수값 랜덤 선택
• hp.quniform(label, low, high, q) : [low,high]사이 균등 분포에서 q간격의 일정 시점들로부터 랜덤 선택
• hp.normal(label, mu, sigma) : 평균 mu, 표준편차 sigma를 갖는 정규분포로부터 실수값 랜덤 선택
• 자세한 내용은 여기를 참고

from hyperopt import hp, fmin, tpe, Trials, STATUS_OK
from sklearn.model_selection import cross_val_score

params = {'simpleimputer__strategy': hp.choice('strategy', ['median','mean']),
          'xgbclassifier__max_depth': hp.quniform('max_depth', 2, 10, 2),
          'xgbclassifier__min_child_weight': hp.quniform('min_child_weight',2,10,2),
          'xgbclassifier__colsample_bytree': hp.uniform('colsample_bytree', 0.5,1.0)}


# hyperopt 라이브러리 사용 시 학습 및 검증 함수 직접 작성해줘야함.
def get_pipe(params):
    # max_depth는 정수형으로 변환
    parmas['xgbclassifier__max_depth'] = int(parmas['xgbclassifier__max_depth']
    pipe = make_pipeline(OrdinalEncoder(),
                         SimpleImputer(strategy='median'),
                         XGBClassifier(objective='binary:logistic',
                                       eval_metric='error',
                                       n_estimators=200,
                                       learning_rate=0.1,
                                       use_label_encoder=True,
                                       n_jobs=-1)
    pipe = pipe.set_parms(**params)
    return pipe

# 목적함수
def fit_and_eval(params):
    pipe = get_pipe(params) # 주어진 params로 파이프라인을 만들어 가져온다.
    # 성능 검증
    score = cross_val_score(pipe, x_train, y_train, cv=3, scoring='roc_auc')
    avg_cv_score = np.mean(score)
    # roc_auc는 클수록 좋은 metric이므로, hpyeropt.fmin이 roc_auc를 최대화하도록 하기위해
    # - 부호를 붙여 반환함.
    return {'loss': -avg_cv_score, 'status':STATUS_OK}

# 학습 정보 저장
trials = (Trials())

# 학습하기
best_parmas = fmin(fn=fit_and_eval, # 목적함수
                   trials=trials, # 시도한 입력 및 입력 결과 저장
                   space=params, # 검색 공간
                   ago=tpe.suggest, # 베이지안 최적화 적용 알고리즘
                   max_evals=10, # 시도횟수
                   rstate=np.random.default_rng(2023)) # 시도할때마다 동일한 결과를 록

trials.trials # 모든 trial 정보에 대해 직접 접근 가능
# Trials() 객체를 fmin에 함께 넣어 실행하면, 
# 실행되는 매 fit의 학습 정보 및 학습 결과가 해당 객체에 모두 저장됨

trials.best_trial['misc']['vals'] # 최적 파라미터
>> {'colsample_bytree': [0.6709747268729134], 'max_depth': [4.0],
 'min_child_weight': [8.0], 'strategy': [1]}

-trials.best_trial['result']['loss']) # 최적 AUC
>> 0.8491

이 과정을 반복하여, 최적의 하이퍼파라미터를 확인한다!

best_max_depth = int(best_params['max_depth']
best_min_child_weight = int(best_params['min_child_weight']
best_colsample_bytree = int(best_params['colsapmle_bytree']

# 최종의 모델 선언
best_search = make_pipeline(OrdinalEncoder(),
                            XGBClassifier(max_depth=best_max_depth,
                                          min_child_weight=best_min_child_weight,
                                          colsample_bytree=best_colsample_bytree))
# 학습하기
best_search.fit(x_train, y_train)

# 학습, 검증 성능 비교
y_pred_train = best_search.predict(x_train)

print("학습 f1-score", f1_score(y_train, y_pred_train))
print("검증 f1-score", -trials.best_trial['result']['loss'])
>> 학습 F1: 0.6106811145510836
검증 F1: 0.5818764879623988

hyperopt 라이브러리 사용 시 학습 및 검증 함수를 직접 작성해주어야함.

loss를 가장 작게 만들어주는 하이퍼파라미터 조합 선택, 클수록 좋은 metric의 경우 -부호를 붙여 반환해주어야함.

loss : -auc (hyperopt)

score : -mse (sklearn)

목적함수가 최소가 되도록 해야함. f1값은 클수록 좋은 것이니, score 에 -를 붙여서 리턴해주어, f1값은 키우고 있고 목적함수값은 작아지게 한다.

fmin : find minimum : 우리가 만든 목적함수의 최솟값이 될때까지 찾아라!

sckit learn은 random state로 지정해주면 되는데, 이것은 rstate로 따로 지정해줘야함.

 

 

 

 

---

🌀 특성 선택

데이터가 충분하지 않은 상황에서는 불필요한 특성이 과적합의 원인이 될 수 있음

중요하지 않은 column drop하며 특성 선택해보자!

 

특성 중요도 기반 특성 선택

선형회귀 기반 모델의 경우 coefficient를 통해 ,

트리 기반 모델의 경우 feature_importance를 통해 특성의 중요도 수치값 얻음.

→ 이를 기반으로, 특정 값 아래의 중요도를 갖는 특성들 drop시킬 수 있다.

train_sub, val = train_test_split(train, test_size=0.2, stratify=train[target], random_state=42)
X_train, y_train = train_sub.drop(columns=target), train_sub[target]
X_val, y_val = val.drop(columns=target), val[target]


pipe = make_pipeline(
    OrdinalEncoder(),
    SimpleImputer(strategy="mean"),
    XGBClassifier(
        objective="binary:logistic",
        eval_metric="auc",
        n_estimators=200,
        random_state=42,
        n_jobs=-1,
        max_depth=6,
        min_child_weight=6,
        colsample_bytree=0.7,
        learning_rate=0.1,
        use_label_encoder=False,
    ),
)

pipe.fit(X_train, y_train)
print("검증 AUC: ", pipe.score(X_val, y_val))
>> 검증 AUC:  0.8255248487723876

feature_importances = list(
    zip(X_train.columns, pipe.named_steps["xgbclassifier"].feature_importances_)
)
feature_importances = sorted(feature_importances, key=lambda x: x[1], reverse=True)

plt.figure(figsize=(10, 10), dpi=120)
plt.barh(*list(zip(*feature_importances[::-1])))
plt.axvline(0.015, color="red", linewidth=0.5)

특성 중요도가 0.015미만인 특성들 drop후 재학습

features_selected = list(filter(lambda x: x[1] >= 0.015, feature_importances))
print(features_selected)
selected_feature_names = list(map(lambda x: x[0], features_selected))

X_train_selected = X_train[selected_feature_names]
X_val_selected = X_val[selected_feature_names]

pipe = make_pipeline(
    OrdinalEncoder(),
    SimpleImputer(strategy="mean"),
    XGBClassifier(
        objective="binary:logistic",
        eval_metric="auc",
        n_estimators=200,
        random_state=42,
        n_jobs=-1,
        max_depth=6,
        min_child_weight=6,
        colsample_bytree=0.7,
        learning_rate=0.1,
        use_label_encoder=False,
    ),
)

pipe.fit(X_train_selected, y_train)
print("검증 AUC: ", pipe.score(X_val_selected, y_val))
print("특성 수:")
print("\tBefore: ", X_train.shape[1])
print("\tAfter: ", X_train_selected.shape[1])

>>
검증 AUC:  0.8255248487723876
특성 수:
    Before:  32
    After:  10

→ feature 개수가 적어져도, score은 비슷한 것 확인 가능!

차원개수적어져서 오히려 좋아!

 

통계량 기반 특성 선택

각 특성들과 타겟값 간의 통계량으로부터 각 특성의 영향력 추측해 낮은 영향력 갖는 특성들 제거

 

• 피어슨 상관계수
  • 연속형 특성, 연속형 타겟의 경우
  • np.corrcoef
  • 단점 : 두 특성 간의 선형 관계성만 확인 가능

 

• 스피어만 상관계수
  • 두 특성의 선형성이 아닌 단조성 보여줌. 즉, 한 특성이 커질 때 다른 특성이 함께 커지는지를 수치화해줌.
  • 각 특성의 값들을 그 값의 전체에서의 순위로 대치한 다음, 피어슨 상관계수를 구하는 것과 동일
  • scipy.stats.spearmanr

# 두 특성이 비선형 관계이지만, 단조 관계일 때 살펴보자
# y=x^3

x = np.random.normal(0,5,1000)
y = x**3+np.random.normal(0,1,1000)

plt.plot(x,y,'.')
print("Pearson Corrcoef:", np.corrcoef(x, y)[0, 1])
print("Spearman Corrcoef:", spearmanr(x, y))
>> Pearson Corrcoef: 0.7745216717448516
Spearman Corrcoef: SignificanceResult(statistic=0.9968557448557448, pvalue=0.0)

피어슨 / 스피어만 상관계수 통계량을 이용해, 타겟값과 통계량이 상위 k내에 드는 특성들만 선택하거나, 적절한 threshold를 지정하여 해당 값 이상의 통계량을 갖는 특성들만 학습에 이용 가능

sklearn.feature_selection.SelectKBest

문제의 유형(분류/회귀)에 따라 다양한 통계량을 기반으로 특성 선택할 수 있게함.

score_func을 바꿔줌으로써 서로 다른 통계량으로부터 특성 선택 가능

 

대표적인 몇 가지 통계량 옵션 (score_func)

분류/회귀 문제에 따라 적절한 옵션 선택해야함.

 

분류 타겟을 위한 옵션들

• f_classif
• mutual_info_classif
• chi2

회귀 타겟을 위한 옵션들

• f_regression
• mutual_info_regression

from category_encoders import OneHotEncoder

enc = OrdinalEncoder()
imp = SimpleImputer()

X_train_encoded = enc.fit_transform(X_train)
X_train_imputed = imp.fit_transform(X_train_encoded)

X_val_encoded = enc.transform(X_val)
X_val_imputed = imp.transform(X_val_encoded)

from sklearn.feature_selection import SelectKBest, mutual_info_classif

selector = SelectKBest(score_func=mutual_info_classif, k=6)
X_train_selected = selector.fit_transform(X_train_imputed, y_train)
X_val_selected = selector.transform(X_val_imputed)

# 선택된 특성
X_train_encoded.columns[selector.get_support()].tolist()
>> ['h1n1_knowledge', 'doctor_recc_h1n1', 'health_insurance', 'health_worker', 'opinion_h1n1_vacc_effective', 'opinion_h1n1_risk']

model = XGBClassifier(
    objective="binary:logistic",
    eval_metric="auc",
    n_estimators=200,
    random_state=42,
    n_jobs=-1,
    max_depth=6,
    min_child_weight=6,
    colsample_bytree=0.7,
    learning_rate=0.1,
    use_label_encoder=False,
)

model.fit(X_train_selected, y_train)
print("검증 AUC: ", model.score(X_val_selected, y_val))
print("특성 수:")
print("\tBefore: ", X_train.shape[1])
print("\tAfter: ", X_train_selected.shape[1])
>> 검증 AUC:  0.8268295575851026
특성 수:
    Before:  32
    After:  6

feature 개수가 6으로 줄었고, 성능은 아주조금 높아졌다! good!

 

More Study

• pipeline쓸때 / 안쓸때에 따라 코드 구분. (pipeline 쓰면 파라미터 딕셔너리 선언 시, 앞에 모델이름도 같이 써줘야함)
• 특성 중요도 확인 시, grid_search.best_estimator_ (이건 내부를 봐야대니께 불러오기)→ 최적의 파라미터가 쓰인 모델을 가져와야 feature imporatances 확인 가능

grid search가 가장 성능이 좋지만, 너무 느리다...

시간이 없다면 , random search!!나 베이지안 쓰기

베이지안은 당연히 grid보단 좋진 않지만, 성능이 막 좋진 않지만, 빠르다.
베이지안은 그리 많이 쓰이진 않는다고한다

인코딩, 스케일링은 train / test 분리 한 후에 해야함!!

why?

테스트용 데이터는 우리가 미래데이터이다. 우리에게 없다고 봐야한다.

테스트 데이터는 현재 데이터에 영향을 주면 안된다.

인코딩,스케일링을 규칙을 만든는 패턴에 평가용 데이터들이 같이 규칙패턴을 만들게 되면 안된다.

인코더, 스케일링 시 그 모델을 먼저 훈련데이터로 학습한 후, 그거를 기준으로 테스트데이터도 학습시킴.

 

 

 

하이퍼파라미터 튜닝에 사용하는 cv는 무엇을 의미하나?

이것도 cross validation으로, 튜닝 과정에서 찾은 조합을 하나의 데이터셋에 대해서만 성능을 평가해본다면 이 성능을 신뢰하기 어렵다.

• Ex 1) max_depth = 7 -> 하나의 데이터셋 사용 -> 정확도 0.9 -> 정확도가 엄청 높네!근데 이 결과를 믿을 수 있을까?
• Ex 2) max_depth = 7 -> cv=3 -> 3개의 데이터셋을 검증으로 사용 -> 정확도 각각 0.9, 0.7, 0.8 -> 평균 정확도 0.8 -> 정확도가 준수하고, 여러 번 검증해서 신뢰할 수 있겠다!

→ 튜닝 과정에서 찾은 조합을 CV로 여러 번 검증해 봄으로써 해당 조합이 어느 정도의 일반화 성능을 내는지 평가해볼 수 있다.

 

 

 

 

하이퍼파라미터 튜닝에 사용하는 scoring에는 어떤 평가지표를 사용해야 할까?

• 풀고자 하는 분류 문제에서 F1-score를 평가지표로 사용하고 있는데 튜닝 과정에서 scoring=accuracy 로 설정하면 어떻게 될까?
  • 우리는 튜닝을 통해 F1-score가 가장 높은 모델과 하이퍼파라미터 조합을 얻고 싶은 것인데 튜닝 후 도출된 결과는 정확도가 가장 높은 조합일 것이다.
• 따라서 튜닝에 사용하는 scoring 옵션에는 우리가 풀고 있는 문제에서 사용되는 가장 적합한 평가지표를 사용해주어야 한다.

하지만, 파라미터의 세밀한 조정으로 최적화된 성능을 얻었을지라도 운영환경에서는 성능이 꼭 보장되는 것은 아니다..

 

 

 

 

따라서..! 모델링 목표로는,

완벽한 적절한 예측력을 위해 적절한 복잡도의 모델을 완성하는 것이다!!!

[references]

• Sklearn: Tuning the hyper-parameters of an estimator
• Sklearn: Feature Selection
• Hyperopt: Distributed Asynchronous Hyper-parameter Optimization