sklearn.model

=====================================================
  sklearn.model_selection: Model Selection
=====================================================

 

  https://scikit-learn.org/stable/modules/classes.html#module-sklearn.model_selection

 

 - Splitter Classes            -> sklearn.model_selection.KFold
                                -> sklearn.model_selection.StratifiedKFold = 층화샘플추출
  - Splitter Functions          -> sklearn.model_selection.train_test_split = 
  - Hyper-parameter optimizers  -> sklearn.model_selection.GridSearchCV 
                                   sklearn.model_selection.RandomizedSearchCV
  - Model validation            -> sklearn.model_selection.cross_validate
                                -> sklearn.model_selection.cross_val_score

 

---

 

DecisionTreeClassifier() 패키지 설명

• criterion : 분할 품질을 측정하는 기능 (default : gini)
• splitter : 각 노드에서 분할을 선택하는 데 사용되는 전략 (default : best)
• max_depth : 트리의 최대 깊이 (값이 클수록 모델의 복잡도가 올라간다.)
• min_samples_split : 자식 노드를 분할하는데 필요한 최소 샘플 수 (default : 2)
• min_samples_leaf : 리프 노드에 있어야 할 최소 샘플 수 (default : 1)
• min_weight_fraction_leaf : min_sample_leaf와 같지만 가중치가 부여된 샘플 수에서의 비율
• max_features : 각 노드에서 분할에 사용할 특징의 최대 수
• random_state : 난수 seed 설정
• max_leaf_nodes : 리프 노드의 최대수
• min_impurity_decrease : 최소 불순도
• min_impurity_split : 나무 성장을 멈추기 위한 임계치
• class_weight : 클래스 가중치
• presort : 데이터 정렬 필요 여부

 

---

 

Model Selection 예제

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

# (1) 학습 데이터 세트로만 fitting and predicting

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


# (2) 데이터 세트를 나누어서 fitting and predicting

from sklearn.model_selection import train_test_split  

iris_data = load_iris()
dt_clf = DecisionTreeClassifier( )

X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, 
                                                    test_size=0.3, random_state=121)  # 7:3으로 트레이닝 테스트 나누기

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

# (3) K-Folds cross-validator

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)  # 데이터를 5등분
cv_accuracy = []  # 빈 리스트 만들기 
print('붓꽃 데이터 세트 크기:',features.shape[0])

n_iter = 0  # 반복하는 숫자 기록하기 위해서 

# KFold객체의 split( ) 호출하면 폴드 별 학습용, 검증용 테스트의 로우 인덱스를 array로 반환  
for train_index, test_index  in kfold.split(features): # 4개의 feature와 150개의 sample을 가진 데이터를 split
    # kfold.split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
    X_train, X_test = features[train_index], features[test_index] # 80% 추출
    y_train, y_test = label[train_index], label[test_index]  #20% 추출
    #학습 및 예측 
    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))  # 각각 정확도의 평균

# (4) Stratified K-Folds cross-validator

# 4-1 KFold 사용할 경우

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

kfold = KFold(n_splits=3)
# kfold.split(X)는 폴드 세트를 5번 반복할 때마다 달라지는 학습/테스트 용 데이터 로우 인덱스 번호 반환. 
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())

# 4-2 StratifiedKFold 사용할 경우

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

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

# (5) Evaluate a score by cross-validation

from sklearn.model_selection import cross_val_score , cross_validate

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)  # cv = 3등분 한다 .  
print('교차 검증별 정확도:',np.round(scores, 4))
print('평균 검증 정확도:', np.round(np.mean(scores), 4))

# (6) Exhaustive search over specified Hyper-parameter values for an estimator.

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

### parameter 들을 dictionary 형태로 설정
parameters = {'max_depth':[1,2,3], 'min_samples_split':[2,3]}

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)

# 붓꽃 Train 데이터로 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']]

print('GridSearchCV 최적 파라미터:', grid_dtree.best_params_)  # GridSearchCV는 있는 경우의 수를 다 해보는 것 
print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dtree.best_score_))

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