[K-DIGITAL] 세미프로젝트2. 타이타닉 생존자 예측 모델 만들기(2)

멋쟁이사자처럼 X K-DIGITAL Training - 07.05

 

 

[이전] 2021.07.05 - [python/k-digital] - [K-DIGITAL] 세미프로젝트2. 타이타닉 생존자 예측 모델 만들기(1)

[K-DIGITAL] 세미프로젝트2. 타이타닉 생존자 예측 모델 만들기(1)

---

 

 

타이타닉 생존자 예측(2) 모델 앙상블과 성능 판단, HPO

 

라이브러리

import warnings 
warnings.filterwarnings(action='ignore')

from sklearn import linear_model
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from xgboost import XGBClassifier

from sklearn.metrics import accuracy_score
from vecstack import StackingTransformer
from sklearn.metrics import roc_curve, auc

 

5. Model Ensemble - Stacking

각 모델 정확도 하나의 데이터프레임으로 생성

accuracy_name = ['kNN', 'RF', 'SVC', 'LR', 'NB', 'XGB']
accuracy_list = list({accuracy_kNN, accuracy_RF, accuracy_SVC, accuracy_LR, accuracy_NB, accuracy_XGB})

accuracy_df = pd.DataFrame({'name': accuracy_name, 'accuracy': accuracy_list})

# 중복되서 들어가지 않은 값 따로 추가
accuracy_df = accuracy_df.append({'name': 'DT', 'accuracy': accuracy_DT}, ignore_index=True)

 

Stage 1-1. 모델 생성

# kNN / RF / SVC / LR / XGB
estimators = [
    ('KneighborsClassifier', KNeighborsClassifier(n_neighbors = 13)),
    ('RandomForest', RandomForestClassifier(random_state = 0, n_jobs = -1, n_estimators = 100, max_depth = 3)),
    ('SupportVectorClassifier', SVC()),
    ('LogisticRegression', linear_model.LogisticRegression()),
    ('XGB', XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1, n_estimators = 100, max_depth = 3))]

Stage 1-2. 모델 학습

from vecstack import StackingTransformer

stack = StackingTransformer(estimators, 
                            regression = False, 
                            metric = accuracy_score, 
                            n_folds = 4, stratified = True, shuffle = True, 
                            random_state = 0, verbose = 2) 
                            
stack = stack.fit(X_train, y_train)

Stage 1-3. S_train / S_test 생성

S_train = stack.transform(X_train)
S_test = stack.transform(X_test)

Stage 2. 다시 학습

from xgboost import XGBClassifier

# Stage 2. 
model = XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1, n_estimators = 100, max_depth = 3) 
model = model.fit(S_train, y_train) 
y_pred = model.predict(S_test) 

accuracy = accuracy_score(y_test, y_pred)

accuracy_df = accuracy_df.append({'name': 'Stacking_all', 'accuracy': accuracy}, ignore_index=True)

운이 좋게도 위에는 생략된 stacking(kNN / RF / XGB) 모델의 성능이 가장 높게 나왔다.

대게 데이터 양이 적은 경우 앙상블 기법을 적용했을 때 성능이 더 떨어진다고 한다.

실제로 다른 팀 중 스태킹을 적용했을 때 성능이 더 떨어진 팀들이 있었다!

 

 

6. Results Visualization

각 모델별 ROC Curve 좌표와 AUC

from sklearn.metrics import roc_curve, auc

xgb_fpr, xgb_tpr, _ = roc_curve(y_true=y_test, y_score=xgb_pred_test[:,1]) 
svc_fpr, svc_tpr, _3 = roc_curve(y_true=y_test, y_score=svc_pred_test[:,1])
knn_fpr, knn_tpr, _2 = roc_curve(y_true=y_test, y_score=knn_pred_test[:,1])
rf_fpr, rf_tpr, _4 = roc_curve(y_true=y_test, y_score=rf_pred_test[:,1])

xgb_roc_auc = auc(xgb_fpr, xgb_tpr)
svc_roc_auc = auc(svc_fpr, svc_tpr)
knn_roc_auc = auc(knn_fpr, knn_tpr)
rf_roc_auc = auc(rf_fpr, rf_tpr)

matplot 시각화

plt.figure(figsize=(10, 10))

plt.plot(xgb_fpr, xgb_tpr, color='orange', lw=2, label='XGB ROC curve (area = %0.2f)' % xgb_roc_auc)
plt.plot(svc_fpr, svc_tpr, color='red', lw=2, label='SVC ROC curve (area = %0.2f)' % svc_roc_auc)
plt.plot(knn_fpr, knn_tpr, color='green', lw=2, label='kNN ROC curve (area = %0.2f)' % knn_roc_auc)
plt.plot(rf_fpr, rf_tpr, color='blue', lw=2, label='RF ROC curve (area = %0.2f)' % rf_roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend(loc="lower right")
plt.title("ROC curve")

plt.show()

 

 

7. Hyper-parameters Optimization

* kNN은 깃 참고 (https://github.com/ijo0r98/likelion-kdigital/tree/main/semi-project-2)

ijo0r98/likelion-kdigital

 

* RandomForest 기준

 

7-1. GridSearch

 

잠재적 parameter들의 후보군들(특정 구간)의 파라미터 조합 중 가장 최적의 조합을 찾아주는 방법

하나하나 조합을 이뤄 대입해가며 확인해줌으로 후보군의 개수에 비례하여 시간이 늘어남, 시간이 오래 걸림

검색해야할 파라미터의 수가 많아질수록 조합의 수가 많아지고 검사가 길어짐으로 차원의 저주 에 빠질 수 있음

또한 구간마다 탐색을 수행하기 때문에 광역 최적해(global optinum)를 찾기 어려움

 

모델 파라미터 확인

clf_RF.get_params

최적의 파라미터 도출

from sklearn.model_selection import GridSearchCV

# parameter 설정
param_grid={'max_features': ['auto', 'sqrt'],
            'min_samples_leaf': [1, 2, 4],
            'n_estimators': [130, 180, 230]}

# GridSearch 설정
gs = GridSearchCV(clf_RF, param_grid, scoring='accuracy', fit_params=None, 
                n_jobs=-1, cv=k_fold, verbose=False)
# 모델 학습
gs.fit(X_train, y_train)

# 점수 및 최적 parameter 도출
gs_test_score = accuracy_score(y_test, gs.predict(X_test))

print("Best Accuracy {:.3f} params {}".format(gs.best_score_, gs.best_params_))

>> Best Accuracy 0.828 params {'max_features': 'auto', 'min_samples_leaf': 2, 'n_estimators': 180}

 

결과 시각화

gs_results_df=pd.DataFrame(np.transpose([gs.cv_results_['mean_test_score'],
                                         gs.cv_results_['param_max_features'].data,
                                         gs.cv_results_['param_min_samples_leaf'].data,
                                         gs.cv_results_['param_n_estimators'].data]),
                           columns=['score', 'max_features', 'min_samples_leaf', 'n_estimators'])
gs_results_df.plot(subplots=True,figsize=(10, 10))

 

7-2. RandomSearch

 

무작위로 범위 내의 hyperparameter를 선택하여 그에 대한 결과를 만들고 그 중 가장 좋은 값 도출

한정된 비용(탐색 횟수) 안에서 유용한 방법 -> 차원의 저주(grid search의 문제점) 에서 벗어날 수 있음

무작위로 값을 선택하기 때문에 최적해를 찾는데에는 적합하지 않으나 문제에 대해 아무런 힌트가 없는 초기에 활용하기 좋음

 

최적의 파라미터 도출

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

# parameter 범위 설정
param_grid_rand={'max_features': ['auto', 'sqrt'],
                 'min_samples_leaf': randint(2,10),
                 'n_estimators': randint(100,200)}


# RandomizedSearch 설정
rs=RandomizedSearchCV(clf_RF, param_grid_rand, n_iter = 50, scoring='accuracy', fit_params=None, n_jobs=-1, cv=k_fold, verbose=False, random_state=0)

# 모델 피팅
rs.fit(X_train, y_train)

# 점수 표시
rs_test_score=accuracy_score(y_test, rs.predict(X_test))

print("Best Accuracy {:.3f} params {}".format(rs.best_score_, rs.best_params_))

>>Best Accuracy 0.835 params {'max_features': 'sqrt', 'min_samples_leaf': 2, 'n_estimators': 121}

 

결과 시각화

gs_results_df=pd.DataFrame(np.transpose([gs.cv_results_['mean_test_score'],
                                         gs.cv_results_['param_max_features'].data,
                                         gs.cv_results_['param_min_samples_leaf'].data,
                                         gs.cv_results_['param_n_estimators'].data]),
                           columns=['score', 'max_features', 'min_samples_leaf', 'n_estimators'])
gs_results_df.plot(subplots=True,figsize=(10, 10))

 

 

8. Feature Importance

* Decision Tree 기준

 

라이브러리

import seaborn as sns
import numpy as np
%matplotlib inline

feature importance 추출

print("Feature importances: {}".format(np.round(clf_DT.feature_importances_, 3)))

>> Feature importances: [0.19 0.447 0.16 0.112 0.058 0.032]

 

feature명 매핑

for name, value in zip(X_train.columns, clf_DT.feature_importances_):
    print('{0} : {1: .3f}'.format(name, value))

seaborn 시각화

sns.barplot(x=clf_DT.feature_importances_, y=X_train.columns)

 

 

 

++ 세미프로젝트2 후기)

 여러명이 같이 한 작업이다보니 시각화나 최적화 부분에서 기준 모델이 각자 다르다.

여러 모델에 대해 비교하고 연구해 보거나 한 모델에 대해 좀 더 심도있게 해보는 것도 좋았을 것 같다.

강사님이 주신 추가 학습자료에서 이용한건 하이퍼 파라미터 최적화랑,, 결측치 시각화정도? 복습도 중요하지만 추가 학습자료를 더 이용해볼걸 하는 아쉬움이 있다.

우리도 나름 잘했구나 싶었는데 다른분들도 엄청 잘했었다🤗 

세미1 발표때 다른 분들 발표보고 충격먹은게 잊혀지지 않았는데 여전히.. 난 부족하다는걸 많이 느낀다 😥

세미1 다른 팀 프로젝트도 아직 못열어봤는데... 다른 타이타닉 예측 자료는 언제볼까 싶다.

근데 이제 미드 프로젝트를 해야한다니 으악 난 죽어가는중..

얼른 다른 팀원 코드 공부해서 추가 학습자료 올려야징.... 부디 빠른 시일 안에 타이타닉 복습으로 돌아오길..

주란 화이팅!!!!