[머신러닝] 사이킷런(scikit-learn) - train_test_split, 교차검증, GridSearchCV

Model Selection

- 학습 데이터와 테스트 데이터

1. 학습 데이터 세트

• 머신러닝 알고리즘의 학습을 위해 사용.
• 데이터의 속성들과 결정값(레이블값) 모두를 가지고 있음.
• 학습 데이터를 기반으로 머신러닝 알고리즘이 데이터 속성과 결정값의 패턴을 인지하고 학습

2. 테스트 데이터 세트

• 테스트 데이터 세트에서 학습된 머신러닝 알고리즘을 테스트.
• 속성 데이터만 머신러닝 알고리즘에 제공하며, 머신러닝 알고리즘은 제공된 데이터를 기반으로 결정값을 예측.
• 테스트 데이터는 학습 데이터와 별도의 데이터 세트로 제공되어야 함.

3. 학습 데이터와 테스트 데이터 분리 - train_test_split()

sklearn.model_selection의 train_test_split()함수

X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, 
                                                    test_size=0.3, random_state=121)

• test_size : 전체 데이터에서 테스트 데이터 세트 크기를 얼마로 샘플링할 것인가를 결정. 디폴트는 0.25, 25%
• train_size : 전체 데이터에서 학습용 데이터 세트 크기를 얼마로 샘플링할 것인가를 결정. test_size 파라미터를 통상적으로 사용하기 때문에 train size는 잘 사용하지 않음.
• shuffle : 데이터를 분리하기 전에 데이터를 미리 섞을지를 결정. 디폴트는 True. 데이터를 분산시켜서 좀 더 효율적인 학습 및 테스트 데이터 세트를 만드는데 사용됨.
• random_state : 호출할 때마다 동일한 학습/테스트용 데이터 세트를 생성하기 위해 주어지는 난수값. train_test_split()는 호출 시 무작위로 데이터를 분리하므로 random_state를 지정하지 않으면 수행할 때마다 다른 학습/테스트용 데이터를 생성함.

4. 실습

# 학습/테스트 데이터 분리
from sklearn.model_selection import train_test_split

학습/테스트 데이터의 이해

• 학습 데이터로 잘못된 예측 케이스

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# iris 데이터 로드
iris = load_iris()

# 학습 데이터 세팅
train_data = iris.data
train_label = iris.target

# 디시젼트리 분류기 인스턴스 생성
dt_clf = DecisionTreeClassifier()

# 학습 데이터로 학습
dt_clf.fit(train_data, train_label)

• 테스트 데이터로 predict해야 제대로 된 예측

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

dt_clf = DecisionTreeClassifier( )
iris_data = load_iris()

# train_test_split 함수 : 학습, 테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, 
                                                    test_size=0.3, random_state=121)

print(X_train.shape)
print(X_test.shape)

# 모델 학습
dt_clf.fit(X_train, y_train)

# 테스트 데이터로 예측
pred = dt_clf.predict(X_test)
print('예측 정확도: {0:.4f}'.format(accuracy_score(y_test,pred)))

- 교차 검증과 GridSearchCV

1. 교차 검증

• 학습 데이터 세트 : 학습 데이터를 다시 분할하여 학습 데이터와 학습된 모델의 성능을 일차 평가하는 검증 데이터로 나눔
• 테스트 데이터 세트 : 모든 학습/검증 과정이 완료도니 후 최종적으로 성능을 평가하기 위한 데이터 세트

k 폴드 교차 검증

• 일반 K 폴드
• Stratified K 폴드
  • 불균형한(imbalanced)분포도를 가진 레이블(결정 클래스) 데이터 집합을 위한 k 폴드 방식.
  • 학습 데이터와 검증 데이터 세트가 가지는 레이블 분포도가 유사하도록 검증 데이터 추출.

1. K 폴드

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import KFold
import numpy as np

# 데이터 로드
iris = load_iris()
label = iris.target
features = iris.data

print(features.shape)
features

# 모델 정의
dt_clf = DecisionTreeClassifier(random_state=156)
dt_clf

# 5개의 폴드 세트로 분리하는 KFold 객체와 폴드 세트별 정확도를 담을 리스트 객체 생성.
kfold = KFold(n_splits=5)  # n=5
cv_accuracy = []           # 최종적으로는 n번의 교차검증의 평균 정확도 계산/ 폴드 세트 별로 정확도 값을 저장할 리스트 생성
print('붓꽃 데이터 세트 크기:', features.shape[0])

# for문이 도는 동안 generator가 kfold된 데이터의 학습, 검증 row 인덱스를 array로 반환  
kfold.split(features)

n_iter = 0

# KFold객체의 split( ) 호출하면 폴드 별 학습용, 검증용 테스트의 row 인덱스를 array로 반환  
for train_index, test_index  in kfold.split(features):
    # kfold.split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
    X_train, X_test = features[train_index], features[test_index]
    y_train, y_test = label[train_index], label[test_index]

    # 학습 및 예측 
    dt_clf.fit(X_train , y_train)    
    pred = dt_clf.predict(X_test)
    n_iter += 1

    # 반복 시 마다 정확도 측정
    accuracy = np.round(accuracy_score(y_test,pred), 4)  # 정확도 : 소수점 4자리까지 구함 /np.round(수,자릿수) 
    train_size = X_train.shape[0]
    test_size = X_test.shape[0]
    print('\n#{0} 교차 검증 정확도 :{1}, 학습 데이터 크기: {2}, 검증 데이터 크기: {3}'
          .format(n_iter, accuracy, train_size, test_size))
    print('#{0} 검증 세트 인덱스:{1}'.format(n_iter,test_index))

    cv_accuracy.append(accuracy)

# 개별 iteration별 정확도를 합하여 평균 정확도 계산 
print('\n## 평균 검증 정확도:', np.mean(cv_accuracy)) 

2. Stratified K 폴드

KFOLD 교차검증의 문제점 : 불균형한 데이터에는 적용이 안된다.
이를 해결할 방법이 StratifiedKFold : 불균형한 분포도를 가진 레이블 데이터 집합을 균형하게 섞어주고 교차검증을 진행한다.

import pandas as pd

# iris 데이터 로드
iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# iris 타겟값 확인
iris_df['label'] = iris.target
iris_df['label'].value_counts()

kfold = KFold(n_splits=3)
# kfold.split(X)는 폴드 세트를 3번 반복할 때마다 달라지는 학습/테스트 용 데이터 로우 인덱스 번호 반환. 
n_iter =0
for train_index, test_index  in kfold.split(iris_df):
    n_iter += 1
    label_train= iris_df['label'].iloc[train_index]  # 학습 레이블
    label_test= iris_df['label'].iloc[test_index]    # 검증 레이블

    print('## 교차 검증: {0}'.format(n_iter))
    print('학습 레이블 데이터 분포:\n', label_train.value_counts())       # 학습 레이블 분포
    print('검증 레이블 데이터 분포:\n', label_test.value_counts(), '\n')  # 검증 레이블 분포

kfold를 했더니 불균형하게 학습 레이블, 검증 레이블이 들어가 있으므로 검증이 제대로 되지 않는다
이를 해결할 방법이 StratifiedKFold : 불균형한 분포도를 가진 레이블 데이터 집합을 균형하게 섞어주고 교차검증을 진행.

from sklearn.model_selection import StratifiedKFold

# StratifiedKFold 클래스의 인스턴스 선언 : skf
skf = StratifiedKFold(n_splits=3)
n_iter=0

# StratifiedKFold 사용시 KFold와 차이점 : 레이블 값을 넣어줘서 레이블에 맞게 균일하게 분포를 맞춰준다.
for train_index, test_index in skf.split(iris_df, iris_df['label']):
    n_iter += 1
    label_train= iris_df['label'].iloc[train_index]
    label_test= iris_df['label'].iloc[test_index]

    print('## 교차 검증: {0}'.format(n_iter))
    print('학습 레이블 데이터 분포:\n', label_train.value_counts())
    print('검증 레이블 데이터 분포:\n', label_test.value_counts(), '\n')

StratifiedKFold 했더니 균일하게 학습 레이블, 검증 레이블이 들어가 있으므로 검증이 제대로 된다.

최종적으로 StratifiedKFold를 활용한 교차 검증 정확도 확인

from sklearn.model_selection import StratifiedKFold

dt_clf = DecisionTreeClassifier(random_state=156)

skfold = StratifiedKFold(n_splits=3)
n_iter=0
cv_accuracy=[]

# StratifiedKFold의 split( ) 호출시 반드시 레이블 데이터 셋도 추가 입력 필요(레이블 분포도에 따라 학습/검증 데이터를 분할하기 때문에)
for train_index, test_index  in skfold.split(features, label):
    # split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
    X_train, X_test = features[train_index], features[test_index]
    y_train, y_test = label[train_index], label[test_index]

    #학습 및 예측 
    dt_clf.fit(X_train , y_train)    
    pred = dt_clf.predict(X_test)

    # 반복 시 마다 정확도 측정 
    n_iter += 1
    accuracy = np.round(accuracy_score(y_test,pred), 4)
    train_size = X_train.shape[0]
    test_size = X_test.shape[0]

    print('\n#{0} 교차 검증 정확도 :{1}, 학습 데이터 크기: {2}, 검증 데이터 크기: {3}'
          .format(n_iter, accuracy, train_size, test_size))
    print('#{0} 검증 세트 인덱스:{1}'.format(n_iter,test_index))
    cv_accuracy.append(accuracy)

# 교차 검증별 정확도 및 평균 정확도 계산 
print('\n## 교차 검증별 정확도:', np.round(cv_accuracy, 4))
print('## 평균 검증 정확도:', np.mean(cv_accuracy)) 

아까보다 좋은 검증 정확도가 나옴

교차 검증을 보다 간편하게 - cross_val_score()

KFold 클래스를 이용한 교차 검증 방법

1. 폴드 세트 설정
2. For루프에서 반복적으로 학습/검증 데이터 추출 및 학습과 예측 수행
3. 폴드 세트별로 예측 성능을 평균하여 최종 성능 평가

-> cross_val_score() 함수로 폴드 세트 추출, 학습/예측, 평가를 한번에 수행

from sklearn.tree import DecisionTreeClassifier
# cross_val_score
from sklearn.model_selection import cross_val_score , cross_validate
from sklearn.datasets import load_iris
import numpy as np

iris_data = load_iris()
dt_clf = DecisionTreeClassifier(random_state=156)

data = iris_data.data
label = iris_data.target

# 성능 지표는 정확도(accuracy), 교차 검증 세트는 3개 
scores = cross_val_score(dt_clf , data , label , scoring='accuracy', cv=3)
print('교차 검증별 정확도:',np.round(scores, 4))
print('평균 검증 정확도:', np.round(np.mean(scores), 4))

2. GridSearchCV

GridSearchCV - 교차 검증과 최적 하이퍼 파라미터 튜닝을 한 번에

- 하이퍼 파라미터 : 모델의 성능을 최대로 끌어올리는 학습 조건
- 하이퍼 파라미터 튜닝의 중요성 : 학습 조건을 잘 설정해야 최대의 성능을 내는 머신러닝을 얻을 수 있음

사이킷런은 GridSearchCV를 이용해 Classifier나 Regressor와 같은 알고리즘에 사용되는 하이퍼 파라미터를 순차적으로 입력하면서 편리하게 최적의 파라미터를 도출할 수 있는 방안을 제공.

EX.
grid_parameters = {'max_depth': [1, 2, 3], min_samples_split': [2, 3]}

CV 세트가 3이라면 파라미터 순차 적용 횟수 : 6 X CV세트 수 : 3 = 학습/검증 총 수행 횟수 : 18

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.metrics import accuracy_score

# iris 데이터를 로드
iris = load_iris()

# 학습/테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, 
                                                    test_size=0.2, random_state=121)

# 모델 정의
dtree = DecisionTreeClassifier()

### hyper-parameter 들을 딕셔너리 형태로 설정
parameters = {'max_depth':[1, 2, 3], 'min_samples_split':[2,3]}

import pandas as pd

# param_grid의 하이퍼 파라미터들을 3개의 train, test set fold 로 나누어서 테스트 수행 설정.  
grid_dtree = GridSearchCV(dtree, param_grid=parameters, cv=3, refit=True, return_train_score=True)
### refit=True 가 default : 가장 좋은 파라미터 설정으로 재 학습 시킴.  

# 붓꽃 Train 데이터로 param_grid의 하이퍼 파라미터들을 순차적으로 학습/평가 .
grid_dtree.fit(X_train, y_train)

# GridSearchCV 결과 전체 확인
grid_dtree.cv_results_

# GridSearchCV 결과는 cv_results_ 라는 딕셔너리로 저장됨
# 이를 DataFrame으로 변환해서 확인
scores_df = pd.DataFrame(grid_dtree.cv_results_)
scores_df[['params', 'mean_test_score', 'rank_test_score', 
           'split0_test_score', 'split1_test_score', 'split2_test_score']]

-> 가장 좋은 hyper-parameter는 {'max_depth': 3, 'min_samples_split': 3}

print('GridSearchCV 최적 파라미터:', grid_dtree.best_params_)
print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dtree.best_score_))

# refit=True로 설정된 GridSearchCV 객체가 fit()을 수행 시 학습이 완료된 Estimator를 내포하고 있으므로 predict()를 통해 예측도 가능. 
pred = grid_dtree.predict(X_test)
print('테스트 데이터 세트 정확도: {0:.4f}'.format(accuracy_score(y_test, pred)))

# 테스트 데이터 예측 정확도 확인
accuracy_score(y_test, pred)

estimator 종류

1. 분류 : DecisionTreeClassifier, RandomForestClassifier, ...
2. 회귀 : LinearRegression, ...

# GridSearchCV의 refit으로 이미 학습이 된 estimator 반환
# 위에서 dtree = DecisionTreeClassifier() 로 estimator를 선언했고, 이를 GridSearchCV에 넣었으므로,
estimator = grid_dtree.best_estimator_
estimator

# GridSearchCV의 best_estimator_는 이미 최적 하이퍼 파라미터로 학습이 됨
pred = estimator.predict(X_test)
print('테스트 데이터 세트 정확도: {0:.4f}'.format(accuracy_score(y_test, pred)))

GridSearchCV를 사용했더니 교차검증을 통해 최적의 모델 성능을 내는 하이퍼 파라미터 튜닝을 하고 정확도가 높은 모델을 얻어냄.