[ML]7. 앙상블 모델

머신러닝_07_앙상블 모델

 

1. 앙상블(Ensemble): 여러 개의 머신 러닝 모델을 연결하여 더 강력한 모델을 만드는 기법
2. 앙상블 모델의 종류: Voting, Bagging, Boosting

1)Voting: 서로 다른 모델을 결합하여 투표를 통해 최종 예측결과를 결정하는 방식

• Hard Voting(다수결)/Soft Voting(확률)

 

2)Bagging: 같은 알고리즘으로 여러 개의 모델을 만들어서 투표를 통해 최종예측, 결과를 결정하는 방식 

-샘플 데이터를 여러 개로 분할, 데이터의 중복 허용

예)랜덤 포레스트(Decision Tree모델이 여러 개)

 

3)Boosting: 성능이 낮은 여러 개의 모델을 이용

• 처음 모델이 예측을 하면 예측결과에 따라 잘못 분류된 데이터에 가중치 부여
• 부여된 가중치가 다음 모델에 영향
• 잘못 분류된 데이터에 집중하여 개선된 분류규칙을 만드는 단계를 반복하며 성능이 높은 모델을 생성

예)AdaBoost, GradientBoost, XGBoost

 

• Bagging과 Boosting 모델의 비교

 3. 랜덤 포레스트

• 여러 개의 결정트리 분류모델이 전체 데이터에서 각자의 데이터를 샘플링하여 개별적으로 학습한 뒤 최종적으로 모든 분류기가 soft voting을 통해 예측
• 서로 다른 데이터로 다른 방향으로 학습된 과대적합 모델을 많이 만들고 평균을 내서 일반화시키는 모델
• 다양한 트리를 만드는 방법: 데이터 무작위 선택, 노드 기준 특성 무작위 선택
• 분류/회귀 모두 사용가능

 

4. AdaBoost: 각각의 트리들이 독립적이지 않고 오류 데이터에 가중치를 부여

• 첫 번째 의사결정 트리 생성: 대충 분류

• 오류 데이터에 높은 가중치 부여, 올바른 데이터에는 낮은 가중치 부여0.

• 가중치를 부여한 상태에서 다시 분류

• 진행한 분류들을 결합

 

5. GBM

6. XGBoost

• 결정 트리 기반의 앙상블 모델에서 가장 각광받고 있는 알고리즘 중 하나
• Early Stopping 기능과 과대적합 방지를 위한 규제가 포함→GBM 단점 보완
• Early Stopping: 학습능률이 떨어지면 학습중지하는 기능

           →느린 학습시간, 과대적합 문제 해결

• 대규모 머신러닝문제에 그래디언트 부스팅 적용 시 XGBoost 사용
• 분류, 회귀 모두 가능

 

7. LightBGM

 

[실습]유방암 데이터 랜덤포레스트 모델 학습

1. 문제정의: 유방암 진단
2. 데이터 불러오기

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

 

#유방암 진단 데이터셋 불러오기

from sklearn.datasets import load_breast_cancer

breast_cancer=load_breast_cancer()

 

#문제, 정답, 특성 이름(문제 컬럼) 데이터, 정답 이름(정답 컬럼) 추출

breast_cancer_data=breast_cancer['data']

breast_cancer_label=breast_cancer['target']

breast_cancer_feature_names=breast_cancer['feature_names']

breast_cancer_label_names=breast_cancer['target_names']

 

#데이터 프레임 구성(문제데이터)

breast_cancer_df=pd.DataFrame(data=breast_cancer_data, columns=breast_cancer_feature_names)

 

3. 데이터 전처리

#훈련, 데이터셋 분리(train_test_split)

 

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(breast_cancer_data,breast_cancer_label, test_size=0.2, random_state=6)

4. 모델 선택 및 생성

1)Decision Tree 모델

#DecisionTree 모델 import

from sklearn.tree import DecisionTreeClassifier

dt_model=DecisionTreeClassifier()

 

#모델 학습(fit)

dt_model.fit(X_train, y_train)

 

#모델 성능 평가: .score(input_data, true_data)

dt_model.score(X_test, y_test)

 

#모델 예측(predict)

dt_pre=dt_model.predict(X_test)

 

#모델 정확도: accuracy_score(실제값, 예측값)

from sklearn.metrics import accuracy_score

dt_score=accuracy_score(y_test,dt_pre)

 

 

 

2)Voting: KNN, DT(결정트리), LR(로지스틱 회귀) 모델

• 모델 import

#Voting import

from sklearn.ensemble import VotingClassifier

 

#KNN

from sklearn.neighbors import KNeighborsClassifier

 

#LR(로지스틱 회귀)

from sklearn.linear_model import LogisticRegression

 

• 개별 모델 생성

#개별 모델 생성

#KNN 모델

knn_model=KNeighborsClassifier(n_neighbors=8)

 

#로지스틱 모델

lr_model=LogisticRegression()

 

#결정트리 모델

#dt_model

 

• Voting 모델 생성

#voting 모델 생성

#estimators: 사용할 단일 모델들을 리스트 형식[(key, value)]으로 정의(KNN,DT,LR)

#voting=hard/soft

 

voting=VotingClassifier(estimators=[('KNN', knn_model), ('LR',lr_model), ('DT', dt_model)],voting='soft')

 

• 모델 학습

#모델 학습

#각 모델의 학습결과 확인

knn_model.fit(X_train, y_train) #앙상블 모델

lr_model.fit(X_train, y_train) #개별 모델

dt_model.fit(X_train, y_train) #개별 모델

voting.fit(X_train, y_train) #개별 모델

 

• 모델 예측

#각 모델별 예측

knn_pre=knn model.predict(X_test)

lr_pre=lr_model.predict(X_test)

dt_pre=dt_model.predict(X_test)

voting_pre=voting.predict(X_test)

 

• 모델 정확도

#각 모델별 정확도

 

knn_score=accuracy_score(y_test,knn_pre)

lr_score=accuracy_score(y_test,lr_pre)

dt_score=accuracy_score(y_test,dt_pre)

voting_score=accuracy_score(y_test,voting_pre)

 

*다양한 출력형태

 

3)Bagging

• 랜덤포레스트 import

#랜덤 포레스트 import

from  sklearn.ensemble import RandomForestClassifier

 

rf_model=RandomForestClassifier()

 

• 모델 학습

#모델 학습

rf_model.fit(X_train, y_train)

 

• 모델 예측

#모델 예측

rf_pre=rf_model.predict(X_test)

 

• 모델 정확도

#모델 정확도

rf_score=accuracy_score(y_test,rf_pre)

print('RF 모델의 정확도: {0:.2f}% '.format(rf_score*100))

5. 랜덤 포레스트 하이퍼 파라미터 튜닝

• 랜덤 포레스트 

-n_estimators: 기본 100개

-n_jobs=-1 모든 cpu 코어를 이용해 학습

-max_features: DT 모델에서는 최종 결과값의 개수, 랜덤포레스트에서는 쿼터(1/4) 개수 예)16-→4로 인식

 

• GridSearchCV

-max_depth: 노드의 깊이

-min_samples_leaf: 최종 결과 개수

-min_samples_split: 노드를 만들기 위한 최소 개수

 

• 라이브러리 import

from sklearn.tree import  DecisionTreeClassifier

from sklearn.model_selection import GridSearchCV

import pandas as pd

 

• 파라미터 설정

params={

    'max_depth': [2,4,6],

    'min_samples_leaf': [2,4,6],

    'min_samples_split':[2,4,6],

    'max_leaf_nodes': [3,5,7]

}

 

• GridSearchCV 모델 생성

#GridSearchCV(모델이름, param_grid=파라미터, cv=cv값, refit=T/F,  n_jobs=-1)

#refit: 가장 좋은 파라미터 설정을 재학습

#n_jobs=-1 모든 cpu 코어를 이용해 학습

grid_tree=GridSearchCV(rf_model, param_grid=params,cv=5, refit=True, n_jobs=-1)

 

• 모델 학습

#param_grid에서 설정한 파라미터를 순차적으로 학습/평가

grid_tree.fit(X_train, y_train)

 

• 결과 출력

 

6. Boosting

• Boosting 모델들의 파라미터

-learning_rate(학습률): 오류 데이터에 가중치 부여(범위 0~1, 기본값: 0.1)

-n_estimators: 트리 개수(기본 100개)

-subsample: weak(약한 분류기 데이터 샘플 수)

-random_state

-트리모델 파라미터(max_depth....)

 

1)AdaBoost

#모델 import

from sklearn.model_selection import cross_val_score

from sklearn.ensemble import AdaBoostClassifier

#모델 생성

 

ada_model=AdaBoostClassifier(n_estimators=100, random_state=7, learning_rate=0.3)

 

#교차 검증-일반화 성능평가

rs=cross_val_score(ada_model, X_train, y_train, cv=5)

 

print('교차검증: ', rs)

print('교차검증 평균:', rs.mean())

 

#모델 학습

ada_model.fit(X_train, y_train)

 

#모델 예측

ada_pre=ada_model.predict(X_test)

 

#모델 정확도 평가

from sklearn.metrics import accuracy_score

ada_score=accuracy_score(y_test, ada_pre)

print('AdaBoost 모델 정확도: {0:.2f}%'.format(ada_score*100))

 

2)GBM

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.model_selection import cross_val_score

from sklearn.metrics import accuracy_score

 

# 모델 생성

gbm_model=GradientBoostingClassifier(n_estimators=100, random_state=7, learning_rate=0.3)

 

#교차 검증-일반화 성능평가

rs2=cross_val_score(gbm_model, X_train, y_train, cv=5)

 

print('교차검증: ', rs2)

print('교차검증 평균:', rs2.mean())

 

#모델 학습

gbm_model.fit(X_train, y_train)

 

#모델 예측

gbm_pre=gbm_model.predict(X_test

 

#모델 정확도 평가

gbm_score=accuracy_score(y_test, gbm_pre)

 

print('GBM 모델 정확도: {0:.2f}%'.format(gbm_score*100))

 

3)XGBoost

#XGBoost/Light GBM은 sklearn에서 제공하지 않음

#별도의 설치 필요(colab에서는 제공함)

 

from xgboost import XGBClassifier

from sklearn.model_selection import cross_val_score

from sklearn.metrics import accuracy_score

 

# 모델 객체 생성

xgb_model=XGBClassifier(n_estimators=100, random_state=7, learning_rate=0.3)

 

#교차 검증-일반화 성능평가

rs3=cross_val_score(xgb_model, X_train, y_train, cv=5)

 

print('교차검증: ', rs3)

print('교차검증 평균:', rs3.mean())

 

#모델 학습

xgb_model.fit(X_train, y_train)

#모델 예측

xgb_pre=xgb_model.predict(X_test)

 

#모델 정확도 평가

xgb_score=accuracy_score(y_test, xgb_pre)

 

print('XGB 모델 정확도: {0:.2f}%'.format(xgb_score*100))

 

■Early Stopping

(1)데이터 split을 2번하여  train/validation/test 데이터 분할

#1. 훈련, 평가 데이터셋 분리(train_test_split)

#train_test_split(문제데이터, 정답데이터, 분할 비율, 랜덤으로 섞는 비율)

#train/test 데이터(8:2)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(breast_cancer_data, breast_cancer_label,

                                                  test_size=0.2, random_state=6)

 

#2. train 데이터 분할(train, validation)

 

#이미 분할된 train 데이터를 train, validation 데이터로 다시 분할

#train/val 데이터 분할(7:1)

#X_train(X_tr, X_val), y_train(y_tr, y_val)

 

from sklearn.model_selection import train_test_split

X_tr, X_val, y_tr, y_val=train_test_split(X_train, y_train,

                                          test_size=0.1, random_state=10)

 

• Early Stopping 파라미터

-early_stopping_rounds: 반복횟수

-early_metric: 조기중단 평가지표(logloss: 로그 손실이 적을수록 좋은 모델)

-eval_set: 평가를 수행할 데이터셋

 

(2)모델 생성

#모델 불러오기

 

from xgboost import XGBClassifier

from sklearn.model_selection import cross_val_score

from sklearn.metrics import accuracy_score

 

#Early Stopping 적용하여 모델 생성

xgb_model_es=XGBClassifier(n_estimators=100, random_state=7,

# early_stopping_rounds=4, #반복횟수 learning_rate=0.3)

 

(3)학습 및 평가

• 분류모델 평가지표: logloss, error, auc, aucpr

#평가를 수행할 데이터셋(eval_set) 만들기

#[(train data), (validation data)]

#train: 학습하면서 log값이 증가

#val: 답 예측 후 실제 답과 비교하기 때문에 log 값이 변동

evals=[(X_tr, y_tr), (X_val, y_val)]

 

# 모델 학습(평가지표, 평가데이터셋 옵션)

xgb_model_es.fit(X_tr, y_tr, early_stopping_rounds=50,

eval_metric='logloss', #평가지표 eval_set=evals, #평가데이터 셋

verbose=True ) #화면 출력

 

#모델 예측

xgb_es_pre=xgb_model_es.predict(X_test)

xgb_es_pre

 

#모델 예측(확률)

xgb_es_proba=xgb_model_es.predict_proba(X_test)

#양성->[: ,0] 악성->[:, 1]

 

#모델 정확도 평가

xgb_es_score=accuracy_score(y_test, xgb_es_pre)

print('XGB 모델 학습조기중단 정확도: {0:.2f}%'.format(xgb_es_score*100))

 

4)LightGBM

from warnings import filterwarnings

import warnings

from lightgbm import LGBMClassifier

 

warnings.filterwarnings('ignore') #경고창 무시

 

#LGB 모델 생성

lgb_model=LGBMClassifier(n_estimators=100, random_state=7,

                       #early_stopping_rounds=4, #반복횟수

                        learning_rate=0.3)

#교차 검증-일반화 성능평가

 

rs4=cross_val_score(lgb_model, X_train, y_train, cv=5)

 

print('교차검증: ', rs4)

print('교차검증 평균:', rs4.mean())

 

#모델 학습

 

lgb_model.fit(X_train, y_train)

 

#모델 예측

lgb_pre=lgb_model.predict(X_test)

 

#모델 정확도 평가

lgb_score=accuracy_score(y_test, lgb_pre)

print('LGB 모델 정확도: {0:.2f}%'.format(lgb_score*100))

7. 특성 중요도 시각화

import matplotlib.pyplot as plt

import seaborn as sns

import pandas as pd

 

#X_train의 타입 Numpy->DataFrame으로 변경

X_train_df=pd.DataFrame(X_train, columns=breast_cancer_feature_names)

 

#특징 중요도 .feature_importances_

importance_value=lgb_model.feature_importances_

 

#Series로 만들기

im_series=pd.Series(importance_value, index=X_train_df.columns)

 

im_series_top=im_series.sort_values(ascending=False)[:20]

 

#시각화(막대그래프)

plt.figure(figsize=(8, 6))

plt.title('Feature Importance Top 20')

sns.barplot(x=im_series_top,y=im_series_top.index)

plt.show()