[혼공머신] 05. 트리 알고리즘

캔에 인쇄된 알코올, 도수, 당도, pH 값으로 와인 종류 구별

 

---

로지스틱 회귀로 와인 분류하기

species 열에서 고유값 추출

## 로지스틱 회귀로 와인 분류하기

import pandas as pd
wine = pd.read_csv('https://bit.ly/wine-date')

 

샘플 확인 - head

* head() : 처음 n개의 샘플 확인 (기본값 5)

wine.head()

처음 3개 열(alchol, sugar pH) - 각각 알코올 도수, 당도, pH값 나타냄

네 번째 열(class) 타깃값 - 0 레드와인, 1 화이트 와인

-> 레드와인 vs 화이트 아인 구분하는 이진 분류

화이트 와인이 양성 클래스 -> 전체 와인 데이터에서 화이트 와인 골라내는 문제

 

 

샘플 확인 - info

* info() : 데이터프레임의 각 열의 데이터 타입과 누랍된 데이터가 있는지 확인

wine.info()

샘플 - 6497개     /    열 - 4개 (모두 실수값)    /    non-null count가 6497개 -> 누락된 값 없음

 

 

샘플 확인 - describe()

* describe() : 열에 대한 간략한 통계 출력. 최소, 최대, 평균값 등을 볼 수 있음

wine.describe()

평균(mean), 표준편차(std), 최소(min), 최대(max), 중간값(50%), 1사분위수(25%), 3사분위수(75%) 출력

-> 알코올 도수와 당도, pH 값의 스케일이 다름 -> StandardScaler 클래스 사용 특성 표준화 필요

 

 

판다스 데이터프레임 -> 넘파이 배열 변환

wine 데이터프레임에서 처음 3개 열 넘파이 배열로 바꿔서 data 저장,

마지막 class열 넘파이 배열로 바꿔서 target 배열에 저장

data = wine[['alcohol','sugar','pH']].to_numpy()
target = wine['class'].to_numpy()

 

훈련 세트와 테스트 세트 나누기

sklearn.model_select 아래 train_test_split

* train_test_split() : 훈련세트, 테스트 세트로 나눔  ( test_size 테스트 세트 지정, 지정 x - 25% )

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(data, target, test_size=0.2, random_state=42)

 

훈련 세트와 테스트 세트 크기 확인

* shape : 크기 확인

print(train_input.shape, test_input.shape)

(5197, 3) (1300, 3)   -> 훈련 세트 5197개  /  테스트 세트 1300개

 

 

전처리

* sklearn.preprocessing 안의 StandardScaler : 전처리

from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

 

 

로지스틱 회귀 모델 훈련

* sklearn.linear_model  안의 LogisticRegression

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(train_scaled, train_target)
print(lr.score(train_scaled, train_target))
print(lr.score(test_scaled, test_target))

0.7808350971714451

0.7776923076923077

-> 훈련세트, 테스트 세트 점수 모두 낮음 -> 과소적합

 

 

계수, 절편 출력

로지스틱 회귀가 학습한 계수와 절편 출력

* .coef_ : 계수

* .intercept_ : 절편

print(lr.coef_, lr.intercept_)

[[ 0.51270274 1.6733911 -0.68767781]] [1.81777902]

 

이 모델은 알코올 도수에 0.51270274를 곱하고, 당도에 1.6733911을 곱하고, pH에 -0.68767781을 곱한 다음 모두 더한다. 마지막으로 1.81777902를 더한다. 이 값이 0보다 크면 화이트 와인, 작으면 레드와인이다. 현재 약 77% 정확도로 화이트 와인을 분류했다......  ~~~~~~~>  보고서 이해 불가! 로지스틱 회귀는 설명이 어려움!

 

---

 

05-1. 결정트리

모델이 이유를 설명하기 쉬움

결정 트리 질문을 하나씩 던져서 정답을 맞춰나간다 (=스무고개)

데이터를 잘 나눌 수 있는 질문을 찾는다면 계속 질문을 추가해서 분류 정확도 높일 수 있음

 

결정트리 모델 훈련

* sklearn.tree 안에 DecisionTreeClassifier 클래스 사용

* fit() : 모델 훈련

* score() : 정확도 평가

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(train_scaled, train_target)
print(dt.score(train_scaled, train_target)) # 훈련 세트
print(dt.score(test_scaled, test_target))   # 테스트 세트

0.996921300750433

0.8592307692307692

-> 훈련 세트 점수 엄청 높음 -> 과대적합

 

 

결정트리 모델 훈련

* plot_tree() : 결정 트리를 이해하기 쉬운 트리 그림으로 출력

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
plt.figure(figsize=(10, 7))
plot_tree(dt)
plt.show()

결정트리는 위에서부터 아래로 거꾸로 자라남

노드 : 결정 트리를 구성하는 핵심 요소, 훈련 데이터의 특성에 대한 테스트를 표현

루트 노드 : 맨 위의 노드    /  리프 노드 : 맨 아래 끝에 달린 노드

가지 : 테스트의 결과(Ture, False)

일반적으로 하나의 노드는 2개의 가지 가짐

 

 

트리 깊이 제한 출력

* max_depth : 깊이 (1 - 루프 노드를 제외하고 하나의 노드를 더 확장)

* filled : 클래스에 맞게 노드 색칠

* feature_names : 특성의 이름 전달

plt.figure(figsize=(10,7))
plot_tree(dt, max_depth=1, filled=True, feature_names=['alcohol', 'sugar', 'pH'])
plt.show()

 

> 그림이 담고 있는 정보

 

루프노드 당도 -0.239 이하인지 질문

-0.239와 같거나 작으면 왼쪽 가지(yes)

그렇지 않으면 오른쪽 가지(no) 이동

 

루프노드 샘플수 = 5197

이 중에서 음성클래스(레드와인) 1258개, 양성클래스(화이트와인) 3939개

 

* plot_tree() 함수에서 filled=True로 지정하면 클래스마다 색깔을 부여,

                 어떤 클래스의 비율이 높아지면 점점 진한 색으로 표시

 

리프 노드에서 가장 많은 클래스 ->예측 클래스

 

불순도

gini 지니 불순도

 

* criterion : 노드에서 데이터를 분할할 기준 정함

                  DecisionTreeClassifier 클래스의 criterion 매개변수 기본값 'gini'

 

지니 불순도는 클래스의 비율을 제곱해서 더한 다음 1에서 빼면 됨

지니 불순도 = 1 - (음성 클래스 비율^2 + 양성 클래스 비율^2)

 

ex)  루트 노드의 지니 불순도 계산

샘플 총 5197개, 음성 클래스 1258개, 음성 클래스 3939개

루프노드 지니 불순도 = 1 - ((1258/5197)^2 + (3939/5197)^2) = 0.367

 

불순도 0.5 = 최악

순수 노드 : 불순도 0 

 

정보이득

부모와 자식 노드 사이의 불순도 차이

결정 트리 모델은 부모 노드와 자식 노드의 불순도 차이가 가능한 크도록 트리를 성장시킴

- > 부모 노드와 자식 노드의 불순도 차이 계산 

 

자식 노드의 불순도를 샘플 개수에 비례하여 모두 더한 다음 부모 노드의 불순도에 빼면 됨

정보 이득 = 부모의 불순도 -(왼쪽 노드 샘플 수 / 부모 샘플 수) x 왼쪽 노드 불순도 - (오른쪽 노드 샘플 수 / 부모 샘플 수) x 오른쪽 노트 불순도

 

ex) 루트 노드를 부모 노드, 왼쪽과 오른쪽 노드가 자식 노드

왼쪽 노드로는 2922 샘플 이동, 오른쪽 노드로는 2275개 샘플 이동

정보 이득 = 0.367 - (2922.5197) x 0.481 - (2275 / 5197) x 0.069 = 0.066

 

=> 결정 트리 알고리즘은 불순도 기준을 사용해 정보 이득이 최대가 되도록 노드를 분할

노드를 순수하게 나눌수록 정보 이득이 커짐

새로운 샘프에 대해 예측할 때에는 노드의 질문에 따라 트리 이동

마지막에 도달한 노드의 클래스 비율을 보고 예측 만듦

 

 

가지치기

가지치기를 안 하면 무작정 끝까지 자라나는 트리 만들어짐

훈련 세트에는 아주 잘 맞지만, 테스트 세트에서 점수는 그에 못 미침 -> 과대적합 -> 일반화 잘 안 됨

* max_depth() : 자라날 수 있는 트리의 최대 깊이 지정

dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(train_scaled, train_target)
print(dt.score(train_scaled, train_target))
print(dt.score(test_scaled, test_target))

0.8454877814123533

0.8415384615384616

-> 훈련 세트 성능 낮아졌지만 테스트 세트 성능은 거의 그대로

 

트리 그래프

* .plot_tree() : 트리 그래프

plt.figure(figsize=(20,15))
plot_tree(dt, filled=True, feature_names=['alcohol', 'sugar', 'pH'])
plt.show()

 

 

그런데 -0.802라는 음수로 된 당도 ... ?

불순도 기준으로 샘플을 나눔. 불순도는 클래스별 비율을 가지고 계산

샘플을 어떤 클래스 비율로 나누는지 계산할 때 특성값의 스케일 영향 미치지 않음

=> 결정 트리 알고리즘은 표준화 전처리 할 필요 없음

 

 

전처리 전 훈련 세트, 테스트 세트로 결정 트리 모델 훈련

dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(train_input, train_target)
print(dt.score(train_input, train_target))
print(dt.score(test_input, test_target))

0.8454877814123533

0.8415384615384616

 

트리 그래프

plt.figure(figsize=(20,15))
plot_tree(dt, filled=True, feature_names=['alcohol', 'sugar', 'pH'])
plt.show()

결과는 같은 트리지만, 특성값을 표준점수로 바꾸지 않아 이해하기 훨씬 쉬움

당도가  1.625보다 크고 4.325보다 작은 와인 중에 알코올 도수가 11.025와 같거나 작은 것이 레드 와인, 그외 화이트 와인

 

특성 중요도

* feature_importances_  : 어떤 특성이 가장 유용한지 특성 중요도

print(dt.feature_importances_)

[0.12345626 0.86862934 0.0079144 ]

-> 두 번째 특성인 당도가 0.87로 특성 중요도 가장 높음 - 알코올 도수 - pH

 

특성 중요도 값을 모두 더하면 1

특성 중요도는 각 노드의 정보 이득과 전체 샘플에 대한 비율을 곱한 후 특성별로 더하여 계산

특성 중요도를 활용하면 결정 트리 모델을 특성 선택에 활요할 수 있음

 

 

---

 

05-2. 교차 검증과 그리드 서치

지금까지 훈련세트에서 모델 훈련, 테스트 세트에서 모델 평가함

테스트 세트에서 얻은 점수를 보고 일반화 성능 가늠

그런데 테스트 세트를 사용해 자꾸 성능을 확인하다 보면 점점 테스트 세트에 맞추게 되는 셈

테스트 세트로 일반화 성능을 올바르게 예측하려면 가능한 한 테스트 세트를 사용하지 말아야 함

모델을 만들고 나서 마지막에 딱 한 번 사용하는 것이 좋음

 

검증 세트

테스트 세트를 사용하지 않으면 모델이 과대/과소적합인지 판단하기 어려움

테스트 세트를 사용하지 않고 이를 측정하는 간단한 방법은 훈련 세트를 또 나눈 것 -> 이 데이터를 '검증 세트'라고 부름

 

훈련 세트 - 모델 훈련   /   검증 세트 - 모델 평가    /    테스트 세트 - 최종 점수 평가

 

 

데이터 불러오기

import pandas as pd

wine = pd.read_csv('https://bit.ly/wine-date')

 

타깃, 특성 배열 저장

class 열 - 타깃  /  나머지 열 - 특성 배열 저장

data = wine[['alcohol', 'sugar', 'pH']].to_numpy()
target = wine['class'].to_numpy()

 

 

훈련 / 테스트 세트 나누기

train_test_split() 함수 2번 적용해서 훈련 세트와 검증 세트로 나눠줌

 

훈련 세트의 입력 데이터와 티깃 데이터를 train_input, train_target 배열에 저장

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(data, target, test_size=0.2, random_state=42)

 

train_input과 train_target을 다시 train_test_split() 함수에 넣어

훈련세트 sub_input, sub_target  /  검증 세트 val_input,  val_target을 만듦

sub_input, val_input, sub_target, val_target = train_test_split(train_input, train_target, test_size=0.2, random_state=42)

 

 

훈련 세트, 검증 세트 크기 확인

print(sub_input.shape, val_input.shape)

(4157, 3) (1040, 3)

-> 원래 5197개였던 훈련세트가 4157로 줄고, 검증 세트는 1040개가 됨

 

 

모델 생성 후 평가

sub_input, sub_target, val_input, val_target 사용해 모델 만들고 평가

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(sub_input, sub_target)
print(dt.score(sub_input, sub_target))
print(dt.score(val_input, val_target))

 

 

교차 검증

검증 세트 만드느라 훈련 세트 줄었음 - 보통 많은 데이터를 훈련에 사용할 수록 좋은 모델이 만들어짐

검증 세트를 너무 조금만 떼어 놓으면 검증 점수 불안정

=> 교차 검증을 이용!

 

교차검증 : 검증 세트를 뗴어 내여 평가하는 과정을 여러 번 반복

                  그 다음 이 점수를 평균하여 최정 검증 점수 얻음

 

k-폴드 교차 검증 : 훈련 세트를 몇 부분으로 나누냐에 따라..

각 폴드에서 계산한 검증 점수를 평균하기 때문에 안정적인 점수 얻을 수 있음

 

 

교차 검증

* cross_validate() : 교차 검증 함수 (기본값 5-폴드 교차 검증)

                             cross_validate(평가할 모델 객체, 훈련세트 전체)

from sklearn.model_selection import cross_validate
scores = cross_validate(dt, train_input, train_target)
print(scores)

{'fit_time': array([0.01800036, 0.00823307, 0.00744772, 0.00747132, 0.00703192]), 'score_time': array([0.0013876 , 0.00073624, 0.00069189, 0.00070477, 0.00066996]), 'test_score': array([0.86923077, 0.84615385, 0.87680462, 0.84889317, 0.83541867])}

 

-> fit_time, scroe_time, test_score 키를 가진 딕셔너리 반환

* fit_time, score_time : 각자 모델을 훈련하는 시간과 검증하는 시간

 

cross_validate() 기본값 5-폴드 교차 검증

* .cv 매개변수에서 폴드 수 바꿀 수 있음

 

 

교차 검증 최종 점수

* test_scroe : 검증 폴드의 점수

교차 검증의 최종 점수는 test_score 키에 담긴 점수 평균

import numpy as np
print(np.mean(scores['test_score']))

0.855300214703487

 

 

주의. cross_validate() 훈련 세트를 섞어 폴드 나누지 x

train_test_split() 함수는 전체 데이터를 섞은 후 훈련 세트를 준비 -> 따로 섞을 필요 없음

교차 검증을 할 때 훈련 세트를 섞으려면 분할기 지정해야 함

 

분할기 : 교차 검증에서 폴드를 어떻게 나눌지 결정

* .cross_validate() 는 회귀 모델 - KFold 분할기   /    분류 모델 - StratifiedKFold 사용

 

앞에서 수행한 코드는 다음 코드와 동일

from sklearn.model_selection import StratifiedKFold

scores = cross_validate(dt, train_input, train_target, cv=StratifiedKFold())
print(np.mean(scores['test_score']))

0.855300214703487

 

 

훈련 세트 섞은 후, 10-폴드 교차 검증

* n_splits : 몇(k) 폴드 교차 검증할지 지정

splitter = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
scores = cross_validate(dt, train_input, train_target, cv=splitter)
print(np.mean(scores['test_score']))

 

 

하이퍼파라미터 튜닝

모델 파라미터 : 머신러닝 모델이 학습하는 파라미터

하이퍼파라미터 : 모델이 학습할 수 없어서 사용자가 지정해야만 하는 파라미터

하이퍼파라미터는 모두 클래스나 메서드의 매개변수로 표현

기본값을 그대로 사용해 모델을 훈련 -> 검증 세트 점수나 교차 검증을 통해서 매개변수 조금씩 변경 

 

그리드 서치 GridSearchCV : 하이퍼파라미터 탐색과 교차 검증을 한 번에 수행

 

 

min_impurtiy_decrease 매개변수 최적값 찾기

GridSearchCV 클래스 임포트

탐색할 매개변수와 탐색할 값의 리스트를 딕셔너리로 만듦

from sklearn.model_selection import GridSearchCV

params = {'min_impurity_decrease': [0.0001, 0.0002, 0.0003, 0.0004, 0.0005]}

0.0001부터 0.0005까지 0.0001씩 증가하는 5개 값 시도

 

 

그리드 서치 객체 생성

GridSearchCV 클래스에 탐색 대상 모델과 params 변수 전달하여 그리드 서치 객체 생성

gs = GridSearchCV(DecisionTreeClassifier(random_state=42), params, n_jobs=-1)

 

 

gs객체에 fit() 메서드 호출

이 메서드를 호출하면 그리드 서치 객체는 결정 트리 모델 min_impurity_decrease 값을 바꿔가며 총 5번 실행함

GridSearchCV의 cv 매개변수 기본값 5

따라서  min_impurity_decrease 5 x 5 = 25개의 모델 훈련

* n_jobs() : 병렬 실행에 사용할 CPU 코어 수 지정 (기본값 1 /  -1 지정시 시스템에 있는 모든 코어 사용)

gs.fit(train_input, train_target)

 

 

best_estimator_

그리드 서치는 훈련이 끝나면 모델 중에서 검증 점수가 가장 높은 모델의 매개변수 조합으로

전체 훈련 세트에서 자동으로 다시 모델을 훈련함 

이 모델은 gs 객체의 best_estimator_ 속성에 저장됨

* best_estimator_ : 검증 점수가 가장 높은 모델의 매개변수 조합으로 전체 훈련 세트에서 다시 모델 훈련

dt = gs.best_estimator_
print(dt.score(train_input, train_target))

0.9615162593804117

 

best_params_ 

* best_params_ : 그리드 서치로 찾은 최적의 매개변수 값 저장

print(gs.best_params_)

{'min_impurity_decrease': 0.0001}

-> 0.0001이 가장 좋은 값으로 선택됨

 

mean_test_score

* cv_results_ 속성의 mean_test_score : 각 매개변수에서 수행한 교차 검증의 평균 점수 저장

print(gs.cv_results_['mean_test_score'])

 

 

최상의 매개변수 조합

* argmax() : 가장 큰 값의 인덱스 추출

인덱스 사용해 params 키에 저장된 매개변수 출력

=> 최상의 검증 점수 만든 매개변수 조합

best_index = np.argmax(gs.cv_results_['mean_test_score'])
print(gs.cv_results_['params'][best_index])

{'min_impurity_decrease': 0.0001}

 

정리

1. 먼저 탐색할 매개변수를 지정

2. 훈련세트에서 그리드 서치를 수행하여 최상의 평균 검증 점수가 나오는 매개변수 조합 찾기

    이 조합은 그리드  서치 객체에 저장됨

3. 그리드 서치는 최상의 매개변수에서 전체 훈련 세트를 사용해 최종 모델을 훈련

   이 모델도 그리드 서치 객체에 저장

 

 

복잡한 매개변수 조합 탐색

* min_impurity_decrease : 노드를 분할하기 위한 불순도 감소 최소량

* max_depth : 트리의 깊이 제한

* min_samples_split : 노드를 나누기 위한 최소 샘플 수

params = {'min_impurity_decrease': np.arange(0.0001, 0.001, 0.0001),
          'max_depth': range(5, 20, 1), 
          'min_samples_split': range(2, 100, 10)}

arrange() 함수 0.0001에서 시작 0.001될 때까지 0.0001을 계속 더함

range() max_depth를 5에서 20까지 1씩 증가하면서 15개 값 만듦

min_samples_split 2에서 100까지 10씩 증가하면서 10개의 값

 

=> 이 매개변수로 수행할 교차 검증 횟수는 9 x 15 x 10 =1350개

기본 5-폴드 교차 검증을 수행 -> 만들어지는 모델 수 6750개

 

 

그리드 서치 실행

gs = GridSearchCV(DecisionTreeClassifier(random_state=42), params, n_jobs=-1)
gs.fit(train_input, train_target)

 

최상의 매개변수 조합 확인

print(gs.best_params_)

{'max_depth': 14, 'min_impurity_decrease': 0.0004, 'min_samples_split': 12}

 

 

최상의 교차 검증 점수 확인

print(np.max(gs.cv_results_['mean_test_score']))

0.8683865773302731

 

GridSearchCV 클래스 - 원하는 매개변수 값을 나열하면 자동으로 교차 검증을 수행해서 최상의 매개변수 찾을 수 있음

 

 

 

랜덤 서치

매개변수 값의 목록을 전달하는 것이 아니라 매개변수를 샘플링할 수 있는 확률 분포 객체 전달

 

싸이파이 - 확률 분포 클래스 임포트

from scipy.stats import uniform, randint

싸이파이 stats 서브 패키지 uniform, randint 클래스는 모두 주어진 범위에서 고르게 값을 뽑음

이를 균등 분포에서 샘플링한다고 함

 

 

 randint 

* randint : 주어진 범위에서 고르게 정수값 뽑음

0에서 10사이의 범위를 갖는 객체 만들고 10개의 숫자 샘플링

rgen = randint(0, 10)
rgen.rvs(10)

 

uniform

* uniform : 주어진 범위에서 고르게 실수값 뽑음

0~1 사이에서 10개의 실수 추출

ugen = uniform(0,1)
ugen.rvs(10)

랜덤서치에 randint, uniform 클래스 객체 넘겨주고 총 몇 번을 샘플링해서 최적의 매개변수를 찾으라고 명령 가능

 

 

min_samples_leaf

* min_samples_leaf : 리프 노드가 되기 위한 최소 샘플의 개수

                                    어떤 노드가 분할하여 만들어질 자식 노드의 샘플 수가 이 값보다 작을 경우 분할하지 않음

params = {'min_impurity_decrease': uniform(0.0001, 0.001),
          'max_depth': randint(20, 50),
          'min_samples_split': randint(2, 25),
          'min_samples_leaf': randint(1, 25)}

min_imputiry_decrease는 0.0001에서 0.001 사이의 실수값을 샘플링

max_depth은 20에서 50사이의 정수

min_samples_split 2에서 25 사이의 정수

min_samples_leaf 1에서 25 사이의 정수 샘플링

 

 

n_iter

* n_iter : 샘플링 횟수

샘플링 횟수는 사이킷런 랜덤 서치 클래스인 RandomizedSerchCV의 n_iter 매개변수에 지정

from sklearn.model_selection import RandomizedSearchCV

gs = RandomizedSearchCV(DecisionTreeClassifier(random_state=42), 
                        params, n_iter=100, n_jobs=-1, random_state=42)
gs.fit(train_input, train_target)

params에 정의된 매개변수 범위에서 총 100번을 샘플링하여 교차 검증을 수행하고 최적의 매개변수 조합 찾음

 

 

최적의 매개변수 조합 

print(gs.best_params_)

{'max_depth': 39, 'min_impurity_decrease': 0.00034102546602601173, 'min_samples_leaf': 7, 'min_samples_split': 13}

 

 

최고의 교차 검증 점수

print(np.max(gs.cv_results_['mean_test_score']))

 

최종 모델 테스트 세트 성능 확인

최적의 모델은 이미 전체 훈련 세트(train_input, train_target)로 훈련되어 

best_estimator 속성에 저장  -> 이 모델을 최종 모델로 결정  -> 테스트 세트 성능 확인

dt = gs.best_estimator_
print(dt.score(test_input, test_target))

0.86

 

= 수동으로 매개변수 바꾸는 대신에 그리드 서치, 랜덤 서치 사용하자!

 

 

---

 

 

05-3.  트리의 앙상블

대체로 성능이 좋은 알고리즘 - 랜덤 포레스트

 

정형 데이터와 비정형 데이터

정형 데이터 : 어떤 구조로 되어 있는 데이터 ex) csv, 데이터베이스, 엑셀 

비정형 데이터 : 정형 데이터와 반대 ex) 텍스트 데이터, 사진, 음악

 

앙상블 학습 : 정형 데이터를 다루는 데 가장 뛰어난 성과를 내는 알고리즘

신경망 알고리즘 : 비정형 데이터는 규칙성을 찾기 어려움. 신경망 알고리즘으로 모델 만들 수 있음

 

---

랜덤 포레스트 RandomForestClassifier

앙상블 학습의 대표 주자 중 하나로 안정적인 성능 덕분에 널리 사용

결정 트리를 랜덤하게 만들어 결정 트리의 숲을 만듦

그리고 각 결정 트리의 예측을 사용해 최종 예측을 만듦

각 트리를 훈련하기 위한 데이터를 랜덤하게 만든다

입력한 훈련 데이터에서 랜덤하게 샘플을 추출하여 훈련 데이터를 만든다 - 이때 한 샘플이 중복되어 추출될 수 있음

예) 1000개 가방에서 100개씩 샘플을 뽑는다면 먼저 1개를 뽑고, 뽑았던 1개를 다시 가방에 넣는다

      이런 식으로 계속해서 100개를 가방에서 뽑으면 중복된 샘플 뽑을 수 있음  -> 부트스트랩 샘플

부트스트랩 : 데이터 세트에서 중복을 허용하여 데이터를 샘플링하는 방식

부트스트랩 샘플은 훈련 세트의 크기와 같음

 

각 노드를 분할할 때 전체 특성 중에서 일부 특성을 무작위로 고른 다음 이 중에서 최선의 분할을 찾음

분류 모델 RandomForestClassifier - 전체 특성 개수의 제곱근만큼의 특성을 선택

회귀 모델 RandomForestRegressor - 전체 특성 사용

 

사이킷런 랜덤 포레스트는 기본 100개의 결정 트리 훈련

분류 - 각 트리의 클래스별 확률을 평균하여 가장 높은 확률을 가진 클래스를 예측

회귀 - 단순히 각 트리의 예측 평균

 

랜덤 포레스트는 랜덤하게 선택한 샘플과 특성을 사용하기 때문에 

훈련 세트에 과대적합되는 것을 막아주고 검증 세트와 테스트 세트에서 안정적인 성능 얻음

 

 

데이터 준비, 훈련/테스트 세트 분할

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

wine = pd.read_csv('https://bit.ly/wine-date')

data = wine[['alcohol', 'sugar', 'pH']].to_numpy()
target = wine['class'].to_numpy()

train_input, test_input, train_target, test_target = train_test_split(data, 
                                                                      target, test_size=0.2, random_state=42)

 

 

교차 검증

* return_train_score : True 지정 - 검증 점수뿐만 아니라 훈련 세트에 대한 점수도 같이 반환 (기본값 False)

from sklearn.model_selection import cross_validate
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_jobs=-1, random_state=42)
scores = cross_validate(rf, train_input, train_target, return_train_score=True, n_jobs=-1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

0.9973541965122431

0.8905151032797809

 

랜덤 포레스트는 결정 트리의 앙상블이기 때문에 DecisionTreeClassifier가 제공하는 중요 매개변수 모두 제공

criterion, max_depth, max_features, min_samples_split, min_impurity_decrease, min_samples_leaf

 

 

랜덤 포레스트 모델 훈련 후 특성 중요도 출력

랜덤 포레스트 특성 중요도 : 각 결정 트리의 특성 중요도를 취합한 것

rf.fit(train_input, train_target)
print(rf.feature_importances_)

[0.23167441 0.50039841 0.26792718]

 

랜덤 포레스트는 특성의 일부를 랜덤하게 선택하여 결정 트리를 훈련 -> 하나의 특성에 과도하게 집중하지 않고

좀 더 많은 특성이 훈련에 기여할 기회 얻음 -> 과대적합 줄이고 일반화 성능 높이는데 도움 

 

 

OOB 점수 출력

자체적으로 모델을 평가하는 점수 얻을 수 있음

OBB 샘플 : 부트스트랩 샘플에 포함되지 않고 남는 샘플

이 남은 샘플을 사용하여 부트스트랩 샘플로 훈련한 결정 트리 평가 ~ 검증 세트 역할!

rf = RandomForestClassifier(oob_score=True, n_jobs=-1, random_state=42)

rf.fit(train_input, train_target)
print(rf.oob_score_)

OOB 점수를 사용하면 교차 검증을 대신할 수 있어서

결과적으로 훈련 세트에 더 많은 샘플을 사용할 수 있음

 

---

엑스트라 트리 ExtraTreesClassifier

랜덤 포레스트와 유사

차이점 : 부트스트랩 샘플 사용 X

결정 트리를 만들 때 전체 훈련 세트를 사용

대신, 노드를 분할할 때 가장 좋은 분할을 찾는 것이 아니라 무작위로 분할

엑스트라 트리 사용하는 결정 트리 splitter='random'

 

하나의 결정 트리에서 특성을 무작위로 분할한다면 성능이 낮아지겠지만

많은 트리를 앙상블 하기 때문에 과대적합을 막고 검증 세트의 점수 높이는 효과있음

 

 

엑스트라 트리 교차 검증 점수 확인

from sklearn.ensemble import ExtraTreesClassifier
et = ExtraTreesClassifier(n_jobs=-1, random_state=42)
scores = cross_validate(et, train_input, train_target, 
                        return_train_score=True, n_jobs=-1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

0.9974503966084433

0.8887848893166506

 

보통 엑스트라 트리가 무작위성이 좀 더 크기 때문에 랜덤 포레스트보다 더 많은 결정 트리를 훈련해야 함

하지만 랜덤하게 노드를 분할하기 때문에 빠른 계산 속도가 장점

 

 

특성 중요도 출력

et.fit(train_input, train_target)
print(et.feature_importances_)

[0.20183568 0.52242907 0.27573525]

 

 

---

그레이디언트 부스팅 GradientBoosintClassifier

깊이가 얕은 결정 트리를 사용하여 이전 트리의 오차를 보완하는 방식으로 앙상블

기본적으로 깊이가 3인 결정 트리를 100개 사용

깊이가 얕은 결정트리를 사용하기 때문에 과대적합에 강하고 일반적으로 높은 일반화 성능 기대

 

경사 하강법을 사용하여 트리를 앙상블에 추가

분류 - 로지스틱 손실 함수

회귀 - 평균 제곱 오차 함수

 

경사 하강법 : 손실 함수를 산으로 정의하고 

                      모델의 가중치와 절편을 조금씩 바꿔서 가장 낮은 곳을 찾아 내려오는 과정

그레이디언트 부스팅 - 결정 트리를 계속 추가하면서 가장 낮은 곳을 찾아 이동

 

 

그레이디언트 교차 검증 점수

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(random_state=42)
scores = cross_validate(gb, train_input, train_target,
                        return_train_score=True, n_jobs=-1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

0.8881086892152563

0.8720430147331015

 

결정 트리의 개수를 늘려도 과대적합에 매우 강함

학습률을 증가시키고 트리의 개수를 늘리면 조금 더 성능 향상 가능

* learning_rate : 학습률 (기본값 0.1)

 

특성 중요도

gb.fit(train_input, train_target)
print(gb.feature_importances_)

[0.11949946 0.74871836 0.13178218]

 

* subsample : 트리 훈련에 사용할 훈련 세트의 비율 정함

                       (기본값 1.0 전체 훈련 세트 사용 / 1보다 작으면 훈련 세트의 일부 사용)

 

그레이디언트 부스팅이 랜덤 포레스트보다 조금 더 높은 성능 얻을 수 있음

하지만 순서대로 트리를 추가하기 때문에 훈련 속도 느림

즉, GradientBoostingClassifier에는 n_jobs 매개변수 없음

 

---

 

히스토그램 기반 그레이디언트 부스팅 HistGradientBoosintClassifier

정형 데이터를 다루는 머신러닝 알고리즘 중에서 가장 인기가 높음 알고리즘

입력 특성을 256개의 구간으로 나눔 - 노드를 분할할 때 최적의 분할을 매우 빠르게 찾을 수 잇음

256개의 구간 중에서 하나를 뗴어 놓고 누락된 값을 위해서 사용

 

트리 개수를 지정하는데 n_estimators 대신 부스팅 반복 횟수를 지정하는 max_iter 사용

 

 

히스토그램 기반 그레이디언트 부스팅 검증 점수

from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier

hgb = HistGradientBoostingClassifier(random_state=42)
scores = cross_validate(hgb, train_input, train_target, return_train_score=True, n_jobs=-1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

0.9321723946453317

0.8801241948619236

 

과대적합을 잘 억제하면서, 그레이디언트 부스팅보다 좀 더 높은 성능

 

 

훈련 세트 특성 중요도

* permutation_importance()  : 그레이디언트 부스팅의 특성 중요도

                                   특성을 하나씩 랜덤하게 섞어서 모델의 성능이 변화하는지를 관찰하여 어떤 특성이 중요한지 계산

* n_repeats : 랜덤하게 섞을 횟수 (기본값 5)

from sklearn.inspection import permutation_importance

hgb.fit(train_input, train_target)
result = permutation_importance(hgb, train_input, train_target,
                                n_repeats=10, random_state=42, n_jobs=-1)
print(result.importances_mean)

[0.08876275 0.23438522 0.08027708]

 

permutation_importancer() 함수가 반환하는 객체는 반복하여 얻은 특성 중요도, 평균, 표준편차 담고 있음

 

 

테스트 세트 특성 중요도

result = permutation_importance(hgb, test_input, test_target,
                                n_repeats=10, random_state = 42, n_jobs=-1)
print(result.importances_mean)

[0.05969231 0.20238462 0.049 ]

 

 

테스트 세트 최종 성능 확인

hgb.score(test_input, test_target)

0.8723076923076923

 

 

사이킷런 말고 그레이디언트 부스팅 알고리즘 구현한 라이브러리

XGBoost

from xgboost import XGBClassifier

xgb = XGBClassifier(tree_method='hist', random_state=42)
scores = cross_validate(xgb, train_input, train_target, return_train_score=True, n_jobs=-1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

 

LightGBM

from lightgbm import LGBMClassifier

lgb = LGBMClassifier(random_state=42)
scores = cross_validate(lgb, train_input, train_target, return_train_score=True, n_jobs=1)

print(np.mean(scores['train_score']), np.mean(scores['test_score']))

 

 

 

 

 

---

참고도서 : 혼자공부하는 머신러닝 + 딥러닝, 박해선, 한빛미디어, 2020년