ASAC 36일차_머신러닝 6일차

24.01.19

목표

Random Forest, XGB, LGBM 모델의 baseline 모델을 확인하고

Grid Search, Random Grid Search 를 활용하여 하이퍼 파라미터 튜닝을 진행한다. 

 

1. Random Forest

- Baseline 확인

from sklearn.ensemble import RandomForestClassifier

# RF의 bawseline 확인
rf = RandomForestClassifier(n_jobs=-1, random_state=1234)
scores = cross_val_score( rf,
                         X_train,y_train,
                          cv=kfold,
                          scoring="accuracy",
                          )

for iter_count, acc in enumerate(scores):
    print("RF의 {0}번째 검증 ACC:{1:4f}".format(iter_count, acc ))
print("RF 모델의 Accuracy Mean:", scores.mean())
print("RF 모델의 Accuracy std:", scores.std())

# 결과
RF의 0번째 검증 ACC:0.811189
RF의 1번째 검증 ACC:0.846154
RF의 2번째 검증 ACC:0.788732
RF의 3번째 검증 ACC:0.760563
RF의 4번째 검증 ACC:0.830986
RF 모델의 Accuracy Mean: 0.8075248694967005
RF 모델의 Accuracy std: 0.030379537772527453

 

- Random Grid Search 적용

# RGS

#1) 모델
rf = RandomForestClassifier(n_jobs=-1, random_state=1234)

#2) 변경해보고 싶은 파라미터들의 조합
parameters = {
            "n_estimators" : [10, 30, 50, 70, 100,200,300,500,1000,2000],
            "max_features" : [3,4,5,6,7,8,9,10,20],
            "max_depth" : [2,3,4,5,6,7,8,9,10,20],
            "min_samples_leaf": [1,3,5,7,9],
       		 }

#3) RGS에 적용 
n_liter = 20 

#4) RGS에 모델 생성
rf_kfold_rgs = RandomizedSearchCV(rf, 
                                param_distributions = parameters, 
                                cv=kfold,
                                scoring = 'accuracy', 
                                n_jobs= -1, 
                                random_state=1234,
                                n_iter = n_iter)

#5) 실제 데이터 밀어 넣기
rf_kfold_rgs.fit(X_train, y_train)

# 결과 확인

rf_kfold_rgs.best_score_
=> 0.8285728356150891

rf_kfold_rgs.best_params_
=> {'n_estimators': 70, 'min_samples_leaf': 3, 'max_features': 6, 'max_depth': 8}


# 참고) numpy에서 랜덤값 추출 방법
np.random.randint( low=10, high=2000, size=10)

# RGS로 찾은 모델이 baseline보다 좋은지 확인하기 위해
# x_val 데이터로 모델 평가 진행

rf_kfold_rgs_best = rf_kfold_rgs.best_estimator_
rf_kfold_rgs_ypred = rf_kfold_rgs_best.predict(X_val)
rf_kfold_rgs_acc = accuracy_score(y_val, rf_kfold_rgs_ypred)
rf_kfold_rgs_acc
=> 0.8324022346368715

X_val.shape
=> (179, 8)

 

- Grid Search 적용

# GS

# 1) 모델
rf = RandomForestClassifier(n_jobs=-1, random_state=1234)

# 2) 변경해보고 싶은 파라미터들의 조합
parameters = {
    "n_estimators" : [1000, 500],
    "max_features" : [5,6,7],
    "max_depth": [9,10,11], 
    "min_samples_leaf": [2,3,4] 
}

# 4) GS에 모델 생성
rf_kfold_gs = GridSearchCV( rf,
                           param_grid=parameters,
                           cv=kfold,
                           scoring="accuracy",
                           n_jobs= -1)
                           
# 5) 실제 데이터를 밀어 넣기
rf_kfold_gs.fit(X_train, y_train)

# 결과
rf_kfold_gs.best_score_
=> 0.8285728356150891

rf_kfold_gs_best = rf_kfold_gs.best_estimator_
rf_kfold_gs_ypred = rf_kfold_gs_best.predict(X_val)
rf_kfold_gs_acc = accuracy_score(y_val, rf_kfold_gs_ypred)
rf_kfold_gs_acc
=> 0.8324022346368715

rf_kfold_gs.best_params_
=> {'max_depth': 9,
 'max_features': 6,
 'min_samples_leaf': 3,
 'n_estimators': 1000}

# 참고) 정답 제출 방식
rf_kfold_gs_best.predict(X_val)
rf_kfold_gs_best.predict_proba(X_val) # 확률로 표기

 

RF모델의 성능 평가

base: 0.81

RGS: 0.83

GS: 0.83

 

구글 코랩상에서 돌아가는 한계 + 시간 문제 때문에 많이 돌려본 것은 아니지만

조금만 했는데도 base 모델보다 미세하게 성능이 높아진 것을 확인할 수 있었습니다. 

---

추가) 모델 저장하는 법

모델을 저장하고 불러오는 방법

1. Joblib패키지 활용

import joblib

# 1) 모델 저장하기: joblib.dump(어떤모델, 어디 저장)
joblib.dump(rf_kfold_gs_best, "rf_kfold_gs_best.pkl")

# 2) 받은 모델 불러오기: joblib.load(불러올 모델의 경로, 파일명)
model_path = "/content/rf_kfold_gs_best.pkl"
rf_kfold_backup_model = joblib.load(model_path)

# 잘 불러졌는지 확인
rf_kfold_backup_model.predict(X_val)
(rf_kfold_backup_model.predict(X_val) == rf_kfold_gs_best.predict(X_val)).sum()

 

2. pickle 패키지 활용

# case1) 모델을 저장하는 사람
import pickle
filename = "my_model.pkl"
pickle.dump(rf_kfold_gs_best, open(filenmae, 'wb'))

# case2) 모델을 받아서 여는 사람
import pickle
new_momdel = pickle.load(open(받은 모델의 경로_파일명_확장자pkl, 'rb'))

 

---

2. XGBoost

- Baseline 확인

from xgboost import XGBClassifier
xgbc = XGBClassifier(n_jobs_=1, random_dtate = 1234


# xgboost로 baseline 확인
xgbc = XGBClassifier(n_jobs=-1, random_state=1234)
scores = cross_val_score( xgbc,
                         X_train,y_train,
                          cv=kfold,
                          scoring="accuracy",
                          n_jobs=-1)
print(scores)

for iter_count, acc in enumerate(scores):
    print("XGboost의 {0}번째 검증 ACC:{1:4f}".format(iter_count, acc ))
print("XGboo 모델의 Accuracy Mean:", scores.mean())
print("RF 모델의 Accuracy std:", scores.std())

 

xgboost의 기본 baseline : 0.799 ~ 0.80 으로 RF와 baseline 거의 유사하게 나타난다. 
# xgboost는 RF 보다는 조금 더 variance가 낮은 것 같다. 

 

- Random Grid Search 적용

# xgboost의 RGS
xgbc = XGBClassifier(n_jobs =-1, random_state = 1234)

# 테스트할 파라미터들
parameters = {
    	"n_estimators" : [10, 30, 50, 100, 300, 500],
		"learning_rate": [0.01, 0.1, 0.2, 40, 100, 300, 500],
		"max_depth":[2,3,4,5,6,10], 
		"gamma" : [0, 0.1, 0.2, 0.3],  
		"subsample" : [0.3, 0.4, 0.5, 0.6, 0.9],
		"colsample_bytree" : [0.3, 0.4, 0.5, 0.6, 0.9],  
		"reg_alpha" : [0, 0.01, 0.1, 0.3],
		"reg_lambda" : [0, 0.01, 0.1, 0.3]
}

# 랜덤하게 뽑을 경우의 수
n_liter = 80

# RGS
xgb_kfold_rgs = RandomizedSearchCV(xgbc,
                                    param_distributions = parameters, 
                                    cv = kfold, 
                                    scoring='accuracy',
                                    n_jobs = -1, 
                                    random_state=1234, 
                                    n_iter=n_iter)
xgb_kfold_rgs.fit(X_train, y_train)

# 결과
xgb_kfold_rgs.best_score_
xgb_kfold_rgs.best_params_
=> 0.82~

xgb_kfold_rgs_best = xgb_kfold_rgs.best_estimator_
xgb_kfold_rgs_ypred = xgb_kfold_rgs.predict(X_val)
xgb_kfold_rgs_acc = accuracy_score(y_val, xgb_kfold_rgs_ypred)
xgb_kfold_rgs_acc
=> 0.798~

xgb_kfold_rgs.best_params_
# --> 이 파라미터 주변을 좀 더 탐색을 해볼 것 같음!!!!

 

모델 성능이 0.82 로 높아지긴 했는데

예측이 0.798인것으로 보아 약간 overfit에 걸렸다는 것을 유추해볼 수 있다. 

 

- Grid Search 적용

# GrdiSearch Xgboost
xgbc = XGBClassifier( n_jobs=-1, random_state=1234)

# test
parameters ={
    "n_estimators": [40, 45, 50, 55, 100],
    "learning_rate":[0.01, 0.05, 0.1, 0.15],
    "max_depth" :[4,5,6],
    "gamma":[0, 0.1, 0.05, 0.15],
    "subsample": [0.4, 0.3, 0.5],
    "colsample_bytree":[0.4, 0.5, 0.6],
    "reg_alpha": [0.01,0,0.02],
    "reg_lambda":[0.1, 0, 0.05, 0.15]
}

# gridsearch - model
xgb_kfold_gs = GridSearchCV(xgbc,
                            param_grid=parameters,
                            cv=kfold,
														scoring='accuracy',
														n_jobs =-1)
                             )

# 주어진 train에 적용
xgb_kfold_gs.fit(X_train, y_train)

# 결과
xgb_kfold_gs.best_score_
=> 0.8384418398502905

xgb_kfold_gs.best_params_
=> {'colsample_bytree': 0.5,
 'gamma': 0,
 'learning_rate': 0.1,
 'max_depth': 5,
 'n_estimators': 100,
 'reg_alpha': 0.01,
 'reg_lambda': 0.1,
 'subsample': 0.4}

xgb_kfold_gs_best = xgb_kfold_gs.best_estimator_
xgb_kfold_gs_ypred = xgb_kfold_gs_best.predict(X_val)
xgb_kfold_gs_acc = accuracy_score(y_val, xgb_kfold_gs_ypred)
xgb_kfold_gs_acc

=> 0.7932960893854749

 

GS 또한 학습에서 0.83인데 검증에서 0.79로 나온 것으로 약간 overfit한 모습을 보인다. 

 

xgb 모델의 성능 평가

base: 0.81

RGS: 0.82

GS: 0.83

---

3. LightGBM

- baseline 확인

from lightgbm import LGBMClassifier

lgbc = LGBMClassifier(n_jobs=-1, random_state=1234)
scores = cross_val_score( lgbc,
                         X_train,y_train,
                          cv=kfold,
                          scoring="accuracy",
                          n_jobs=-1)
print(scores)

for iter_count, acc in enumerate(scores):
    print("LGBM의 {0}번째 검증 ACC:{1:4f}".format(iter_count, acc ))
print("LGBM 모델의 Accuracy Mean:", scores.mean())
print("LGBM 모델의 Accuracy std:", scores.std())

- Random Grid Search 적용

# RGS
lgbc = LGBMClassifier(n_jobs=-1, random_state=1234)
parameters = {
        "n_estimators" : [ 10, 30, 50, 100, 300, 500],
        "learning_rate":[0.01, 0.03, 0.05, 0.07, 0.1, 0.3],
        "max_depth":[-1, 2, 3, 5, 7, 10],
        "min_split_gain":[0, 0.1, 0.2], 
        "subsample":[0.3, 0.4, 0.5, 0.6],
		"colsample_bytree": [0.3, 0.4, 0.5, 0.6],
		"reg_alpha" : [0, 0.01, 0.1, 0.3],
		"reg_lambda" : [0, 0.01, 0.1, 0.3]
}

# 몇 개를 뽑을 지
n_liter = 60

# rgs 모델 세팅
lgbm_kfold_rgs = RandomizedSearchCV(
	lgbc, param_distributions = parameters, cv=kfold, n_jobs=-1,
	scoring='accuracy', random_state=1234, n_iter = n_iter)

# 실제 학습 데이터에 적용
lgbm_kfold_rgs.fit(X_train, y_train)

# 결과
lgbm_kfold_rgs.best_score_

lgbm_kfold_rgs_best = lgbm_kfold_rgs.best_estimator_
lgbm_kfold_rgs_ypred = lgbm_kfold_rgs.predict(X_val)
lgbm_kfold_rgs_acc = accuracy_score(y_val, lgbm_kfold_rgs_ypred)
lgbm_kfold_rgs_acc
=> 0.8268156424581006

 

RF, Xgboost와 동일하게 RGS나 GS를 통해 HPT를 진행한다. 

 

---

Voting

앙상블 기법 중 Voting을 코드로 적용하는 법도 배워보자

 

- 방법1) 직접 다수결을 판단하는 함수를 만들어서 진행

- 방법2) scikit-learn에 있는 것을 가져다 사용

 

1. Hard voting

from sklearn.ensemble import VotingClassifier

# HardVoting

hard_clf = VotingClassifier(

    estimators= [
        ("RF", rf_kfold_gs_best),     
        ("XGB", xgb_kfold_gs_best),
        ("LGBM", lgbm_kfold_rgs_best) 
    ],

    voting="hard"
)

hard_clf.fit(X_train, y_train)
hard_clf_ypred = hard_clf.predict(X_val)
hard_clf_acc = accuracy_score(y_val, hard_clf_ypred)
hard_clf_acc

 

2. Soft voting

# 지분율 : lightGBm 2, xg : 1
soft_clf = VotingClassifier(
    estimators= [
        ("XGB", xgb_kfold_gs_best),
        ("LGBM", lgbm_kfold_rgs_best)
    ],

    voting="soft",
    weights=[1, 2]  # 가중치 적용
)

soft_clf.fit(X_train, y_train)
soft_clf_ypred = soft_clf.predict(X_val)
soft_clf_acc = accuracy_score(y_val, soft_clf_ypred)
soft_clf_acc