카테고리 보관물: Report

결정 트리와 불순도에 대한 궁금증

이 글은 세바스찬 라쉬카의 머신러닝 FAQ 글(Why are implementations of decision tree algorithms usually binary and what are the advantages of the different impurity metrics?)을 번역한 것입니다.

결정 트리 알고리즘은 왜 이진 트리로 구현되어 있을까요? 각 불순도 지표들의 장점은 무엇인가요?

현실적인 이유로(조합의 폭발적인 증가combinatorial explosion) 대부분의 라이브러리들은 결정 트리를 이진 트리로 구현합니다. 좋은 점은 이진 트리가 NP-완전 문제NP-complete라는 것입니다(Hyafil, Laurent, and Ronald L. Rivest. “Constructing optimal binary decision trees is NP-complete.” Information Processing Letters 5.1 (1976): 15-17.).

(CARTClassification And Regression Tree 알고리즘의) 목적 함수는 각 분할에서 정보 이득information gain(IG)을 최대화하는 것입니다:

IG(D_p, f) = I(D_p) - \sum_{j=1}^{m}\dfrac{N_j}{N}I(D_j)

는 분할에 사용되는 특성이고 D와 D는 각각 부모 노드와 번째 자식 노드의 데이터셋입니다. 는 불순도 지표입니다. N 은 샘플의 전체 개수이고 Njj 번째 자식 노드의 샘플 개수입니다. 이제 분류에서 가장 널리 사용되는 (CART 알고리즘의) 분할 기준을 살펴 보겠습니다. 간단하게 이진 분할로 식을 표현하지만 당연히 다중 분할로 일반화될 수 있습니다. 이진 분할에 대한 IG 는 다음과 같이 계산합니다:

IG(D_p, a) = I(D_p) - \dfrac{N_{left}}{N}I(D_{left}) - \dfrac{N_{right}}{N}I(D_{right})

이진 결정 트리에서 가장 널리 사용되는 불순도 지표 또는 분할 기준은 지니 불순도Gini impurity(IG)와 엔트로피Entropy(IH)와 분류 오차Classification Error(IE)입니다. 엔트로피의 정의부터 살펴보죠. 다음과 같습니다.

I_H(t) = - \sum_{i=1}^c p(i|t)\,log_2\,p(i|t)

클래스에 샘플이 하나라도 있다면

p(i|t) \ne 0

이고 p(i|t) 는 특정 노드 t 에서 클래스 c 에 속한 샘플의 비율입니다. 그러므로 한 노드의 샘플이 모두 동일한 클래스에 속한다면 엔트로피는 0입니다. 클래스 별로 균등하게 분포되어 있다면 당연하게 엔트로피는 최대가 됩니다. 지니 불순도는 잘 못 분류될 확률을 최소화시키려는 기준으로 생각할 수 있습니다.

I_G(t) = \sum_{i=1}^c p(i|t)(1-p(i|t)) = 1 - \sum_{i=1}^c p(i|t)^2

엔트로피와 비슷하게 지니 불순도는 클래스가 균일하게 섞여 있을 때 최대가 됩니다. 그러나 실제로 지니 불순도와 엔트로피는 매우 비슷한 결과를 만들며 불순도 기준을 사용하여 트리를 평가하는데 시간을 들이는 것보다 가지치기pruning 방식을 바꿔보는 것이 더 낫습니다. 또 다른 불순도 지표는 분류 오차입니다.

I_E = 1 - \text{max}\{ p(i|t) \}

가지치기에는 좋은 지표지만 노드의 클래스 확률 변화에 덜 민감하기 때문에 결정 트리를 구성하는데는 적합하지 않습니다.

overview-plot

분류 오차가 클래스 확률 변화에 왜 덜 민감한지 보기 위해 다음 그림에서 두 개의 분할 사례를 살펴 보겠습니다.

split

클래스 1에 40개의 샘플, 클래스 2에 40개의 샘플을 가진 부모 노드의 데이터셋 Dp 를 각각 두 개의 데이터셋 Dleft 와 Dright 로 나누었습니다. 분류 오차를 분할 기준으로 사용했을 때 정보 이득은 AB 의 경우 모두 같습니다(IGE = 0.25):

I_E(D_p) = 1 - \text{max}(0.5 + 0.5) = 0.5

A:

I_E(D_{left}) = 1 - \text{max}(0.75, 0.25) = 0.25

I_E(D_{right}) = 1 - \text{max}(0.25, 0.75) = 0.25

IG_E = 0.5 - \dfrac{40}{80}\times0.25-\dfrac{40}{80}\times0.25 = 0.25

B:

I_E(D_{left}) = 1 - \text{max}(\dfrac{20}{60},\dfrac{40}{60}) = \dfrac{1}{3}

I_E(D_{right}) = 1 - \text{max}(1, 0) = 0

IG_E = 0.5 - \dfrac{60}{80}\times\dfrac{1}{3}-\dfrac{20}{80}\times0 = 0.25

하지만 지니 불순도 기준의 IG는 A(0.125) 보다 B(0.1666) 가 더 순수하기 때문에 높습니다.

I_G(D_p) = 1 - (0.5^2 + 0.5^2) = 0.5

A:

I_G(D_{left}) = 1 - \left( \left(\dfrac{3}{4}\right)^2 + \left(\dfrac{1}{4}\right)^2 \right) = \dfrac{3}{8} = 0.375

I_G(D_{right}) = 1 - \left( \left(\dfrac{1}{4}\right)^2 + \left(\dfrac{3}{4}\right)^2 \right) = \dfrac{3}{8} = 0.375

IG_G = 0.5 - \dfrac{40}{80}\times0.375 - \dfrac{40}{80}\times0.375 = 0.125

B:

I_G(D_{left}) = 1 - \left( \left(\dfrac{2}{6}\right)^2 + \left(\dfrac{4}{6}\right)^2 \right) = \dfrac{4}{9}

I_G(D_{right}) = 1 - \left( \left(\dfrac{2}{2}\right)^2 + \left(\dfrac{0}{2}\right)^2 \right) = 1 - 1 = 0

IG_G = 0.5 - \dfrac{60}{80}\times\dfrac{4}{9} - \dfrac{40}{80}\times0 = 0.1666

비슷하게 엔트로피 기준은 A(0.19) 보다 B(0.31)를 선호합니다.

I_H(D_p) = - (0.5\,log_2\,(0.5) + 0.5\,log_2(0.5)) = 1

A:

I_H(D_{left}) = - \left( \dfrac{3}{4}\,log_2\left(\dfrac{3}{4}\right) + \dfrac{1}{4}\,log_2\left(\dfrac{1}{4}\right) \right) = 0.81

I_H(D_{right}) = - \left( \dfrac{1}{4}\,log_2\left(\dfrac{1}{4}\right) + \dfrac{3}{4}\,log_2\left(\dfrac{3}{4}\right) \right) = 0.81

IG_H = 1 - \dfrac{40}{80}\times0.81 - \dfrac{40}{80}\times0.81 = 0.19

B:

I_H(D_{left}) = - \left( \dfrac{2}{6}\,log_2\left(\dfrac{2}{6}\right) + \dfrac{4}{6}\,log_2\left(\dfrac{4}{6}\right) \right) = 0.92

I_H(D_{right}) = - \left( \dfrac{2}{2}\,log_2\left(\dfrac{2}{2}\right) + \dfrac{0}{2}\,log_2\left(\dfrac{0}{2}\right) \right) = 0

IG_G = 1 - \dfrac{60}{80}\times0.92 - \dfrac{40}{80}\times0 = 0.31

지니 불순도와 엔트로피에 대해 덧붙이자면 위에 언급한 것처럼 만들어진 트리는 실제 매우 비슷합니다. 지니 불순도의 장점은 로그를 계산할 필요가 없어서 구현 성능이 조금 더 낫다는 것입니다.

옮긴이: 위 그림을 보면 엔트로피보다 지니 불순도 방식이 불순도 값을 줄이기 위해 더 클래스 확률을 낮추어야 함을 알 수 있습니다. 즉 엔트로피 방식이 조금 더 균형잡힌 트리를 만들 가능성이 높습니다. scikit-learn의 DecisionTreeClassifier와 DecisionTreeRegressor 및 이들을 사용하는 랜덤 포레스트와 그래디언트 부스팅에서 특성 중요도 속성은(feature_importances_) 트리가 분할에 사용한 특성별로 발생되는 모든 정보 이득을 더하고 전체 특성 중요도의 합이 1이 되도록 정규화한 것입니다.

다중 평가 지표: cross_validate()

Scikit-Learn 0.19 버전에 추가된 새로운 기능 시리즈 마지막으로 다중 평가 지표에 대해 알아보겠습니다. 다중 평가 지표란 말 그대로 모델을 평가할 때 여러개의 지표를 이용할 수 있다는 뜻입니다. 0.19 버전에 새롭게 추가된 cross_validate() 함수가 이 기능을 제공합니다.

5.3.5절과 유사한 예제를 만들어 보겠습니다. 먼저 숫자 데이터셋을 불러들여 타깃을 9로 하는 이진 분류 문제로 데이터셋을 훈련 세트와 테스트 세트로 나눕니다.

digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(
    digits.data, digits.target == 9, random_state=42)

지금까지 교차 검증에 사용했던 cross_val_score() 함수를 훈련 세트에 적용해 보겠습니다. 분류 모델은 SVC()를 사용합니다.

사이킷런 0.20 버전에서 SVC ​클래스의 gamma 매개변수 옵션에 auto외에 scale이 추가되었습니다. auto는 1/n_features, 즉 특성 개수의 역수입니다. scale은 1/(n_features * X.std())로 스케일 조정이 되지 않은 특성에서 더 좋은 결과를 만듭니다. 사이킷런 0.22 버전부터는 gamma 매개변수의 기본값이 auto에서 scale로 변경됩니다. 서포트 벡터 머신을 사용하기 전에 특성을 표준화 전처리하면 scale과 auto는 차이가 없습니다. 경고를 피하기 위해 명시적으로 auto 옵션을 지정합니다.

사이킷런 0.22 버전에서 cross_val_score 함수와 GridSearchCV 클래스의 cv 매개변수 기본값이 3에서 5로 바뀔 예정입니다. 0.20 버전에서 cv 매개변수를 지정하지 않는 경우 이에 관한 경고 메세지가 출력됩니다. 경고 메세지를 피하기 위해 cv 매개변수 값을 명시적으로 3으로 지정합니다.

from sklearn.svm import SVC
cross_val_score(SVC(gamma='auto'), X_train, y_train, cv=3)
array([0.90200445, 0.90200445, 0.90200445])

cross_val_score() 함수는 scoring 매개변수에 원하는 평가 지표를 지정할 수 있습니다. 분류 문제일 경우 기본은 정확도를 의미하는 ‘accuracy’입니다. 따라서 다음 코드는 위와 동일한 결과를 출력합니다.

cross_val_score(SVC(gamma='auto'), X_train, y_train, scoring='accuracy' cv=3)

여러개의 평가 지표를 사용하려면 새롭게 추가된 cross_validate() 함수를 사용합니다. cross_val_score()와 마찬가지로 scoring 매개변수에서 평가 지표를 지정할 수 있습니다. 여러개의 평가 지표를 지정하려면 리스트로 만들어 전달하면 됩니다. 이 함수는 디폴트 설정에서 테스트 폴드에 대한 점수 뿐만 아니라 훈련 폴드에 대한 점수도 반환합니다. 향후 버전에서 기본으로 훈련 폴드 점수가 반환되지 않는다는 경고 메세지가 출력되므로 return_train_score 매개변수에서 명시적으로 훈련 폴드의 점수를 받을지 여부를 설정하는 것이 좋습니다.

from sklearn.model_selection import cross_validate
cross_validate(SVC(gamma='auto'), X_train, y_train, 
               scoring=['accuracy', 'roc_auc'], 
               return_train_score=True)
{'fit_time': array([0.07761502, 0.07732582, 0.07719207]),
 'score_time': array([0.06746364, 0.06803942, 0.06800795]),
 'test_accuracy': array([0.90200445, 0.90200445, 0.90200445]),
 'test_roc_auc': array([0.99657688, 0.99814815, 0.99943883]),
 'train_accuracy': array([1., 1., 1.]),
 'train_roc_auc': array([1., 1., 1.])}

이 함수는 각 폴드에서 훈련과 테스트에 걸린 시간을 반환하고 scoring 매개변수에 지정한 평가 지표마다 훈련 점수와 테스트 점수를 반환합니다. 훈련 점수와 테스트 점수를 반환된 딕셔너리에서 추출하려면 ‘train_XXXX’, ‘test_XXXX’와 같은 스타일의 키를 사용하면 됩니다.

사실 0.19 버전부터는 cross_val_score() 함수도 cross_validate()를 사용합니다. 그래서 다음 코드는 cross_val_score() 함수와 동일한 결과를 반환합니다.

cross_validate(SVC(gamma='auto'), X_train, y_train, 
               scoring=['accuracy'], cv=3,
               return_train_score=False)['test_accuracy']

cross_validate() 함수의 scoring 매개변수에 리스트 대신 딕셔너리로 평가 지표를 전달할 수 있습니다. 딕셔너리의 키는 임의의 문자열이 가능합니다. 이렇게 하면 결과 딕셔너리의 키 이름을 간략하게 나타낼 수 있습니다. 다음과 같이 씁니다.

cross_validate(SVC(gamma='auto'), X_train, y_train, 
               scoring={'acc':'accuracy', 'ra':'roc_auc'}, 
               return_train_score=False, cv=3)
{'fit_time': array([0.07760668, 0.07740569, 0.07696486]),
 'score_time': array([0.06791329, 0.06786489, 0.06783247]),
 'test_acc': array([0.90200445, 0.90200445, 0.90200445]),
 'test_ra': array([0.99657688, 0.99814815, 0.99943883])}

평가 지표 mean_squared_error 같이 긴 이름을 자주 참조해야 한다면 이름을 간소하게 나타내는 것이 좋을 것 같습니다.

다중 평가 지표는 cross_validate()는 물론 그리드서치에서도 사용할 수 있습니다. GridSearchCV()의 scoring 매개변수도 마찬가지로 리스트 또는 딕셔너리로 설정할 수 있습니다. 다만 평가 지표를 리스트나 딕셔너리로 설정하려면 refit 매개변수에서 어떤 평가 지표로 선택한 최종 모델을 학습할 것인지 지정해야 합니다.

param_grid = {'gamma': [0.0001, 0.01, 0.1, 1, 10]}
grid = GridSearchCV(SVC(), param_grid=param_grid, 
                    scoring=['accuracy'], refit='accuracy',
                    return_train_score=True, cv=3)
grid.fit(X_train, y_train)

최적의 파라미터와 교차 검증 점수를 출력해 보겠습니다.

grid.best_params_
{'gamma': 0.0001}
grid.best_score_
0.9651076466221232

gamma가 0.0001이 선택되었습니다. 전체 교차 검증 결과를 출력해 보기 위해서 판다스의 DataFrame으로 만든 다음 넘파이로 행과 열을 바꾸겠습니다(컬럼 제목을 좌측에 놓기 위해서입니다).

np.transpose(pd.DataFrame(grid.cv_results_))

스크린샷 2018-03-13 오후 4.34.44.png

확실히 gamma가 0.0001일 때 mean_test_accuracy가 가장 높습니다. 이제 roc_auc를 추가해 그리드서치를 실행해 보겠습니다.

grid = GridSearchCV(SVC(), param_grid=param_grid, 
                    scoring={'acc':'accuracy', 'ra':'roc_auc'}, refit='ra',
                    return_train_score=True, cv=3)
grid.fit(X_train, y_train)

최적의 파라미터와 교차 검증 점수를 출력합니다.

grid.best_params_
{'gamma': 0.01}
grid.best_score_
0.9983352038907595

앞에서와 같이 교차 검증 결과를 출력해 보겠습니다. accuracy와 roc_auc에 대해 모두 점수가 출력되므로 꽤 긴 출력이 됩니다. 위에서처럼 gamma가 0.0001일 때는 mean_test_acc가 가장 높지만 gamma가 0.01일 때는 mean_test_ra가 제일 높습니다. refit 매개변수를 ‘ra’로 주었기 때문에 최적 파라미터와 최종 모델은 gamma가 0.01입니다.

스크린샷 2018-03-13 오후 4.37.26

grid.best_estimator_
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma=0.01, kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

이 글의 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/cross_validate.ipynb)에서 확인할 수 있습니다.

MLPClassifier의 다중 레이블 분류

이 포스트는 “나이브”님이 메일로 문의 주신 내용을 바탕으로 작성되었습니다. “파이썬 라이브러리를 활용한 머신러닝” 2.3.8절의 신경망에 소개된 MLPClassifier 모델이 다중 분류Multi-class Classification, 다중 레이블 분류Multi-label Classification가 가능한지에 대해 문의를 주셨습니다. 책을 보니 공교롭게도 예제가 모두 이진 분류로 나와 있네요. 🙂

MLPClassifier는 다중 분류, 다중 레이블 분류를 지원합니다. 일반적으로 신경망에서 다중 분류를 구현하려면 출력층의 뉴런을 2개 이상 놓아야 합니다. MLPClassifier 클래스는 겉으로 드러나 있지는 않지만 타깃 배열 y의 차원을 보고 출력 뉴런의 개수를 자동으로 결정합니다. 간단한 예를 만들어 확인해 보겠습니다. 먼저 책에서 사용한 moons 데이터셋을 억지로 다중 분류를 위한 데이터셋으로 변경해 보겠습니다. 즉1차원 배열인 타깃값 y를 (100, 2) 2차원 배열로 만들어 사용합니다.

print(Y_train[:10])
array([[ 0.,  1.],
        [ 0.,  1.],
        [ 1.,  0.],
        [ 0.,  1.],
        [ 0.,  1.],
        [ 1.,  0.],
        [ 0.,  1.],
        [ 1.,  0.],
        [ 1.,  0.],
        [ 0.,  1.]])

그런 다음 책의 예제와 동일한 옵션으로 신경망을 학습시켜 보겠습니다. 타깃을 2차원 배열로 변형시켰기 때문에 y_train이 아니라 Y_train 처럼 대문자를 사용했습니다.

mlp_multi = MLPClassifier(solver='lbfgs', random_state=0).fit(X_train, Y_train)

mlp_multi

이 그래프를 아래 이진 분류의 경우와 비교해 보면 결정 경계가 조금 다른 것을 확인할 수 있습니다.

mlp_binary

MLPClassifier의 기본값은 100개의 뉴런을 가진 은닉층 하나를 사용합니다. 그림 2-47과 같은 신경망 구조를 상상해 보면, 마지막 출력층과 은닉층 사이의 연결(가중치)이 출력층의 뉴런의 개수가 하나일때와 두 개일때 달라질 것이라는 것을 눈치챌 수 있습니다. 이런 차이 때문에 결정 경계가 조금 달라졌습니다. 하지만 우리가 사용한 샘플 데이터는 그렇게 조밀하지 않으므로 변화된 결정 경계에 영향을 받지 않아 테스트 점수가 동일합니다.

mlp_multi.score(X_test, Y_test)
0.88

이번에는 다중 레이블 분류를 위해 ClassifierChain 예제에서 사용했던 Yeast 데이터셋을 이용해 보겠습니다. 이 데이터의 타깃값은 확실히 다중 레이블입니다.

Y_train[:10]
array([[ 1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 1.,  1.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,  0.,  0.,  0.,  0.,
          0.],
        [ 0.,  0.,  1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 0.,  1.,  1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 1.,  1.,  0.,  0.,  0.,  1.,  1.,  1.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 0.,  1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
          0.],
        [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,  0.,  0.,  0.,  0.,
          0.],
        [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.],
        [ 1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  1.,
          0.]])

입력의 특성이 103개이므로 뉴런과 은닉층의 개수를 조금 늘려 보겠습니다(300, 100). 그리고 기본 solver인 Adam 알고리즘을 사용하므로 최대 반복횟수(max_iter)를 기본값인 200에서 크게 증가시켜 주었습니다.

mlp_multilabel = MLPClassifier(hidden_layer_sizes=(300,100), max_iter=10000, 
                               random_state=42).fit(X_train, Y_train)
mlp_multilabel.score(X_test, Y_test)
0.16115702479338842

분류 모델의 score 메서드는 다중 레이블 분류를 지원하지 않습니다. 즉 행의 전체 원소가 모두 정확히 맞았을 때를 카운트합니다. ClassifierChain에서 처럼 자카드 유사도를 사용할 수 있지만 여기서는 하나 원소라도 맞았을 때를 수동으로 확인해 보겠습니다.

Y_pred = mlp_multilabel.predict(X_test)
np.sum(np.sum(Y_test.astype(int) & Y_pred, axis=1) > 0)/Y_test.shape[0]
0.85330578512396693

이 코드는 예측(Y_pred)을 만들어 테스트 데이터(Y_test)의 각 원소에 대해 논리 곱(AND) 연산을 합니다. 즉 두 행렬의 같은 위치의 원소가 모두 True일 때만 True가 됩니다. 그리고 난 후 True의 개수가 0 보다 큰 행의 개수를 카운트했습니다. 테스트 세트의 85%는 최소한 하나의 레이블 이상 맞았네요. 🙂

 

이 글의 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/MLP_Multilabel.ipynb)에서 확인할 수 있습니다.

분류기 체인: ClassifierChain

Scikit-Learn 0.19 버전에 추가된 기능으로 이번에 소개할 모델은 ClassifierChain입니다.

다중 레이블(Multi-Label) 문제를 직접 다룰 수 있는 모델도 있지만(가령, 랜덤 포레스트), 이진 분류기를 사용하여 다중 레이블 분류기를 구현하는 간단한 방법은 One-Vs-All 방식을 사용하는 것입니다. 이 예에서 사용할 데이터는 Yeast 데이터셋으로 2,417개의 샘플과 103개의 특성, 14개의 타깃 레이블(즉, 다중 레이블)을 가지고 있습니다.

import numpy as np
from sklearn.datasets import fetch_openml

yeast = fetch_openml('yeast', version=4)

X = yeast['data']
Y = yeast['target']

Y = Y == 'TRUE'

X와 행의 차원을 맞추기 위해 희소 행렬 Y를 전치하고 밀집 행렬로 변환합니다. 그러면 X는 (2417×103)인 행렬이고 Y는 (2417×14)인 행렬이 됩니다. 그 다음 훈련 데이터와 테스트 데이터로 나눕니다.

from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, 
                                                    random_state=42)

먼저 로지스틱 회귀을 사용해 OneVsRestClassifier 모델을 훈련시켜 보겠습니다.

from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier

ovr = OneVsRestClassifier(LogisticRegression(solver='liblinear'))
ovr.fit(X_train, Y_train)
pred_ovr = ovr.predict(X_test)

OneVsRestClassifier는 타깃 레이블의 개수 만큼 로지스틱 회귀 모델을 만들어 각 레이블을 타깃으로 하는 분류기를 학습시킵니다. 따라서 pred_ovr의 차원은 (2417×14)이 됩니다. 다중 레이블 분류에 사용되는 대표적인 측정 방법은 자카드 유사도(jaccard_similarity_score)입니다. 이 함수에 진짜 타깃 레이블과 예측 결과를 전달하면 0~1 사이의 값을 반환합니다. 1에 가까울수록 두 값이 비슷한 것입니다.

from sklearn.metrics import jaccard_similarity_score
ovr_score = jaccard_similarity_score(Y_test, pred_ovr)
ovr_score
0.50828086055358779

이번에는 ClassifierChain을 사용해 보겠습니다. 이 (메타) 분류기는 OneVsRestClassifier처럼 레이블마다 하나의 모델을 학습시키지만 타깃 레이블을 특성으로 사용합니다. 다중 레이블의 문제에서 종종 타깃은 서로에게 상관관계를 가집니다. 이런 경우 분류기 체인 방식을 사용하면 One-Vs-All 전략 보다 더 좋은 결과를 얻을 수 있습니다.

ClassifierChain은 먼저 첫 번째 레이블에 대해 이진 분류기를 학습시킵니다. 그 다음 두 번째 분류기를 학습시킬 때 첫 번째 레이블을 특성으로 포함시킵니다. 그 다음엔 첫 번째와 두 번째 레이블을 특성으로 포함시켜 세 번째 분류기를 학습시키는 식입니다. 이렇다 보니 레이블의 순서에 따라 결과가 달라질 수 있습니다. ClassifierChain의 order 매개변수 기본값은 Y 타깃값을 순서대로 사용하므로 이보다는 ‘random’으로 주는 것이 일반적입니다.

from sklearn.multioutput import ClassifierChain

cc = ClassifierChain(LogisticRegression(), order='random', random_state=42)
cc.fit(X_train, Y_train)
pred_cc = cc.predict(X_test)
cc_score = jaccard_similarity_score(Y_test, pred_cc)
cc_score
0.52203774760592925

예측을 만들 때는 체인 순서대로 첫 번째 분류기의 예측을 만들어 다음 분류기에서 특성으로 사용하고, 두 번째 분류기의 예측을 만들어 첫 번째 예측 결과와 함께 세 번째 분류기의 특성으로 사용하는 식으로 진행됩니다.

이번에는 random_state를 바꾸어 가면서 여러개의 ClassifierChain을 만들어 order=’random’일 때 미치는 영향을 살펴 보겠습니다. 다음 코드는 리스트 내포(list comprehension)를 사용하여 random_state 값을 바꾸면서 10개의 ClassifierChain을 만들고 자카드 점수를 계산하지만 기본적으로 위의 코드와 동일합니다.

chains = [ClassifierChain(LogisticRegression(), order='random', random_state=42+i)
          for i in range(10)]
for chain in chains:
    chain.fit(X_train, Y_train)

pred_chains = np.array([chain.predict(X_test) for chain in chains])
chain_scores = [jaccard_similarity_score(Y_test, pred_chain)
                    for pred_chain in pred_chains]
[0.52203774760592925,
 0.50759953430407978,
 0.54071149809786168,
 0.51879427390791022,
 0.51900088547815826,
 0.51148445792040831,
 0.52014626787354057,
 0.50362964056145876,
 0.50333366128820667,
 0.47443673750491933]

확실히 random_state에 따라 타깃값을 사용하는 순서가 바뀌기 때문에 성능이 들쭉 날쭉합니다. 다음 그래프에서 첫 번째 막대 그래프는 ovr_score이고 그 다음 10개의 그래프는 chain_scores입니다.

jaccard_bar1

어떤 순서로 레이블을 사용할지 사전에 알 수 없으므로 ClassifierChain의 앙상블을 만들어 사용하는 것이 좋습니다. 앙상블을 만들 때는 각 분류기 체인의 값을 평균내어 사용합니다. 분류기 체인의 예측 결과를 앙상블하는 것보다 예측 확률을 앙상블하는 것이 조금 더 안정적인 결과를 제공할 것으로 기대할 수 있습니다. 로지스틱 회귀는 predict_proba() 메서드를 제공하므로 간단하게 체인의 확률값을 얻을 수 있습니다. 앙상블의 평균을 낸 후에 이를 예측값으로 바꾸어 Y_test와 유사도를 측정하려면 앙상블의 평균 확률이 0.5 보다 큰지를 판단하면 됩니다.

proba_chains = np.array([chain.predict_proba(X_test) for chain in chains])
proba_ensemble = proba_chains.mean(axis=0)
ensemble_score = jaccard_similarity_score(Y_test, proba_ensemble >= 0.5)
0.51958792470156101

앙상블의 결과는 0.5196로 첫 번째 체인보다는 점수가 낮지만 가장 나쁜 체인의 점수에 비하면 비교적 높은 점수를 얻었습니다. 또 OneVsRestClassifier 보다 높은 점수를 얻었습니다. 다음 그래프의 첫 번째 막대 그래프는 ovr_score이고 그 다음 10개의 그래프는 chain_scores이며 마지막 막대 그래프가 앙상블의 결과입니다.

jaccard_bar2

이 글의 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/ClassifierChain.ipynb)에서 확인할 수 있습니다.

AWS 스팟 인스턴스 + Deep Learning AMI

AWS의 EC2 스팟spot 인스턴스와 함께 AWS 공식 Deep Learning AMI를 사용하는 법에 대해 간단히 따라가 보도록 하겠습니다. 이 글은 ‘홍대 머신러닝 스터디‘를 위해 작성되었습니다.

먼저 AWS 페이지에서 계정을 만들어야 합니다. 계정을 만들 때 향후 결재를 위해 신용카드 정보를 입력해야 하는 것외에는 특별한 것은 없습니다. 계정을 만들고 AWS 콘솔에 로그인해서 메뉴바에 서비스 드롭다운 메뉴를 펼쳐 EC2를 찾아 클릭합니다.

스팟 인스턴스는 왼쪽 메뉴 ‘스팟 요청’에서 할 수 있습니다. 그런데 웬일인지 이 메뉴를 통해 스팟 인스턴스를 요청할 때는 아마존의 Deep Learning AMI(서버 이미지)를 찾을 수가 없었습니다. 물론 직접 Nvidia 드라이버와 텐서플로를 설치해도 되지만 편리하게 제공해 주는 것을 마다할 이유는 없겠지요.

아마존의 Deep Learning AMI를 사용해서 스팟 인스턴스를 띄우려면 먼저 아래 그림과 같이 좌측의 ‘AMI’ 메뉴에서 가능합니다. 혹시 서울 리전이 아니더라도 크게 상관은 없습니다만 아래 화면과 다를 수 있습니다. 서울 리전은 오른쪽 위에서 이름 옆의 드롭다운에서 선택할 수 있습니다. 검색창의 드롭다운 메뉴를 ‘퍼블릭 이미지’로 바꾼 다음  ‘deep learning ami’를 찾습니다. 아마존 리눅스와 우분투가 있는데 여기서는 우분투 버전을 선택했습니다.

스크린샷 2018-01-17 오후 8.29.36

그 다음 ‘작업’ 버튼을 눌러 ‘스팟 요청’ 메뉴를 클릭합니다.

스크린샷 2018-01-17 오후 8.29.57

계속 읽기

QuantileTransformer

Scikit-Learn 0.19 버전에 추가된 기능 중 오늘은 QuantileTransformer() 변환기를 살펴 보겠습니다. 먼저 ‘파이썬 라이브러리를 활용한 머신러닝‘ 3장에 있는 스케일 조정의 예제와 비슷한 데이터 셋을 make_blobs 함수로 만들겠습니다. 여기서는 샘플 개수가 어느 정도 되어야 눈으로 확인하기 좋으므로 500개를 만들겠습니다.

X, y = make_blobs(n_samples=500, centers=2, random_state=4)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='black')

quantile-1

QuantileTransformer 는 지정된 분위수에 맞게 데이터를 변환합니다. 기본 분위수는 1,000개이며 n_quantiles 매개변수에서 변경할 수 있습니다. 여기서는 100개 정도로 지정해 보겠습니다.

quan = QuantileTransformer(n_quantiles=100)

fit() 메서드에서 입력 데이터의 범위를 분위수에 맞게 나누어 quantiles_ 속성에 저장합니다. 이를 위해 넘파이 percentile() 함수를 사용하여 분위에 해당하는 값을 손쉽게 구할 수 있습니다. QuantileTransformer 에는 기본값이 100,000인 subsample 매개변수가 있습니다.  만약 입력 데이터 개수가 subsample 보다 크면 계산량을 줄이기 위해 subsample 개수만큼 데이터를 샘플링하여 percentile() 함수를 적용합니다. percentile() 함수는 특성마다 각각 적용되므로 quantiles_ 속성의 크기는 [n_quantiles, X.shape[1]] 이 됩니다.

quan.fit(X)
print(quan.quantiles_.shape)
(100, 2)

transform() 메서드에서는 데이터를 quantiles_를 기준으로 하여 0~1 사이로 매핑합니다. 이를 위해 넘파이 interp() 함수를 사용합니다. 두 개의 특성이 모두 0~1 사이로 균등하게 나뉘어진 것을 그래프로 확인할 수 있습니다.

X_quan = quan.transform(X)
plt.scatter(X_quan[:, 0], X_quan[:, 1], c=y, edgecolors='black')

quantile-2

이런 변환은 RobustScaler와 비슷하게 이상치에 민감하지 않게 됩니다. 하지만 균등 분포라서 무조건 [0, 1] 사이로 클리핑합니다.

사실 transform() 메서드에서는 scipy.stats.uniform.ppf() 함수를 사용하여 균등 분포로 변환합니다. 하지만 interp() 함수에서 동일한 변환을 이미 하고 있기 때문에 효과가 없습니다. QuantileTransformer 에서 output_distribution=’normal’ 로 지정하면 scipy.stats.norm.ppf() 함수를 사용하여 정규 분포로 변환합니다.

quan = QuantileTransformer(output_distribution='normal', n_quantiles=100)
X_quan = quan.fit_transform(X)
plt.scatter(X_quan[:, 0], X_quan[:, 1], c=y, edgecolors='black')

quantile-3

변환된 데이터는 평균이 0, 표준편차가 1인 정규 분포임을 확인할 수 있습니다.

X_quan.mean(axis=0), X_quan.std(axis=0)
(array([-0.00172502, -0.00134149]), array([ 1.0412595 ,  1.03818794]))

StandardScaler 와 비교해 보면 평균 과 표준편차는 같지만 정규 분포를 따르지 않는 분포에서 차이를 확인할 수 있습니다. 🙂

from sklearn.preprocessing import StandardScaler
X_std = StandardScaler().fit_transform(X)
plt.scatter(X_std[:, 0], X_std[:, 1], c=y, edgecolors='black')

quantile-4

이 글의 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/QuantileTransformer.ipynb)에서 확인할 수 있습니다.

반복 교차 검증

Scikit-Learn 0.19 버전에서 추가된 기능 중 이번에는 모델 선택 패키지 하위에 있는 RepeatedKFold와 RepeatedStratifiedKFold를 알아 보겠습니다. 이 두 클래스는 각각 KFold와 StratifiedKFold를 감싸고 있는 래퍼 클래스처럼 보아도 무방합니다. 데이터셋의 크기가 크지 않을 경우, LOOCV를 사용하기에는 결과가 불안정해서 교차 검증을 반복적으로 여러번 수행하곤 합니다. 0.19 버전에서는 이런 반복적인 교차 검증을 수행할 수 있는 두 개의 클래스를 추가하였습니다.

RepeatedKFold와 RepeatedStratifiedKFold를 사용하는 방법은 다른 분할 클래스들과 매우 비슷합니다. 이 클래스들은 폴드를 한번만 나누는 것이 아니고 지정한 횟수(n_repeats)만큼 반복해서 나누게 되고 교차 검증 점수도 반복한 만큼 얻을 수 있습니다. 이때 기본적으로 랜덤하게 나누므로 분할기에 자동으로 Shuffle=True 옵션이 적용됩니다. n_repeats의 기본값은 10입니다.

붓꽃 데이터셋으로 이 클래스들을 사용해서 교차 검증을 해 보겠습니다.

사이킷런 0.19 버전 이하에서는 LinearSVCliblinear를 사용하는 LogisticRegressionverbose 매개변수가 0이 아니고 max_iter 반복 안에 수렴하지 않을 경우 반복 횟수를 증가하라는 경고 메세지가 나옵니다. 사이킷런 0.20 버전부터는 verbose 매개변수에 상관없이 max_iter 반복 안에 수렴하지 않을 경우 반복 횟수 증가 경고가 나옵니다. 경고 메세지를 피하기 위해 max_iter 매개변수의 기본값을 증가시킵니다.

향후 사이킷런 0.22 버전에서 LogisticRegression 클래스의 solver 매개변수 기본값이 liblinear에서 lbfgs로 변경될 예정입니다. 사이킷런 0.20 버전에서 solver 매개변수를 지정하지 않는 경우 이에 대한 경고 메세지를 출력합니다. 경고 메세지를 피하고 향후 변경될 내용을 적용하기 위하여 solver 매개변수를 lbfgs로 설정합니다.

사이킷런 0.20 버전에서 LogisticRegressionmulti_class 매개변수 옵션에 auto가 추가되었습니다. auto로 설정하면 이진 분류이거나 solverliblinear일 경우에는 ovr을 선택하고 그 외에는 multinomial을 선택합니다. 사이킷런 0.22 버전부터는 multi_class 매개변수의 기본값이 ovr에서 auto​로 변경됩니다. 경고 메세지를 피하기 위해 명시적으로 ovr 옵션을 지정합니다.

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score, KFold, StratifiedKFold
from sklearn.linear_model import LogisticRegression

iris = load_iris()
logreg = LogisticRegression(solver='liblinear', multi_class='auto', max_iter=1000)

먼저 가장 기본이 되는 KFold를 사용한 교차 검증입니다.

kfold = KFold(n_splits=5)
scores = cross_val_score(logreg, iris.data, iris.target, cv=kfold)
scores, scores.mean()
(array([ 1.        ,  0.93333333,  0.43333333,  0.96666667,  0.43333333]),
 0.7533333333333333)

iris 데이터셋은 타깃값의 순서대로 훈련 데이터가 정렬되어 있기 때문에 기본 KFold에서는 교차 검증 점수가 매우 들쭉 날쭉 합니다.

이번엔 RepeatedKFold를 사용해 보겠습니다. 사용법은 KFold와 같지만 반복 횟수(n_repeats)를 설정해 주고 결과를 일정하게 고정하기 위해 random_state를 지정했습니다.

from sklearn.model_selection import RepeatedKFold
rkfold = RepeatedKFold(n_splits=5, n_repeats=5, random_state=42)
scores = cross_val_score(logreg, iris.data, iris.target, cv=rkfold)
scores, scores.mean()
(array([ 1.        ,  0.93333333,  0.9       ,  0.96666667,  0.96666667,
         0.96666667,  0.93333333,  1.        ,  1.        ,  0.83333333,
         0.93333333,  0.9       ,  0.96666667,  0.9       ,  0.93333333,
         0.96666667,  1.        ,  0.96666667,  0.93333333,  0.93333333,
         0.96666667,  0.9       ,  1.        ,  0.93333333,  0.93333333]),
 0.94666666666666677)

교차 검증 점수가 반복 횟수만큼 5개 행으로 출력되었습니다. 이전 보다 훨씬 고른 점수 분포를 보여 주며 전체 점수의 평균은 0.95 정도입니다. 교차 검증 점수의 범위를 박스플롯으로 가늠해 볼 수 있습니다.

boxplot1

다음엔 계층별 교차 검증인 StratifiedKFold를 적용해 보겠습니다.

skfold = StratifiedKFold(n_splits=5)
scores = cross_val_score(logreg, iris.data, iris.target, cv=skfold)
scores, scores.mean()
(array([ 1.        ,  0.96666667,  0.93333333,  0.9       ,  1.        ]),
 0.96000000000000019)

StratifiedKFold는 타깃값 클래스 비율을 고려하므로 전체적으로 고르게 폴드를 나누어서 교차 검증 점수가 안정되었습니다. 그럼 RepeatedStratifiedKFold를 사용해서 비교해 보겠습니다.

from sklearn.model_selection import RepeatedStratifiedKFold
rskfold = RepeatedStratifiedKFold(n_splits=5, n_repeats=5, random_state=42)
scores = cross_val_score(logreg, iris.data, iris.target, cv=rskfold)
scores, scores.mean()
(array([ 0.96666667,  0.96666667,  0.96666667,  0.93333333,  0.96666667,
         0.86666667,  0.96666667,  0.96666667,  0.93333333,  0.96666667,
         1.        ,  1.        ,  0.93333333,  0.93333333,  0.93333333,
         1.        ,  0.96666667,  0.96666667,  0.9       ,  0.96666667,
         0.96666667,  0.96666667,  0.96666667,  0.9       ,  0.96666667]),
 0.95466666666666655)

평균 교차 검증 점수는 0.955 정도로 RepeatedKFold와 StratifiedKFold의 중간에 해당하는 값입니다. 박스 플롯 끼리 비교해 보면 거의 비슷하지만 RepeatedStratifiedKFold가 약간 더 집중되어 있음을 알 수 있습니다.

boxplot2.png

이 두 클래스가 더욱 유용해질 때는 그리드서치에 사용할 때 입니다. cross_val_score와 마찬가지로 GridSearchCV의 분할은 회귀일 때는 KFold, 분류일 때는 StratifiedKFold가 기본입니다. 자원이 허락된다면 RepeatedKFold와 RepeatedStratifiedKFold로 바꾸지 않을 이유가 없습니다.

앞에서는 책의 예제와 비슷한 모양을 갖추기 위해 데이터셋을 나누지 않았습니다. 여기서는 훈련 데이터와 테스트 데이터로 나누고 RepeatedStratifiedKFold를 그리드서치에 적용해 보겠습니다.

사이킷런 0.22 버전부터는 GridSearchCV와 RandomizedSearchCV의 iid 매개변수 기본값이 True에서 False로 바뀝니다. 0.24 버전에서는 이 매개변수가 아예 삭제될 예정입니다. iid 매개변수가 True이면 독립 동일 분포라고 가정하고 테스트 세트의 샘플 수로 폴드의 점수를 가중 평균합니다. False로 지정하면 단순한 폴드 점수의 평균입니다. False일 때 기본 교차 검증과 동작 방식이 같습니다. 사이킷런 0.20 버전에서 iid 매개변수가 기본값일 때 가중 평균과 단순 평균의 차이가 10^-4 이상이면 경고 메세지가 발생합니다. 경고 메세지를 피하고 향후 변경될 방식을 사용하기 위해 GridSearchCV의 iid 매개변수를 False로 설정합니다

from sklearn.model_selection import GridSearchCV, train_test_split
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=42)
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
grid = GridSearchCV(logreg, param_grid, cv=rskfold, return_train_score=True, iid=False)
grid.fit(X_train, y_train)
grid.score(X_test, y_test), grid.best_params_, grid.best_score_

테스트 점수는 완벽하고 규제 매개 변수 C의 최적값은 100이 선택되었습니다. 교차 검증 최고 점수는 0.96 입니다.

(1.0, {'C': 100}, 0.96250000000000002)

cv_results_에 있는 교차 검증 결과를 출력해 보면 훈련과 테스트에 대해 모두 5번 반복해서 각각 25개의 점수가 있는 것을 확인할 수 있습니다.

for k in grid.cv_results_:
    if 'split' in k:
    print(k, grid.cv_results_[k])

내용이 장황하므로 일부만 추렸습니다. 전체 출력 내용은 깃허브를 참고해 주세요.

split21_test_score [ 0.34782609  0.65217391  0.82608696  0.91304348  0.86956522  0.91304348
  0.86956522]
split6_test_score [ 0.34782609  0.65217391  0.7826087   0.91304348  0.95652174  0.95652174
  0.95652174]
split24_train_score [ 0.34065934  0.64835165  0.83516484  0.94505495  0.96703297  0.96703297
  0.96703297]
split3_train_score [ 0.34444444  0.65555556  0.82222222  0.95555556  0.96666667  0.96666667
  0.96666667]
...
split16_test_score [ 0.34782609  0.65217391  0.91304348  0.95652174  0.95652174  1.
  0.95652174]
split23_test_score [ 0.31818182  0.63636364  0.77272727  0.95454545  0.95454545  0.95454545
  0.95454545]
split1_test_score [ 0.34782609  0.65217391  0.86956522  0.82608696  0.91304348  0.95652174
  1.        ]
split18_train_score [ 0.34444444  0.65555556  0.82222222  0.95555556  0.96666667  0.96666667
  0.96666667]

폴드 분할을 여러번 반복하여 그리드서치의 결과를 조금 더 안정적으로 만들 수 있을 것 같습니다. 반복 횟수가 클수록 훈련 시간은 느려지게 되므로 파이프라인 캐싱을 활용하고 가용한 자원내에서 반복을 수행하는 것이 좋을 것 같습니다.

이 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/RepeatedKFold.ipynb)에서 확인할 수 있습니다.

New SAGA solver

scikit-learn 0.19 버전에서 추가된 기능 중 SAGA 알고리즘에 대해 살펴 보겠습니다. SAGA는 SAGStochastic Average Gradient 알고리즘의 변종, 혹은 개선 버전입니다(SAGA의 A가 특별한 의미가 있는 것은 아닙니다). SAG 알고리즘은 이전 타임스텝에서 계산된 그래디언트를 모두 평균내어 적용하는 알고리즘입니다. 기본 공식은 일반적인 SGDStochastic Gradient Descent과 비슷합니다. 다만 이전에 계산했던 그래디언트를 저장하고 다시 활용한다는 측면에서 SGD와 배치 그래디언트 디센트의 장점을 취하고 있습니다.

w^{k+1} = w^k - \dfrac{\alpha}{n} \left( f'_j(w^k)-f'_j(\theta_j^k)+\sum_{i=1}^{n}f'_i(\theta_i^k) \right)

첨자가 조금 장황해 보일 수 있지만 사실 특별한 내용은 아닙니다. 이전까지의 그래디언트를 모두 누적하고 있는 항이 \sum_{i=1}^{n}f'_i(\theta_i^k)입니다. 그리고 현재 스텝에서 구한 그래디언트를 f'_j(w^k) 더하되 혹시 이전에 누적된 것에 포함이 되어 있다면, 즉 랜덤하게 추출한 적이 있는 샘플이라면 이전의 그래디언트 값을 f'_j(\theta_j^k) 빼 줍니다. 혼돈을 줄이기 위해 현재의 스텝의 파라미터와 이전의 스텝의 파라미터를 w\theta로 구별하였습니다.

SAGA 알고리즘은 여기에서 과거 그래디언트에만 평균을 적용하는 방식입니다. 위 공식과 비교해 보시면 금방 눈치챌 수 있습니다.

w^{k+1} = w^k - \alpha \left( f'_j(w^k)-f'_j(\theta_j^k)+\dfrac{1}{n}\sum_{i=1}^{n}f'_i(\theta_i^k) \right)

SAGA 알고리즘은 Ridge, RidgeClassifier, LogisticRegression 등에 solver 매개변수를 ‘saga’로 설정하여 사용할 수 있습니다. 이 모델들은 대량의 데이터셋에서 SAG 알고리즘을 사용할 수 있었는데 SAGA가 SAG 보다 성능이 좋으므로 데이터셋이 클 경우 SAGA를 항상 사용하는 것이 좋을 것 같습니다. 그럼 예를 살펴 보겠습니다.

먼저 익숙한 cancer 데이터셋에서 로지스특회귀로 SAG와 SAGA를 비교해 보겠습니다.

logreg_sag = LogisticRegression(solver='sag', max_iter=10000)
logreg_sag.fit(X_train, y_train)
print("훈련 세트 점수: {:.3f}".format(logreg_sag.score(X_train, y_train)))
print("테스트 세트 점수: {:.3f}".format(logreg_sag.score(X_test, y_test)))
훈련 세트 점수: 0.927
테스트 세트 점수: 0.930

다음은 SAGA solver일 경우입니다.

logreg_saga = LogisticRegression(solver='saga', max_iter=10000)
logreg_saga.fit(X_train, y_train)
print("훈련 세트 점수: {:.3f}".format(logreg_saga.score(X_train, y_train)))
print("테스트 세트 점수: {:.3f}".format(logreg_saga.score(X_test, y_test)))
훈련 세트 점수: 0.920
테스트 세트 점수: 0.937

둘이 거의 비슷하지만 SAGA의 테스트 점수가 조금 더 좋습니다. 좀 더 큰 데이터셋에 적용해 보기 위해서 캘리포니아 주택 가격 데이터셋을 사용해 보겠습니다. 이 데이터셋은 8개의 특성을 가지고 있고 2만개가 넘는 샘플을 가지고 있습니다. 타깃값은 평균 주택 가격입니다. scikit-learn에 이 데이터를 다운 받아 로드할 수 있는 함수가 있습니다.

from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()

housing도 scikit-learn의 다른 샘플 데이터와 동일하게 Bunch 클래스의 객체입니다. 데이터를 분할하고 릿지 회귀를 사용하여 이전과 마찬가지로 ‘sag’와 ‘saga’를 비교해 보겠습니다.

X_train, X_test, y_train, y_test = train_test_split(
    housing.data, housing.target, random_state=42)
ridge = Ridge(solver='sag').fit(X_train, y_train)
print("훈련 세트 점수: {:.3f}".format(ridge.score(X_train, y_train)))
print("테스트 세트 점수: {:.3f}".format(ridge.score(X_test, y_test)))
훈련 세트 점수: 0.061
테스트 세트 점수: 0.062

이번에는 SAGA solver 입니다.

ridge_saga = Ridge(solver='saga').fit(X_train, y_train)
print("훈련 세트 점수: {:.3f}".format(ridge_saga.score(X_train, y_train)))
print("테스트 세트 점수: {:.3f}".format(ridge_saga.score(X_test, y_test)))
훈련 세트 점수: 0.035
테스트 세트 점수: 0.036

확실히 SAGA solver의 R2 스코어가 더 낮게 나온 것을 알 수 있습니다. 🙂

이 샘플 코드는 ‘파이썬 라이브러리를 활용한 머신러닝‘ 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/SAGA%20solver.ipynb)에서 확인할 수 있습니다.

참고 자료

Pipeline에서 캐싱을 사용하기

며칠전 ‘파이썬 라이브러리를 활용한 머신러닝‘의 원저자 안드리아스 뮐러가 한 유투브 채널에 나와 Scikit-Learn의 0.19버전에서 추가된 기능과 0.20에서 추가될 내용을 소개했습니다.

0.19에 새롭게 추가된 기능으로 대표적으로 언급한 것이 Pipeline 캐싱, SAGA solver, RepeatedKFold, QuantileTransformer, ClassifierChain, 다중 scoring 설정입니다. 또 0.20에 추가될 기능으로는 GradientBoosting의 early stopping, CategoricalEncoder, PowerTransfomer, ColumnTransformer, OpenML 데이터셋 로더, matplotlib 기반의 트리 그래프 등입니다. 시간날 때마다 차례대로 살펴 보도록 하겠습니다. 먼저 오늘은 파이프라인 캐싱입니다!

파이프라인 캐싱은 파이프라인의 단계마다 transformer의 fit 결과를 저장하여 다시 사용한다는 것입니다. 전처리 단계가 복잡한 그리드서치를 사용할 때 특히 유용할 수 있습니다. 어 그럼 지금까지는 캐싱없이 무식하게 반복적으로 전처리를 매번 다시 했다는 건가요? 네 맞습니다. ㅠ.ㅠ

캐싱을 사용하려면 Pipeline 클래스의 memory 매개변수에 캐싱에 사용할 디렉토리를 지정하기만 하면 됩니다. 간단한 예를 살펴 보겠습니다. 책의 예제와 비슷하게 보스턴 주택가격 데이터셋을 로드하여 훈련 데이터를 준비하고 매개변수 탐색을 위한 그리드를 정의합니다.

boston = load_boston()
X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target,
                                                    random_state=0)
param_grid = {'polynomialfeatures__degree': [1, 2, 3, 4, 5],
              'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]}

그 다음은 파이프라인을 만들고 GridSearchCV로 매개변수 탐색을 하면 됩니다. 파이프라인 클래스를 사용해서 Pipeline(memory=’…’)와 같이 사용해도 되고 파이프라인을 간단하게 만들어 주는 make_pipeline(memory=’…’) 함수를 사용할 수도 있습니다. 캐싱에 사용할 임시 디렉토리를 지정해 주기위해 mkdtemp와 rmtree 함수를 임포트하고 임시 디렉토리를 만듭니다.

from tempfile import mkdtemp
from shutil import rmtree
cache_dir = mkdtemp()

다음 make_pipeline으로 파이프라인 단계를 만들고 GridSearchCV로 매개변수 탐색을 합니다.

사이킷런 0.22 버전부터는 GridSearchCVRandomizedSearchCViid 매개변수 기본값이 True에서 False로 바뀝니다. 0.24 버전에서는 이 매개변수가 아예 삭제될 예정입니다. iid 매개변수가 True이면 독립 동일 분포라고 가정하고 테스트 세트의 샘플 수로 폴드의 점수를 가중 평균합니다. False로 지정하면 단순한 폴드 점수의 평균입니다. False일 때 기본 교차 검증과 동작 방식이 같습니다. 사이킷런 0.20 버전에서 iid 매개변수가 기본값일 때 가중 평균과 단순 평균의 차이가 10^-4 이상이면 경고 메세지가 발생합니다. 경고 메세지를 피하고 향후 변경될 방식을 사용하기 위해 GridSearchCViid 매개변수를 False로 설정합니다

pipe = make_pipeline(StandardScaler(), PolynomialFeatures(), Ridge(),
                     memory=cache_dir)
grid = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1, iid=False)
grid.fit(X_train, y_train)

간단하죠? 작업이 끝나고 난 뒤에는 임시 디렉토리를 지워 줍니다.

rmtree(cache_dir)

전처리 단계가 복잡하고 많을 수록 캐싱의 효과는 큽니다. 이 샘플 코드를 캐싱을 사용하지 않고 실행했을 때와 비교하면 10.7초에서 6.57초로 30%이상 속도가 빨라 졌습니다!

이 포스트에 사용한 전체 코드는 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/Pipeline-cache.ipynb)에서 확인할 수 있습니다.

더욱 랜덤한 포레스트-익스트림 랜덤 트리(ExtraTreesClassifier)

파이썬 라이브러리를을 활용한 머신러닝‘ 2장의 지도학습에서 대표적인 앙상블 모델로 랜덤 포레스트를 소개하고 있습니다. 랜덤 포레스트는 부스트랩 샘플과 랜덤한 후보 특성들을 사용해 여러개의 결정 트리decision tree를 앙상블 합니다. 그래서 훈련 데이터에 과대적합을 막아주고 모델의 일반화 성능이 항상 단일 트리보다 높습니다. 랜덤 포레스트 모델의 변종으로 익스트림 랜덤 트리extremely randomized trees 혹은 엑스트라 트리ExtraTrees라 부르는 모델이 있습니다. 엑스트라 트리는 포레스트 트리의 각 후보 특성을 무작위로 분할하는 식으로 무작위성을 증가 시킵니다. Scikit-Learn은 앙상블 패키지 안에 엑스트라 트리 모델을 제공합니다.

from sklearn.ensemble import ExtraTreesClassifier

​RandomForestClassifier 클래스가 사용하는 결정 트리는 DecisionTreeClassifier입니다. 이에 반해 ExtraTreesClassifier가 사용하는 결정 트리는 ExtraTreeClassifier입니다. 이름이 매우 비슷하니 유의하세요. ExtraTreesClassifier의 매개변수는 RandomForestClassifier와 동일합니다. 책에서와 같이 make_moons 데이터셋에 엑스트라 트리를 학습시켜 보겠습니다.

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, 
                                                    random_state=42)

xtree = ExtraTreesClassifier(n_estimators=5, random_state=2)
xtree.fit(X_train, y_train)

엑스트라 트리가 사용하는 ExtraTreeClassifier()의 기본값으로 베이스 트리가 만들어 집니다. 랜덤 포레스트와 같이 베이스 모델을 직접 만들어 주입할 수는 없습니다. 엑스트라 트리가 만든 베이스 트리와 전체의 결정 경계를 그려 보겠습니다.

extratrees

그래프에서 볼 수 있듯이 랜덤 포레스트가 만든 것보다 두 클래스의 경계를 잘 구분하고 있습니다. 사실 엑스트라 트리의 베이스 트리인 ExtraTreeClassifier는 DecisionTreeClassifier를 상속한 것이며 splitter=’best’가 아니고 splitter=’random’인 것과 max_features=’auto’인 것을 제외하고는 동일합니다.

이번에는 cancer 데이터셋에 적용해 보겠습니다.

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, 
                                                    random_state=0)
xtree = ExtraTreesClassifier(n_estimators=100, random_state=0)
xtree.fit(X_train, y_train)

print("훈련 세트 정확도: {:.3f}".format(xtree.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(xtree.score(X_test, y_test)))

훈련 세트 정확도: 1.000
테스트 세트 정확도: 0.972

훈련 세트와 테스트 세트에서의 정확도는 랜덤 포레스트와 동일합니다. 하지만 특성 중요도를 그려보면 차이점을 발견할 수 있습니다.

extratree_feature_importance_

이 그래프에서 볼 수 있듯이 엑스트라 트리가 랜덤 포레스트 보다 전반적으로 특성의 중요도를 더 높게 평가하고 있습니다. 이는 엑스트라 트리가 더 폭넓은 시각으로 특성들을 평가한다고 생각할 수 있습니다. 단일 결정 트리에서는 ‘worst radius’가 거의 독점적으로 주요한 특성으로 평가되었지만 랜덤 포레스트는 ‘worst perimeter’가 더 높았고 ‘worst area’는 훨씬 더 낮게  나왔습니다. 이에 비해 엑스트라 트리는 ‘worst area’, ‘worst perimeter’, ‘worst radius’, ‘mean concavity’ 등의 특성 중요도가 비교적 고르게 나온 것을 볼 수 있습니다.

당연히 회귀에 대응하는 엑스트라 트리인 ExtraTreesRegressor도 있습니다. ExtraTreesClassifier와 ExtraTreesRegressor의 매개변수 기본값은 부스트랩 샘플을 사용하지 않도록 bootstrap=False인 것을 제외하고는 랜덤 포레스트와 동일합니다. 이 포스트의 코드는 깃허브(https://github.com/rickiepark/introduction_to_ml_with_python/blob/master/ExtraTreesClassifier.ipynb)에서 확인하실 수 있습니다.