[네이버클라우드캠프] 16일차. 하이퍼파라미터 튜닝 및 주요 개념 소개 (AI GridSearchCV, Bagging, Voting에 대한 설명과 코드

 

하이퍼파라미터 튜닝

 

1. 그리드서치

• 하이퍼파라미터 튜닝 : 임의의 값들을 넣어 더 나은 결과를 찾는 방식
→ 수정 및 재시도하는 단순 작업의 반복
• 그리드 서치 : 수백 가지 하이퍼파라미터값을 한번에 적용 가능
• 그리드 서치의 원리 : 입력할 하이퍼파라미터 후보들을 입력한 후, 

각 조합에 대해 모두 모델링해보고 최적의 결과가 나오는 하이퍼파라미터 조합을 확인

예)
max_depth = [3, 5, 10]
Learning_rate = [0.01, 0.05, 0.1]

1. XGBoost 모델의 parmeters

참조 공식문서 https://xgboost.readthedocs.io/en/stable/parameter.html

2. LightGBM 모델의 parmeters
참조 공식문서 https://lightgbm.readthedocs.io/en/latest/Parameters-Tuning.html

3. Catboost 모델의 parmeters
참조 공식문서 https://catboost.ai/en/docs/concepts/python-reference_catboost_grid_search

---

2. 아웃라이어 x (Outliers)

 

• IQR은 사분위 값의 편차를 이용하여 이상치를 걸러내는 방법
• 전체 데이터를 정렬하여 이를 4등분하여 Q1(25%), Q2(50%), Q3(75%),Q4(100%) 중 IQR는 Q3 - Q1 가 됨

---

3. 배깅 (Bagging)

 

• Bagging은 Bootstrap Aggregation의 약자
• 배깅은 샘플을 여러 번 뽑아 (Bootstrap) 각 모델을 학습시켜 결과물을 집계 (Aggregration) 하는 방법
• 즉, 데이터로부터 부트스트랩 한 데이터로 모델을 학습시키고 학습된 모델의 결과를 집계하여 최종 결과 값을 도출

---

4. 보팅 (Voting)

 

• Voting은 일반적으로 서로 다른 알고리즘을 가진 분류기를 결합하는 것
(참고 : 배깅의 경우 각각의 분류기가 모두 같은 유형의 알고리즘을 기반으로 함)
• 하드 보팅: 각 분류기의 예측 결과를 단순히 다수결(majority voting)로 결정
• 소프트 보팅: 각 분류기의 예측 확률을 평균하여 예측을 수행

---

https://dev-with-gpt.tistory.com/59

파이썬 AI GridSearchCV, Bagging, Voting에 대한 설명과 코드

 

1. GridSearchCV

 

[설명]

GridSearchCV는 사용자가 지정한 매개변수 그리드를 기반으로 모든 가능한 조합의 하이퍼파라미터를 탐색하여 최적의 조합을 찾는 과정을 자동으로 수행합니다.
매개변수 그리드 탐색, 교차 검증, 성능 평가 및 최적 모델 선택 등의 작업을 자동화하여 
모델의 최적화된 성능을 얻을 수 있도록 도와줍니다. 
이를 통해 사용자는 모델의 성능을 향상시키는 최적의 하이퍼파라미터 조합을 찾는 데 집중합니다.

 

[코드]

#그리드서치
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
from sklearn.model_selection import cross_val_score, cross_validate, cross_val_predict
from sklearn.preprocessing import MinMaxScaler
from sklearn.utils import all_estimators
from sklearn.metrics import r2_score, accuracy_score
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier


import warnings
warnings.filterwarnings('ignore')

# 1. 데이터 준비
datasets = load_iris()
x = datasets.data
y = datasets.target

# 학습용 데이터와 테스트용 데이터로 분할
x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.8, shuffle=True, random_state=42 # validation data 포함
)

# k-fold 교차검증을 위한 설정
n_splits = 5
random_state=42
kfold = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state)

# 데이터 스케일링
scaler = MinMaxScaler()
scaler.fit(x_train)
x = scaler.transform(x)
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

# 2. 모델 최적의 파라미터를 찾는 과정
from sklearn.model_selection import GridSearchCV

# RandomForestClassifier 모델과 파라미터 그리드 설정
rf_model = RandomForestClassifier()
param = [
    {'n_estimators' : [100, 200], 'max_depth' : [6,8,10,12], 'n_jobs' : [-1, 2, 4]},
    {'max_depth' : [6,8,10,12], 'min_samples_leaf' : [2,3,5,10]}
]

model = GridSearchCV(rf_model, param, cv=kfold, verbose=1, refit=True, n_jobs=-1) 

# 3. 모델 훈련과 평가
import time
start_time = time.time()
model.fit(x_train, y_train)
end_time = time.time() - start_time

# 최적의 파라미터와 매개변수, 그리고 스코어 출력
print('최적의 파라미터 : ', model.best_params_)
print('최적의 매개변수 : ', model.best_estimator_)
print('best_score : ', model.best_score_)
print('model_score : ', model.score(x_test, y_test))
print('걸린 시간 : ', end_time)

 

[주석]

n_estimators는 100과 200의 두 가지 값을 가지고 있으며, 이는 랜덤 포레스트에 사용될 트리의 개수입니다.

max_depth는 6, 8, 10, 12의 네 가지 값을 가지고 있으며, 트리의 최대 깊이를 지정합니다.

n_jobs는 병렬 처리에 사용될 CPU 코어의 개수를 지정하는데, -1은 가능한 모든 코어를 사용하고, 2와 4는 각각 2개와 4개의 코어를 사용한다는 의미입니다.

max_depth와 min_samples_leaf는 분석하려는 문제와 데이터에 따라 적절한 값으로 조정해야 합니다.

min_samples_leaf는 트리의 분할을 결정하는 데 필요한 최소 샘플 수를 의미합니다.

매개변수 값의 선택은 경험과 실험을 통해 결정되며, 모델의 성능과 일반화 능력을 고려해야 합니다.
적절한 값은 문제와 데이터의 특성에 맞게 조정되어야 하며, 여러 실험을 통해 최적의 조합을 찾을 수 있습니다.

 

[출력]

---

XGBoost 모델의 parmeters

 

    'n_estimators': [100], #default 100 / 1~inf(무한대) / 정수
    'learning_rate' : [0.1, 0.01], #default 0.3/ 0~1 / learning_rate는 eta라고 해도 적용됨
    'max_depth' : [3,4,5],#default 3/ 0~inf(무한대) / 정수 => 소수점은 정수로 변환하여 적용해야 함
    'gamma': [3], #default 0 / 0~inf
    'min_child_weight': [0.01,1,5], #default 1 / 0~inf
    'subsample' : [0.1,0.2], #default 1 / 0~1
    'colsample_bytree' : [0,0.1], #default 1 / 0~1
    'colsample_bylevel' : [0.1,0.2,0.3,0.5,0.7,1], #default 1 / 0~1
    'colsample_bynode' : [0,0.1], #default 1 / 0~1
    'reg_alpha' : [0.1], #default 0 / 0~inf / L1 절대값 가중치 규제 / 그냥 alpha도 적용됨
    'reg_lambda' : [1]

n_estimators: 트리의 개수, 기본값은 100입니다. 정수값을 사용하며, 1부터 무한대까지 가능합니다.
learning_rate: 학습률, 기본값은 0.3입니다. 0부터 1 사이의 실수값입니다.
max_depth: 트리의 최대 깊이, 기본값은 3입니다. 정수값을 사용하며, 0부터 무한대까지 가능합니다.
gamma: 트리 노드 분할을 위한 최소 손실 감소, 기본값은 0입니다. 0 이상의 실수값입니다.
min_child_weight: 리프 노드를 추가로 분할하기 위한 최소 가중치 합, 기본값은 1입니다. 0 이상의 실수값입니다.
subsample: 각 트리마다 사용될 훈련 데이터의 비율, 기본값은 1입니다. 0부터 1 사이의 실수값입니다.
colsample_bytree: 각 트리마다 사용될 특성의 비율, 기본값은 1입니다. 0부터 1 사이의 실수값입니다.
colsample_bylevel: 각 레벨에서 사용될 특성의 비율, 기본값은 1입니다. 0부터 1 사이의 실수값입니다.
colsample_bynode: 각 노드에서 사용될 특성의 비율, 기본값은 1입니다. 0부터 1 사이의 실수값입니다.
reg_alpha: L1 정규화 항의 가중치, 기본값은 0입니다. 0 이상의 실수값입니다.
reg_lambda: L2 정규화 항의 가중치, 기본값은 1입니다. 0 이상의 실수값입니다.

---

 LightGBM 모델의 parmeters

 

대체로 XGBoost와 하이퍼 파라미터들이 비슷하지만 leaf-wise 방식의 하이퍼 파라미터가 존재함
num_leaves : 하나의 트리가 가질 수 있는 최대 리프 개수
min_data_in_leaf : 오버피팅을 방지할 수 있는 파라미터, 큰 데이터셋에서는 100이나 1000 정도로 설정
feature_fraction : 트리를 학습할 때마다 선택하는 feature의 비율
n_estimators : 결정 트리 개수
learning_rate : 학습률
reg_lambda : L2 규제
reg_alpha : L1규제
max_depth : 트리 개수 제한

---

 Catboost 모델의 parmeters

 

CatBoost 평가 지표 최적화에 가장 큰 영향을 미치는 하이퍼파라미터는 
learning_rate, 
depth, 
l2_leaf_reg 및
random_strength
learning_rate: 학습률
depth: 각 트리의 최대 깊이로 과적합을 제어
l2_leaf_reg: L2 정규화(regularization) 강도로, 과적합을 제어
colsample_bylevel: 각 트리 레벨에서의 피처 샘플링 비율
n_estimators: 생성할 트리의 개수
subsample: 각 트리를 학습할 때 사용할 샘플링 비율
border_count: 수치형 특성 처리 방법
ctr_border_count: 범주형 특성 처리 방법

---

2. Bagging (GridSearchCV 기반)

 

Bagging 모델의 parmeters

[설명]

배깅은 Bootstrap Aggregating의 줄임말로, 
중복을 허용한 샘플링(부트스트래핑)을 통해 각각의 모델을 학습시키고, 
이들의 예측 결과를 앙상블하여 최종 예측 결과를 도출합니다.

배깅은 다양한 분류기나 회귀 모델과 함께 사용할 수 있으며, 과적합(Overfitting)을 감소시키고 
일반화 성능을 향상시키는 효과가 있습니다. 
또한, 분산을 줄여 안정적인 예측 결과를 얻을 수 있습니다.

 

Bagging 분류모델의 BaggingRegressor

 

[코드]

import numpy as np
from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.ensemble import BaggingClassifier, BaggingRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import MinMaxScaler

import time

#1. 데이터
datasets = fetch_california_housing()
x = datasets.data
y = datasets.target

x_train, x_test, y_train, y_test = train_test_split(
    x,y, test_size = 0.2 , shuffle = True, random_state=42
)

# sclar
scaler = MinMaxScaler()

x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

#kfold
n_splits = 5
kfold = KFold(n_splits=n_splits, shuffle=True, random_state=42)

param = {
    'n_estimators' : [100],
    'random_state' : [42, 62, 72],
    'max_features' : [3, 4, 7]
}


# 모델 (Bagging)
bagging = BaggingRegressor(DecisionTreeRegressor(),
                            n_estimators=100,
                            n_jobs=-1,
                            random_state=42)
model = GridSearchCV(bagging, param, cv=kfold, refit=True, n_jobs=-1)

#3. 훈련
start_time = time.time()
model.fit(x_train, y_train)
end_time = time.time() - start_time

#4. 평가예측
result = model.score(x_test, y_test)

print('최적의 파라미터 : ', model.best_params_)
print('최적의 매개변수 : ', model.best_estimator_)
print('best_score : ', model.best_score_)
print('model_score : ', model.score(x_test, y_test))
print('걸린 시간 : ', end_time, '초')
print('Bagging 결과 : ', result)

# 최적의 파라미터 :  {'max_features': 7, 'n_estimators': 100, 'random_state': 42}
# 최적의 매개변수 :  BaggingRegressor(estimator=DecisionTreeRegressor(), max_features=7,
#                  n_estimators=100, n_jobs=-1, random_state=42)
# best_score :  0.8201272150909134
# model_score :  0.822087951242456
# 걸린 시간 :  55.286494970321655 초
# Bagging 결과 :  0.822087951242456

 

[출력]

 

---

Bagging 분류모델의 BaggingClassifier

 

[코드]

import numpy as np
from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler

import time

#1. 데이터
datasets = load_iris()
x = datasets.data
y = datasets.target

x_train, x_test, y_train, y_test = train_test_split(
    x,y, test_size = 0.2 , shuffle = True, random_state=42
)

# sclar
scaler = MinMaxScaler()

x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

#kfold
n_splits = 5
kfold = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)

param = {
    'n_estimators' : [100],
    'random_state' : [42, 62, 72],
    'max_features' : [3, 4, 7]
}


# 모델 (Bagging)
bagging = BaggingClassifier(DecisionTreeClassifier(),
                            n_estimators=100,
                            n_jobs=-1,
                            random_state=42)
model = GridSearchCV(bagging, param, cv=kfold, refit=True, n_jobs=-1)

#3. 훈련
start_time = time.time()
model.fit(x_train, y_train)
end_time = time.time() - start_time

#4. 평가예측
result = model.score(x_test, y_test)

print('최적의 파라미터 : ', model.best_params_)
print('최적의 매개변수 : ', model.best_estimator_)
print('best_score : ', model.best_score_)
print('model_score : ', model.score(x_test, y_test))
print('걸린 시간 : ', end_time, '초')
print('Bagging 결과 : ', result)

# 최적의 파라미터 :  {'max_features': 4, 'n_estimators': 100, 'random_state': 42}
# 최적의 매개변수 :  BaggingClassifier(estimator=DecisionTreeClassifier(), max_features=4,
#                   n_estimators=100, n_jobs=-1, random_state=42)
# best_score :  0.95
# model_score :  1.0
# 걸린 시간 :  2.366288423538208 초
# Bagging 결과 :  1.0

 

 

[출력]

 

---

3. Voting

 

[설명]

앙상블 학습이라고도 하는 투표는 여러 모델(분류자 또는 회귀자)을 결합하여 예측 또는 결정을 내리는 기계 학습의 기술입니다. 여러 모델의 예측을 결합하면 종종 단일 모델을 사용하는 것보다 전반적인 성능이 향상될 수 있다는 생각을 기반으로 합니다.

하드 보팅(Hard Voting): 하드 보팅에서는 앙상블의 각 모델이 예측을 하고 최종 예측은 다수결로 결정됩니다. 분류 작업에서 다수의 투표를 받은 클래스가 최종 예측으로 선택됩니다. 회귀 작업에서 예측 값의 평균 또는 중앙값이 최종 예측으로 사용됩니다.

소프트 보팅: 소프트 보팅에서 앙상블의 각 모델은 각 클래스 또는 대상 값에 확률 또는 신뢰도 점수를 할당합니다. 이러한 확률 또는 점수는 모든 모델에서 평균화되며 평균 확률 또는 점수가 가장 높은 클래스 또는 대상 값이 최종 예측으로 선택됩니다. 소프트 보팅은 각 모델의 신뢰도 또는 확실성 수준을 고려합니다.

 

fetch_california_housing, VotingRegressor

 

[코드]

import numpy as np
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.datasets import fetch_california_housing
from sklearn.ensemble import VotingClassifier, VotingRegressor
from sklearn.metrics import accuracy_score, r2_score
from xgboost import XGBClassifier, XGBRegressor
from lightgbm import LGBMClassifier, LGBMRegressor
from catboost import CatBoostClassifier, CatBoostRegressor
import warnings
warnings.filterwarnings('ignore')

#1. 데이터
datasets = fetch_california_housing()
x = datasets.data
y = datasets.target

x_train, x_test, y_train, y_test = train_test_split(
    x, y, test_size= 0.2 , shuffle=True, random_state=42
)

scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

#2. 모델
xgb = XGBRegressor()
cat = CatBoostRegressor()
lgbm = LGBMRegressor()


model = VotingRegressor(
    estimators=[('xgb', xgb), ('lgbm',lgbm), ('cat', cat)], 
    n_jobs=-1
)

#3. 훈련
model.fit(x_train, y_train)

#4. 평가, 예측

regressors = [cat, xgb, lgbm]
for model in regressors:
    model.fit(x_train, y_train)
    y_predict = model.predict(x_test)
    score = r2_score(y_test, y_predict)
    class_names = model.__class__.__name__
    print('{0} 정확도 : {1: .4f}'.format(class_names, score))


# CatBoostClassifier 정확도 :  1.0000
# XGBClassifier 정확도 :  1.0000
# LGBMClassifier 정확도 :  1.0000

 

[출력]

 

load_iris, VotingClassifier

 

[코드]

import numpy as np
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.datasets import load_iris
from sklearn.ensemble import VotingClassifier, VotingRegressor
from sklearn.metrics import accuracy_score, r2_score
from xgboost import XGBClassifier, XGBRegressor
from lightgbm import LGBMClassifier, LGBMRegressor
from catboost import CatBoostClassifier, CatBoostRegressor
import warnings
warnings.filterwarnings('ignore')

#1. 데이터
datasets = load_iris()
x = datasets.data
y = datasets.target

x_train, x_test, y_train, y_test = train_test_split(
    x, y, test_size= 0.2 , shuffle=True, random_state=42
)

scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

#2. 모델
xgb = XGBClassifier()
cat = CatBoostClassifier()
lgbm = LGBMClassifier()


model = VotingClassifier(
    estimators=[('xgb', xgb), ('lgbm',lgbm), ('cat', cat)], 
    n_jobs=-1
)

#3. 훈련
model.fit(x_train, y_train)

#4. 평가, 예측

regressors = [cat, xgb, lgbm]
for model in regressors:
    model.fit(x_train, y_train)
    y_predict = model.predict(x_test)
    score = r2_score(y_test, y_predict)
    class_names = model.__class__.__name__
    print('{0} 정확도 : {1: .4f}'.format(class_names, score))


# CatBoostClassifier 정확도 :  1.0000
# XGBClassifier 정확도 :  1.0000
# LGBMClassifier 정확도 :  1.0000

 

[출력]

 

---

4. 배깅(Bagging)

 

[설명]

배깅(Bagging)은 앙상블 학습 방법 중 하나로, 동일한 기본 모델(예: 결정 트리)을 여러 개 사용하여 각각의 모델을 개별적으로 학습시킨 후 그 결과를 결합하여 예측하는 방법입니다. 이렇게 함으로써 모델의 성능과 안정성을 향상시킬 수 있습니다.

 

[코드]

import numpy as np
from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.ensemble import BaggingClassifier, BaggingRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import MinMaxScaler

import time

#1. 데이터
datasets = fetch_california_housing()
x = datasets.data
y = datasets.target

x_train, x_test, y_train, y_test = train_test_split(
    x,y, test_size = 0.2 , shuffle = True, random_state=42
)

# sclar
scaler = MinMaxScaler()

x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

#kfold
n_splits = 5
kfold = KFold(n_splits=n_splits, shuffle=True, random_state=42)

param = {
    'n_estimators' : [100],
    'random_state' : [42, 62, 72],
    'max_features' : [3, 4, 7]
}


# 모델 (Bagging)
bagging = BaggingRegressor(DecisionTreeRegressor(),
                            n_estimators=100,
                            n_jobs=-1,
                            random_state=42)
model = GridSearchCV(bagging, param, cv=kfold, refit=True, n_jobs=-1)

#3. 훈련
start_time = time.time()
model.fit(x_train, y_train)
end_time = time.time() - start_time

#4. 평가예측
result = model.score(x_test, y_test)

print('최적의 파라미터 : ', model.best_params_)
print('최적의 매개변수 : ', model.best_estimator_)
print('best_score : ', model.best_score_)
print('model_score : ', model.score(x_test, y_test))
print('걸린 시간 : ', end_time, '초')
print('Bagging 결과 : ', result)

# 최적의 파라미터 :  {'max_features': 7, 'n_estimators': 100, 'random_state': 42}
# 최적의 매개변수 :  BaggingRegressor(estimator=DecisionTreeRegressor(), max_features=7,
#                  n_estimators=100, n_jobs=-1, random_state=42)
# best_score :  0.8201272150909134
# model_score :  0.822087951242456
# 걸린 시간 :  55.286494970321655 초
# Bagging 결과 :  0.822087951242456

 

[출력]