사이킷런의 Model Selection 모듈

Model Selection 모듈 소개

---

• 사이킷런의 model_selection 모듈은 학습 데이터와 테스트 데이터 셋을 분리하거나 교차 검증 분할 및 평가,그리고 하이퍼 파라미터 튜닝을위한 다양한 함수와클래스르 제공한다.

1. 학습/테스트 데이터 셋 분리 - train_test_split

먼저 테스트 데이터 셋을 이용하지 않고 학습 데이터 셋으로만 학습하고 예측하면 무엇이 문제인지 살펴보자

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

iris = load_iris()
dt_clf = DecisionTreeClassifier()
train_data = iris.data
train_label = iris.target
dt_clf.fit(train_data,train_label)

#학습 데이터 셋으로 예측 수행
pred = dt_clf.predict(train_data)
print('예측 정확도: ' , accuracy_score(train_label, pred))

예측 정확도:  1.0

정확도가 1.0이 나왔다.

위의 예측 결과가 100% 정확한 이유는 이미 학습한 학습 데이터 셋을 기반으로 예측했기 때문
예측을 수행하는 데이터 셋은 학습을 수행한 학습용 데이터 셋이아닌 전용의 테스트 데이터 셋으로 해야함.
사이킷 런의 train_test_split()를 통해 원본 데이터 셋에서 학습 및 테스트 데이터 셋을 쉽게 분리할 수 있다.

train_test_split 주요 파라미터

• test_size : 전체 데이터에서 테스스 데이터 셋 크기를 얼마로 샘플링 할 것인가를 결정
• shuffle : 데이터를 분리하기전에 미리 섞을지를 결정. 데이터를 분산시켜 좀 더 효율적인 학습 및 테스트 데이터 셋을 만드는데 사용.
• random_state : 호출 할 때 마다 동일한 학습/테스트용 데이터 셋을 생성하기 위해 주어지는 난수값

붓꽃 데이터 셋을 train_test_split()를 이용해 테스트 데이터 셋을 전체의 30%로 , 학습 데이터 셋을 70%로 분리하겠습니다. 앞의 에제와 다르게 random_state = 121로 변경해 데이터 셋을 변화 시켜 보겠습니다.

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()

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

학습 데이터를 기반으로 DecisitonTreeClassifier를 학습하고 이 모델을 이용해 예측 정확도를 측정해 보겠습니다.

dt_clf.fit(X_train,y_train)
pred = dt_clf.predict(X_test)
print('예측 정확도 : {0:.4f}'.format(accuracy_score(y_test,pred)))

예측 정확도 : 0.9556

테스트 데이터로 예측을 수행한 결과 정확도가 약 95.56%입니다. 붓꽃 데이터는 150개의 데이터로 데이터 양이 크지 않아
전체의 30%정도인 테스트 데이터는 45개 정도밖에 되지 않으므로 이를 통해 알고리즘의 예측 성능을 판단하기에는 그리 적절하지 않습니다.
학습을 위한 데이터의 양을 일정 수준이상으로 보장하는 것도 중요하지만, 학습된 모델에 대해 다양한 데이터를 기반으로 예측 성능을 평가해 보는 것도 매우 중요합니다.

2. 교차 검증

• 앞에서 알고리즘의 예측 성능을 평가하기위해 학습용데이터와 테스트용 데이터를 분리해야 한다고 했습니다. 그러나 이방법도 과적합에 취약합니다.
  이러한 문제점을 개선하기 위해 교차 검증을 이용해 다양한 학습과 평가를 수행합니다.

ML은 데이터에 기반합니다. 그리고 데이터는 이상치, 분포도, 다양한 속성값, 피처 중요도 등 여러 가지 ML에 영향을 미치는 요소를 가지고 있습니다.
특정 ML 알고리즘에서 최적으로 동작할 수 있도록 데이터를 선별해 학습한다면 실제 데이터 양식과는 많은 차이가 있을 것이고 결국 성능 저하로 이어질 것입니다.

교차 검증은 이러한 데이터 편중을 막기 위해서 별도의 여러 셋으로 구성된 학습 데이터 셋과 검증 데이터 셋에세 학습과 평가를 수행하는 것입니다.
그리고 각 세트에서 수행한 평가 결과에 따라 하이퍼 파라미터 튜닝 등의 모델 최적화를 더욱 손쉽게 할 수 있습니다.

대부분의 ML 모델의 성능 평가는 교차 검증 기반으로 1차 평가를 한 뒤에 최종적으로 테스트 데이터 셋에 적용해 평가하는 프로세스입니다.
ML에 사용되는 데이터 셋을 세분화해서 학습, 검증, 테스트 데이터 셋으로 나눌 수 있습니다.

테스트 데이터 셋 외에 별도의 검증 데이터 셋을 둬서 최종 평가 이전에 학습된 모델을 다양하게 평가하는 데 사용합니다.

K 폴드 교차 검증

-K 폴드 교차 검증은 가장 보편적으로 사용되는 교차 검증 기법입니다.
먼저 K 개의 데이터폴드 셋을 만들어서 K번 만큼 각 폴드 세트에 학습과 검증 평가를 반복적으로 수행하는 방법입니다.

다음 그림은 5 폴드 교차 검증을 수행합니다 (즉 , K 가 5). 5개의 폴드된 데이터 셋을 학습과 검증을 위한 데이터 셋으로 변경하면서 5번 평가를 수행한 뒤, 이 5개의 평가를 평균한 결과를 가지고 예측 성능을 평가합니다.

교차검증 최종 평가 = 평균(평가[1,2,3,4,5])

사이킷런에서는 K 폴드 교차 검증 프로세스를 구현하기 위해 KFold와 StratifiedKFold 클래스를 제공한다. 먼저 KFold 클래스를 이용해 붓꽃 데이터 셋을 교차 검증하고 예측 정확도를 알아 보겠습니다.

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

iris= load_iris()
features = iris.data
label = iris.target
dt_clf = DecisionTreeClassifier(random_state=156)

# 5개의 폴드 셋으로 분리하는 KFold 객체와 폴드 세트별 정확도를 담을 리스트 객체 생성.
kfold = KFold(n_splits=5)
cv_accuracy=[]
print('붓꽃 데이터 셋의 크기: ', features.shape[0])

붓꽃 데이터 셋의 크기:  150

KFold(n_splits=5)로 KFold 객체를 생성했으니 이제 생성된 KFold 객체의 split()을 호출해 전체 붓꽃 데이터를 5개의 폴드 데이터 셋으로 분리합니다.

전체 붓꽃 데이터는 모두 150개입니다. 따라서 학습용 데이터 셋은 이중 4/5개인 120개, 검증 테스트 데이터 셋은 1/5인 30개로 분할 됩니다.

KFold 객체는 split()를 호출하면 학습용/검증용 데이터로 분할할 수있는 인덱스를 반환한다.

실제로 학습용/검증용 데이터 추출은 반환된 인덱스를 기반으로 개발 코드에서 직접 수행해야한다.

다음 예제는 5개의 폴드 셋을 생성하는 KFold 객체의 split()을 호출해 교차 검증 수행 시마다 학습과 검증을 반복해 예측 정확도를 측정합니다.
그리고 split()이 어떤 값을 실제로 반환하는지도확인해 보기 위해 검증 데이터 셋의 인덱스도 추출해 보겠습니다.

n_iter =  0

#KFold 객체의 split()를 호출하면 폴드 별 학습용, 검증요 테스트의 로우 인덱스를 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)
    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))  

#1 교차 검증 정확도 :1.0 , 학습 데이터 크기: 120, 검증 데이터 크기 :30
#1 검증 세트 인덱스:[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29]

#2 교차 검증 정확도 :0.9667 , 학습 데이터 크기: 120, 검증 데이터 크기 :30
#2 검증 세트 인덱스:[30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
 54 55 56 57 58 59]

#3 교차 검증 정확도 :0.8667 , 학습 데이터 크기: 120, 검증 데이터 크기 :30
#3 검증 세트 인덱스:[60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
 84 85 86 87 88 89]

#4 교차 검증 정확도 :0.9333 , 학습 데이터 크기: 120, 검증 데이터 크기 :30
#4 검증 세트 인덱스:[ 90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113 114 115 116 117 118 119]

#5 교차 검증 정확도 :0.7333 , 학습 데이터 크기: 120, 검증 데이터 크기 :30
#5 검증 세트 인덱스:[120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
 138 139 140 141 142 143 144 145 146 147 148 149]

## 평균 검증 정확도: 0.9

Stratified K 폴드

• Stratified K 폴드는 불균형한 분포도를 가진 레이블 데이터 집합을 위한 K 폴드 방식이다.
• Stratified K 폴드는 K 폴드가 레이블 데이터 집합이 원본 데이터 집합의 레이블 분포를 학습 및 테스트 셋에 제대로 분배하지 못하느 경우에 문제를 해결해준다.

아래 예제를 통해 살펴보자.

import pandas as pd

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns = iris.feature_names)
iris_df['label'] = iris.target
iris_df['label'].value_counts()

2    50
1    50
0    50
Name: label, dtype: int64

레이블 값은 0, 1, 2 값 모두 50개로 동일합니다. 즉 Setosa 품종, Versicolor 품종, Virginica 품종 모두가 50개입니다.
이슈가 발생하는 현상을 도출하기 위해 3개의 폴드 셋을 KFold로 생성하고 각 교차 검증 시마다 생성되는 학습/ 검증 레이블 데이터 값의 분포도를 확인해 보자

kfold = KFold(n_splits = 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())

## 교차 검증: 1
학습 레이블 데이터 분포 :
 2    50
1    50
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 0    50
Name: label, dtype: int64
## 교차 검증: 2
학습 레이블 데이터 분포 :
 2    50
0    50
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 1    50
Name: label, dtype: int64
## 교차 검증: 3
학습 레이블 데이터 분포 :
 1    50
0    50
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 2    50
Name: label, dtype: int64

교차 검증 시마다 3개의 폴드 셋으로 만들어지는 학습 레이블과 검증 레이블이 완전히 다른 값으로 추출되었다.

StratifiedkFold는 이렇게 KFold로 분할된 레이블 데이터 세트가 전체 레이블 값의 분포도를 반영하지 못하는 문제를 해결해 준다.

이번에는 동일한 데이터 분할을 StratifiedkFold 로 수행하고 학습/검증 레이블 데이터의 분포도를 확인해 보자

StatifiedKFold 는 레이블데이터 분포도에 따라 학습/검증 데이터를 나누기 때문에 KFold와 달리 split() 메서드에 인자로 피처 데이트 셋 뿐만 아니라 레이블 데이터 셋도 반드시 필요하다.

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits = 3)
n_iter = 0

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())    

## 교차 검증: 1
학습 레이블 데이터 분포 :
 2    34
1    33
0    33
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 1    17
0    17
2    16
Name: label, dtype: int64
## 교차 검증: 2
학습 레이블 데이터 분포 :
 1    34
2    33
0    33
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 2    17
0    17
1    16
Name: label, dtype: int64
## 교차 검증: 3
학습 레이블 데이터 분포 :
 0    34
2    33
1    33
Name: label, dtype: int64
검증 레이블 데이터 분포 :
 2    17
1    17
0    16
Name: label, dtype: int64

출력 결과를 보면 학습 레이블과 검증 레이블 데이터 값의 분포도가 동일하게 할당됐음을 알 수 있습니다.

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)) 

#1 교차 검증 정확도 :0.98, 학습 데이터 크기: 100, 검증 데이터 크기: 50
#1 검증 세트 인덱스:[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  50
  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66 100 101
 102 103 104 105 106 107 108 109 110 111 112 113 114 115]

#2 교차 검증 정확도 :0.94, 학습 데이터 크기: 100, 검증 데이터 크기: 50
#2 검증 세트 인덱스:[ 17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  67
  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82 116 117 118
 119 120 121 122 123 124 125 126 127 128 129 130 131 132]

#3 교차 검증 정확도 :0.98, 학습 데이터 크기: 100, 검증 데이터 크기: 50
#3 검증 세트 인덱스:[ 34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  83  84
  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99 133 134 135
 136 137 138 139 140 141 142 143 144 145 146 147 148 149]

## 교차 검증별 정확도: [0.98 0.94 0.98]
## 평균 검증 정확도: 0.9666666666666667

3개의 Stratified K 폴드로 교차 검증한 결과 평균 검증 정확도가 약 96%로 측정 됨.

Stratified K 폴드의 경우 원본 데이터의 레이블 분포도 특성을 반영한 학습 및 검증 데이터 셋을 만들 수 있으므로 왜곡된 레이블 데이터 셋에서는 반드시 Stratified K 폴드를 이용해 교차 검증 해야 한다.

3. cross_val_score()

• 사이킷런은 교차 검증을 좀 더 편리하게 수행할 수 있게 해주는 cross_val_score를 제공한다.

• KFold로 데이터를 학습하고 예측하는 코드를 보면

  1. 폴드 셋을 설정하고
  2. for 루프에서 반복으로 학습 및 테스트 데이터의 인덱스를 추출한뒤
  3. 반복적으로 학습과 예측을 수행하고 예측 성능을 반환한다.

  **cross_val_score()**는 이런 일련의 과정을 한꺼번에 수행해주는 API입니다.

cross_val_score()

corss_val_score의 선언 형태

cross_val_score(estimator, X, y=None, scoring=None, cv=None, n_jobs=1, verbose=0, fit_params=None, pre_dispatch=’2*n_jobs’).

이중 estimator, X, y scoring, cv가 주요 파라미터 이다.

• esitmator는 사이킷런의 분류 알고리즘 클래스인 Classifier 또는 회귀 알고리즘 클래스인 Regressor를 의미
• X는 피처 데이터 셋
• y는 레이블 데이터 셋
• scoring은 예측 성능 평가 지표
• cv 는 교차 검증 폴드수

아래 코드에서 cross_val_score()의 자세한 사용법을 알아보자

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score , cross_validate
from sklearn.datasets import load_iris

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))

   교차 검증별 정확도 [0.98 0.94 0.98]
   평균 검증 정확도 0.9667

비슷한 API로 **corss_validate()**가 있습니다 . cross_val_score()는 단 하나의 평가 지표만 가능하지만 corss_validate()는 여러 개의 평가 지표를 반환할 수 있습니다. 또한 학습 데이터에 대한 성능 평가 지표와 수행 시간도 같이 제공합니다.

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

하이퍼 파라미터는 머신러닝 알고리즘을 구성하는 주요 구성 요소이며, 이 값을 조정해 알고리즘의 예측성능을 개선할 수 있다.

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

예를 들어 결정 트리 알고리즘의 여러 하이퍼 파라미터를 순차적으로 변경하면서 최고 성능을 가지는 파라미터 조합을 찾고자 한다면 다음과 같이 파라미터의 집합을 만들고 이를 순차적으로 적용하면서 최적화를 수행할 수 있습니다.

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

• GridSearchCV는 교차 검증을 기반으로 이 하이퍼 파라미터의 최적 값을 찾게 해준다.

• GridSearchCV는 사용자가 튜닝 하고자 하는 여러 종류의 하이퍼 파라미터를 다양하게 테스트하면서 최적의 파라미터를 편리하게 찾게 해주지만 동시에 순차적으로 파라미터를
  테스트하므로 수행시간이 상대적으로 오래 걸리는 것에 유념해야한다.

• 6개의 파라미터 조합이라면 총 cv 3회 x 6개의 파라미터 조합 = 18회의 학습/평가가 이루어 진다.

GridSerach CV 클래스의 주요 파라미터

• estimator : classifier, regressor, pipeline이 사용될 수있습니다.
• param_grid: key + 리스트 값을 가지는 딕셔너리가 주어집니다. estimator의 튜닝을 위해파라미터명과 사용될 여러 파라미터 값을 지정합니다.
• scoirng : 예측 성능을 측정할 평가 방법을 지정합니다. 보통은 사아킷런의 성능 평가 지표를 지정하는 문자열(ex. accuracy)로 지정하나 별도의 성능 평가 지표 함수도 지정할 수 있습니다.
• cv : 교차 검증을 위해 분할되는 학습/테스트 셋의 개수를 지정합니다.
• refit: 디폴트가 True이며 True로 생성 시 가장 최적의 하이퍼 파라미터를 찾은 뒤 력된 estimator 객체를 해당 하이퍼 파라미터로 재학습시킵니다.

#### 간단한 예제를 통해 GridSearchCV 의 사용법을 익혀보자
결정 트리 알고리즘의 여러 가지 최적화 파라미터를 순차적으로 적용해 붓꽃 데이터를 예측 분석해보자

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV

#데이터를 로딩하고 학습 데이터와 테스트 데이터 분리
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()

#파라미터를 딕셔너리 형태로 설정
parameters =  {'max_depth' :[1, 2, 3],'min_samples_split':[2,3]}

1. 학습데이터 셋을 GridSearchCV 객체의 fit메서드에 인자로 입력.

2. GridSearchCV 객체의 fit(학습 데이터 셋)메서드를 수행하면서 학습 데이터를 cv에 기술된 폴딩 세트로 분할해 param_grid에 기술된 하이퍼 파라미터를 순차적으로 변경하면서 학습/평가를 수행하고 그 결과를 cv_results_ 속성에 기록합니다.

import pandas as pd

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

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

#GridSearchCV 결과를 추출해 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']]

.dataframe tbody tr th:only-of-type { vertical-align: middle; }

.dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	params	mean_test_score	rank_test_score	split0_test_score	split1_test_score	split2_test_score
0	{'max_depth': 1, 'min_samples_split': 2}	0.700000	5	0.700	0.7	0.70
1	{'max_depth': 1, 'min_samples_split': 3}	0.700000	5	0.700	0.7	0.70
2	{'max_depth': 2, 'min_samples_split': 2}	0.958333	3	0.925	1.0	0.95
3	{'max_depth': 2, 'min_samples_split': 3}	0.958333	3	0.925	1.0	0.95
4	{'max_depth': 3, 'min_samples_split': 2}	0.975000	1	0.975	1.0	0.95
5	{'max_depth': 3, 'min_samples_split': 3}	0.975000	1	0.975	1.0	0.95

GridSearchCV 객체의 fit()을 수행하면 최고 성능을 나타낸 하이퍼 파라미터의 값과 그때의 평가 결과 값이 각각 best_params_, best_score_ 속성에 기록됩니다.
이 속성을 이용해 최적 하이퍼 파라미터의 값과 그때의 정확도를 알아보자.

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

GridSearchCV 최적 파라미터: {'max_depth': 3, 'min_samples_split': 2}
GridSearchCV 최고 정확도: 0.9750

이미 학습된 best_estimator_를 이용해 앞에서 train_test_split()으로 분리한 테스트 데이터 셋에 대해 예측하고 성능을 평가해 보자.

# GridSearchCV의 refit으로 이미 학습이 된 estimator 반환
estimator = grid_dtree.best_estimator_

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

테스트 데이터 세트 정확도: 0.9667