728x90
반응형
SMALL
728x90
반응형
SMALL

지난 앙상블 모델에 이어 이번 블로그에서는 서포트 벡터 머신에 대하여 다루어 보도록 하겠습니다!

2023.06.06 - [Programming/특성 공학] - [Machine Learning] 앙상블 모델(Random Forest & Gradient Boosting)

 

[Machine Learning] 앙상블 모델(Random Forest & Gradient Boosting)

앞선 결정 트리의 개념에 더하여 이번 블로그에서는 앙상블 모델에 대하여 알아보도록 하겠습니다. 앙상블(ensemble)이란? 앙상블은 여러 머신러닝 모델을 연결하여 더 강력한 모델은 만드는 데에

yuja-k.tistory.com

이전에 분류용 선형 모델에서 잠시 LinearSVC를 잠깐 사용해 보았습니다.

2023.05.16 - [Programming/특성 공학] - [Machine Learning] 다중 선형 분류

 

[Machine Learning] 다중 선형 분류

이번 포스팅은 다중 선형 분류에 대하여 알아보도록 하겠습니다 선형 이진 분류 또는 선형 회귀에 대해 알고 싶은 분들은 이전 포스팅들을 참고해 주세요~! 2023.05.09 - [Programming/특성 공학] - [Machi

yuja-k.tistory.com

지금 해볼 SVM에 포함되는 모델인데요, SVM은 선형 모델과 다르게 단순히 선이나 평면으로 분류를 하지 않는 더 복잡한 모델을 만들 수 있도록 확장한 것입니다.

서포트 벡터 머신도 마찬가지로 분류, 회귀에 모두 사용할 수 있습니다.

다른 모델과 다르게 SVM은 수학적 의미가 너무나 복잡하기 때문에 다루지는 않겠습니다. 사용법과 원리에 대해서만 이야기해 보겠습니다.

선형 모델과 비선형 특성

직선과 초평면은 유연하지 못하다는 것을 우리는 선형 모델을 통해 이미 확인해 보았습니다. 즉 저 차원 데이터에서는 선형 모델이 매우 제한적이게 되는데요, 선형 모델을 유연하게 만드는 방법은 특성끼리 곱하거나 특성 자체를 거듭제곱하는 식으로 특성을 추가하는 것입니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from sklearn.model_selection import train_test_split
import platform
%matplotlib inline
plt.rcParams['axes.unicode_minus'] = False

path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')
from sklearn.datasets import make_blobs
X, y = make_blobs(centers=4, random_state=8)
y = y % 2

mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
plt.xlabel("특성 0")
plt.ylabel("특성 1")

선형 모델은 직선으로만 데이터 포인트를 나누기 때문에 이러한 데이터셋에는 잘 들어맞지 않습니다.

from sklearn.svm import LinearSVC
linear_svm = LinearSVC().fit(X, y)

mglearn.plots.plot_2d_separator(linear_svm, X)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)

plt.xlabel("특성 0")
plt.ylabel("특성 1")

이번에는 특성 1의 제곱을 새로운 특성으로 추가해서 입력 특성을 확장해 보겠습니다. 즉 기존 특성 0, 특성 1만 있는 것이 아닌 [ 특성 0, 특성 1, 특성 1 제곱 ] 데이터가 추가됩니다.

X_new = np.hstack([X, X[:, 1:] ** 2])

from mpl_toolkits.mplot3d import Axes3D, axes3d
figure = plt.figure()

#3차원 그래프
ax = Axes3D(figure, elev=-152, azim=-26)

# y == 0인 포인트를 그리고 다음 y == 1 인 포인트를 그리기
mask = y == 0
ax.scatter(X_new[mask, 0], X_new[mask, 1], X_new[mask, 2], c='b', cmap=mglearn.cm2, s=60, edgecolor='k')
ax.scatter(X_new[~mask, 0], X_new[~mask, 1], X_new[~mask, 2], c='r', marker='^', cmap=mglearn.cm2, s=60, edgecolor='k')

ax.set_xlabel("특성 0")
ax.set_ylabel("특성 1")
ax.set_zlabel("특성 1 ** 2")

새로운 데이터셋에서는 선형 모델과 3차원 공간의 평면을 사용해 두 클래스를 구별할 수 있을 것 같습니다. 선형 모델을 만들어 확인해 보겠습니다.

linear_svm_3d = LinearSVC().fit(X_new, y)
coef, intercept = linear_svm_3d.coef_.ravel(), linear_svm_3d.intercept_

# 선형 결정 경계 그리기
figure = plt.figure()
ax = Axes3D(figure, elev=-152, azim=-26)
xx = np.linspace(X_new[:, 0].min() - 2, X_new[:, 0].max() + 2, 50)
yy = np.linspace(X_new[:, 1].min() - 2, X_new[:, 1].max() + 2, 50)

XX, YY = np.meshgrid(xx, yy)
ZZ = (coef[0] * XX + coef[1] * YY + intercept) / -coef[2]
ax.plot_surface(XX, YY, ZZ, rstride=8, cstride=8, alpha=0.3)
ax.scatter(X_new[mask, 0], X_new[mask, 1], X_new[mask, 2], c='b', cmap=mglearn.cm2, s=60, edgecolor='k')
ax.scatter(X_new[~mask, 0], X_new[~mask, 1], X_new[~mask, 2], c='r', marker='^', cmap=mglearn.cm2, s=60, edgecolor='k')

ax.set_xlabel("특성 0")
ax.set_ylabel("특성 1")
ax.set_zlabel("특성 1 ** 2")

3차원으로 봐도 평면으로 결정 경계가 이루어지는 것을 볼 수 있습니다! SVM 모델을 사용하면 더 이상 선형이 아닌 직선 보다 타원에 가까운 비선형 모델을 만들어 냅니다.

ZZ = YY ** 2
dec = linear_svm_3d.decision_function(np.c_[XX.ravel(), YY.ravel(), ZZ.ravel()])
plt.contourf(XX, YY, dec.reshape(XX.shape), levels = [dec.min(), 0, dec.max()], cmap=mglearn.cm2, alpha=0.5)

mglearn.discrete_scatter(X[:, 0], X[:, 1], y)

plt.xlabel("특성 0")
plt.ylabel("특성 1")

커널 기법 활용하기

앞서 비선형 특성을 추가하여 선형 모델을 조금 더 강력하게 만들어 보았습니다. 이전처럼 확실하게 어떤 특성에 비선형을 적용시켜야 할지 알고 있으면 좋겠지만, 보통은 어떤 특성을 추가해야 할지 모르고, 그렇다고 특성을 많이 추가하면 연산 비용(cpu, 메모리 사용 등)이 커지게 됩니다.

다행히도 수학적 기교를 통해 새로운 특성을 많이 만들지 않고도 고차원에서 분류기를 학습시킬 수 있습니다. 이를 커널 기법(kernel trick)이라고 합니다.

실제로 데이터를 확장하지 않고 확장된 특성에 대한 데이터 포인트들의 거리( 스칼라 곱 )를 계산합니다.

SVM에서 데이터를 고차원 공간에 매핑하는 방법은 두 가지가 있습니다. 차수를 더 늘린다

  • 원래 특성의 가능한 조합을 지정된 차수까지 모두 계산(특성 1 제곱 * 특성 2 5제곱 등..) -> 다항식 커널
  • RBF(radial basis function ) -> 가우시안 커널

가우시안 커널은 차원이 무한한 특성 공간에 매핑하는 것으로, 모든 차수의 모든 다항식을 고려한다고 이해하면 됩니다. 하지만 특성의 중요도는 테일러급수 전개 때문에 고차항이 될수록 줄어듭니다.

복잡한가요? 실제로 수학적인 이론은 중요하지 않지만, RBF 커널을 사용한 SVM이 결정을 만드는 방법은 비교적 쉽게 요약이 가능합니다.

본격적 SVM 이해하기

학습이 진행되는 동안 SVM은 훈련 데이터 포인트가 두 클래스 사이의 결정 경계를 구분하는데 얼마나 중요한지를 배우게 됩니다.

일반적으로 훈련 데이터의 일부만 결정경계를 만드는데 영향을 주게 되는데, 바로 두 클래스 사이의 경계에 위치한 데이터 포인트들입니다.
이러한 데이터들을 서포트 벡터(support vector)라고 하며, 서포트 벡터 머신이 여기서 유래하였습니다.

새로운 데이터 포인트에 예측하려면 각 서포트 벡터와의 거리를 측정합니다. 분류에 대한 결정은 서포트 벡터까지의 거리에 기반하며 서포트 벡터의 중요도는 훈련 과정에서 학습하게 됩니다.(SVC객체의 dual_coef_ 속성에 저장)

데이터 포인트 사이의 거리는 가우시안 커널에 의해 계산됩니다.

𝑘(𝑥1,𝑥2)=exp(−𝛾||𝑥1−𝑥2||2) 수식으로 표현이 가능한데요, 여기서 𝑥1과 𝑥2는 데이터 포인트이며, ||𝑥1−𝑥2||는 유클리디안 거리, $\gamma$는 가우시안 커널의 폭을 제어하는 매개변수입니다.

이어서 forge 데이터셋에 SVM을 학습시켜 보겠습니다.

from sklearn.svm import SVC
X, y = mglearn.tools.make_handcrafted_dataset()
svm = SVC(kernel="rbf", C=10, gamma=0.1).fit(X, y)

mglearn.plots.plot_2d_separator(svm, X, eps=0.5)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)

#서포트 벡터
sv = svm.support_vectors_
# dual_coef_의 부호에 의해 서포트 벡터의 클래스 레이블이 결정됨
sv_labels = svm.dual_coef_.ravel() > 0
mglearn.discrete_scatter(sv[:, 0], sv_labels, s = 15, markeredgewidth=3)
plt.xlabel("특성 0")
plt.ylabel("특성 1")

위 그림에서 결정경계는 검은색 선으로, 서포트 벡터는 굵은 테두리를 가진 데이터 포인트로 그려 보았습니다.

SVM의 핵심 매개변수는 C와 gamma 값으로, 자세히 살펴보겠습니다

SVM 매개변수 튜닝

1) 𝛾매개변수의 역할

gamma 매개변수는 𝛾 로 가우시안 커널 폭의 역수에 해당합니다. gamma 매개변수가 하나의 훈련 샘플에 미치는 영향의 범위를 결정합니다.
작은 값은 넓은 영역을 뜻하며 큰 값이라면 영향이 미치는 범위가 제한적입니다.

정리하자면 가우시안 커널의 반경이 클수록 훈련 샘플의 영향 범위도 커지게 됩니다. gamma는 0보다 범위가 커야 하기 때문에 가우시안 커널 함수의 값의 범위는 𝑒0 ~ 𝑒−∞ 사이입니다 즉 1~0 사이라고 볼 수 있는데요, 따라서 gamma 값이 적어질수록 데이터 포인트의 영향 범위가 커집니다.

 

2) C 매개변수의 역할

 

C 매개변수는 선형 모델에서 사용한 것과 비슷한 규제 매개변수입니다. 이 매개변수는 각 포인트의 중요도(dual_coef_ 값)를 제한합니다.

C 매개변수를 다르게 했을 때 어떻게 변경되는지 살펴보겠습니다.

fig, axes = plt.subplots(3, 3, figsize=(15, 10))

for ax, C in zip(axes, [-1, 0, 3]) :
    for a, gamma in zip(ax, range(-1, 2)):
        mglearn.plots.plot_svm(log_C = C, log_gamma=gamma, ax=a)
        
axes[0, 0].legend(["클래스 0", "클래스 1", "클래스 0 서포트 벡터", "클래스 1 서포트 벡터"],
                  ncol=4, loc=(.9, 1.2))

왼쪽에서 오른쪽으로 가면서 gamma 매개변수를 0.1에서 10으로 증가시킨 것부터 확인하면, gamma 값은 가우시안 커널의 반경을 크게 하여 많은 포인트들이 가까이 있는 것을 고려하는 모습이 보입니다.

그래서 왼쪽에 있는 결정 경계는 매우 부드러워지고, gamma값이 커질수록 결정 경계는 하나하나의 데이터 포인트에 민감해져 결정 경계를 각각 그리는 것이 확인됩니다.

작은 gamma 값이 결정 경계를 천천히 바뀌게 하므로 모델의 복잡도를 낮추게 됩니다. 반면에 gamma 값이 커지면 더욱더 복잡해집니다.

위에서 아래로는 C 매개변수를 0.1에서 1000까지 증가시켰습니다. 선형 모델에서처럼 작은 C는 매우 제약이 큰 모델을 만들고 각 데이터 포인트의 영향력이 작습니다. 왼쪽 위의 결정경계는 거의 선형에 가까우며 잘못 분류된 데이터 포인트가 경계에 영향을 주지 않는 것을 확인할 수 있습니다. 왼쪽 아래에서 볼 수 있듯이 C값을 증가시키면 이 포인트들이 모델에 큰 영향을 주게 되며 결정경계를 휘어서 정확하게 분류합니다.


RBF 커널 SVM을 유방암 데이터셋에 적용해 보겠습니다. 기본값 C=1, gamma=1/n_ features를 사용해 보도록 하겠습니다.

from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer() #유방암 데이터 불러오기

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

svc = SVC()
svc.fit(X_train, y_train)

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

훈련 세트에서는 완벽한 점수를 냈지만, 테스트 세트에서는 63% 의 정확도기 때문에 상당히 과대적합 된 것 같습니다. SVM은 꽤나 잘 작동하는 편이긴 하지만, 매개변수 설정과 데이터 스케일에 매우 민감합니다. 특히 입력 특성의 범위가 비슷해야 합니다. 각 특성의 최솟값과 최댓값을 로그 스케일로 나타내 보겠습니다.

plt.boxplot(X_train, manage_xticks=False)
plt.yscale("symlog")
plt.xlabel("특성 목록")
plt.ylabel("특성 크기")

각 특성의 최댓값 최솟값을 확인해 보면 자릿수 자체가 다른 것이 확인됩니다. 이것이 선형 모델등에서도 문제가 될 수 있지만, 커널 SVM에서는 영향이 매우 큽니다. 이 문제를 해결하기 위해서는 각 특성들에 대해 전처리(pre processing) 작업이 필요합니다.

SVM을 위한 유방암 데이터셋 전처리

위의 문제를 해결하는 방법은 각 특성 값의 범위가 비슷해지도록 조정하는 것입니다. 커널 SVM에서는 모든 특성의 값을 0과 1 사이로 맞추는 방법을 사용합니다. MinMaxScaler 메소드를 사용할 수 있지만, 여기서는 우리가 직접 구현해 보겠습니다.

MinMaxScaler 메소드의 공식은 다음과 같습니다.

# 훈련 세트에서 특성별 최솟값 계산
min_on_training = X_train.min(axis=0)

# 훈련 세트에서 특성별 (최댓값 - 최솟값) 범위 계산
range_on_training = (X_train - min_on_training).max(axis=0)

# 훈련 데이터에 최솟값을 빼고 범위로 나누면
# 각 특성에 대해 최솟값은 0, 최댓값은 1입니다.

X_train_scaled = (X_train - min_on_training) / range_on_training

print("특성별 최소 값 :\n{}".format(X_train_scaled.min(axis=0)))
print("특성별 최대 값 :\n{}".format(X_train_scaled.max(axis=0)))​
# 테스트 세트에도 같은 작업을 작용하지만
# 훈련 세트에서 계산한 최솟값과 범위를 사용합니다.

X_test_scaled = (X_test - min_on_training) / range_on_training​
svc = SVC()
svc.fit(X_train_scaled, y_train)

print("훈련 세트 정확도:{:.3f}".format(svc.score(X_train_scaled, y_train)))
print("테스트 세트 정확도:{:.3f}".format(svc.score(X_test_scaled, y_test)))​

전처리 과정을 통했더니 결과가 매우 크게 달라지는 것이 확인됩니다. 하지만 100% 정확도에서 조금 멀어졌지만 두 결과가 매우 비슷하기 때문에 확실히 과소적합된 상태라고 생각됩니다. 여기서 C나 gamma 값을 증가시켜 조금 더 복잡한 모델로 만들어 볼 수 있을 것 같습니다.

svc = SVC(C=1000)
svc.fit(X_train_scaled, y_train)
print("훈련 세트 정확도:{:.3f}".format(svc.score(X_train_scaled, y_train)))
print("테스트 세트 정확도:{:.3f}".format(svc.score(X_test_scaled, y_test)))

C 값을 증가시켰더니 모델의 성능이 97.2%로 상승하였습니다!

장단점과 매개변수

커널 서포트 벡터 머신은 매우 강력한 모델이며, 다양한 데이터셋에서 잘 작동합니다. SVM은 데이터의 특성이 몇 개 안 되더라도 복잡한 결정 경계를 만들 수 있으며 저 차원과 고차원의 데이터에 모두 잘 작동합니다.

하지만 샘플이 매우 많을 때는 잘 맞지 않습니다. 즉 10,000 개의 이상의 데이터셋에서는 잘 작동하지만, 100,000개 이상의 데이터셋에는 잘 작동하지 않을 수 있다는 측면이 있습니다. (속도와 메모리 관점에서..)

SVM의 또 다른 단점은 데이터의 전처리와 매개변수 설정에 생각보다 신경을 많이 써야 한다는 점입니다. 따라서 요즘에는 전처리가 거의 필요 없는 랜덤 포스트나 그래디언트 부스팅과 같은 트리 기반 모델을 애플리케이션에 많이 도입합니다. 또한 SVM은 수학 적인 관점에서도 모델을 설명하는 것 자체가 매우 어렵습니다.

!! BUT!!

모든 특성이 비슷한 단위이고( 예를 들어 픽셀의 컬러 강도 등...) 스케일이 비슷하면 SVM을 시도해 볼만합니다.

커널 SVM에서 중요한 매개변수는 규제 매개변수 C이고, 어떤 커널을 사용할지와 각 커널에 따른 매개변수입니다. 우리는 RBF 커널만 살펴봤지만 다른 커널도 많이 있습니다.

RBF 커널은 가우시안 커널 폭의 역수인 gamma 매개변수 하나를 가지고 있습니다. gamma와 C 모두 모델의 복잡도를 조정하며 둘 다 큰 값이 더 복잡한 모델을 만들어 냅니다. 따라서 연관성이 많은 이 두 개의 매개변수를 잘 설정하려면 C와 gamma를 함께 조정하는 것이 좋습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

앞선 결정 트리의 개념에 더하여 이번 블로그에서는 앙상블 모델에 대하여 알아보도록 하겠습니다.

앙상블(ensemble)이란?

앙상블은 여러 머신러닝 모델을 연결하여 더 강력한 모델은 만드는 데에 그 의의가 있습니다. 이번 블로그를 통해 저희가 알아볼 앙상블 모델은

  • 랜덤 포레스트(Random Forest Classifier)
  • 그래디언트 부스팅(Gradient Boosting Classifier)

이며, 결정 트리를 이용하여 알아보도록 하겠습니다!


랜덤 포레스트(RandomForest)

결정 트리의 가장 큰 단점 중 하나는 과대적합 될 경향이 있다는 것입니다. 랜덤 포레스트는 결정 트리의 과대적합 가능성을 막아주기 위해 생각해 볼 수 있는 방법입니다.

먼저 포레스트는 말 그대로 숲을 의미하듯이, Decision Tree를 여러개 만드는 기법을 의미합니다.

각 트리는 모델별로 예측을 잘할 테지만, 과대적합 경향을 가진다는데 기초하며, 서로 다른 방향으로 과대적합된 트리를 많이 만들면 그 결과를 평균냄으로써 과대적합 양을 줄이자 라는 겁니다.

이렇게 되면 트리 모델의 예측 성능은 그대로 유지되면서 과대적합이 줄어든 다는 것이 수학적으로 증명되었습니다.

말 그대로 숲(forest)을 이루기 위해서는 나무(tree)를 많이 만들어야 합니다. 각각의 트리는 타깃 예측을 잘해야 하고 다른 트리와 비슷한 예측을 하지 않도록 구별되어야 합니다.

랜덤은 말 그대로 무작위성을 의미합니다. 숲을 이루는 나무들이 각각 달라지도록 무작위성을 주입한다는 뜻입니다.

방식은 두 가지가 있습니다.

  • 트리를 생성할 때 사용하는 데이터 포인트(특성)를 무작위로 선택
  • 분할 테스트에서 특성을 무작위로 선택하는 방법
랜덤 포레스트 구축하기

랜덤 포레스트 모델을 구축할 때 먼저 트리의 개수를 정해야 합니다. RandomForestClassifier나 RandomForestRegressor 클래스의 n_estimators 매개변수를 이용할 수 있습니다.

예제에서는 트리가 10개라고 가정하고 시작합니다.

이 각각의 트리들은 완전히 독립적으로 만들어져야 하므로 알고리즘은 각 트리가 고유하게 만들어지도록 무작위 한 선택을 해야 합니다. 이때 트리를 만들기 위해 데이터의 부트스트랩 샘플(bootstrap sample)을 생성합니다.

매개변수로 n_samples 개의 데이터 포인트 중 무작위로 n_samples 횟수만큼 반복 추출 하게 되는데, 이때 한 샘플이 여러 번 추출될 수 있습니다.

결론적으로 트리를 만들어야 할 샘플 자체는 원본 데이터셋 크기와 같지만, 어떤 데이터 포인트는 누락될 수 있고 어떤 데이터 포인트는 중복되어 들어갈 수 있습니다.

예를 들어 ['a', 'b', 'c', 'd']에서 부트스트랩 샘플을 만든다면

  • ['b', 'd', 'd', 'c']
  • ['a', 'd', 'd', 'b']

같은 샘플이 만들어질 수 있다는 이야기입니다.

이렇게 만들어진 데이터셋을 이용하여 n_estimators 개수만큼 트리를 생성하게 됩니다. 하지만 우리가 본 결정 트리의 알고리즘과 조금 다른데요, 각 노드에서 전체 특성을 대상으로 최선의 테스트를 찾는 것이 아닌 알고리즘이 각 노드에서 후보 특성을 무작위로 선택한 후 이 후보들 중에서 최선의 테스트를 찾습니다.

몇 개의 특성을 고를지는 max_features 매개변수로 조절할 수 있습니다.

후보 특성을 무작위로 고르는 것은 매 노드마다 반복되므로 트리의 각 노드는 다른 후보 특성들을 사용하여 테스트를 만듭니다. 결론적으로 부트스트랩 샘플링은 랜덤 포레스트의 트리가 조금씩 다른 데이터셋을 이용해 만들어지도록 합니다. 이는 각 트리가 서로 무작위적으로 다른 특성, 다른 데이터셋을 가지게 되어 랜덤 포레스트의 모든 트리가 서로 달라지게 합니다.

이 방식에서 핵심이 되는 매개변수는 max_features 입니다. 값에 따른 특징들은 다음과 같습니다.

  • n_features ( 총특성의 개수 )와 같다면 모든 트리에서 모든 특성을 고려하기 때문에 무작위성이 들어가지 않는다.(단, 부트스트랩 샘플링은 적용 )
  • 1로 설정하면 트리는 테스트할 특성을 고를 필요가 없게 되어 그냥 무작위로 선택한 특성의 임계값만을 찾게 됩니다.

정리하자면 max_features의 개수가 많아질수록 랜덤 포레스트가 각 트리들은 구성 자체가 굉장히 비슷해지고 max_feature의 개수가 적어지면 트리는 데이터를 결정하기 위해 트리들의 깊이가 깊어지게 됩니다.

max_features와 n_samples 매개변수를 적절히 조절하여 트리들을 만들면 각 트리 들은 나름대로의 예측을 하게 되고 결과를 냅니다.

랜덤 포레스트는 회귀에서는 예측들의 평균을 내고, 분류에서는 각 트리들에서 제공한 예측 값에 대한 가능성 있는 출력 레이블의 확률을 평균 내어 가장 높은 확률을 가진 클래스가 예측값이 됩니다.

본격적으로 two_moon 데이터셋을 가지고 트리 5개로 구성된 랜덤 포레스트 모델을 만들어 보겠습니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from sklearn.model_selection import train_test_split
import platform
import graphviz
plt.rcParams['axes.unicode_minus'] = False

%matplotlib inline
path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import 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)

forest = RandomForestClassifier(n_estimators=5, random_state=2)
forest.fit(X_train, y_train)

랜덤 포레스트에 의해 만들어진 트리들은 estimator_ 속성에 저장됩니다. 각 트리에서 학습된 결정 경계와 이를 취합해 만든 결정 경계를 함께 시각화해 보겠습니다.

fig, axes = plt.subplots(2, 3, figsize=(20, 10))
for i, (ax, tree) in enumerate(zip(axes.ravel(), forest.estimators_)):
    ax.set_title("트리 {}".format(i))
    mglearn.plots.plot_tree_partition(X, y, tree, ax=ax)

mglearn.plots.plot_2d_separator(forest, X, fill=True, ax=axes[-1, -1], alpha=.4)
axes[-1, -1].set_title("랜덤 포레스트")
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)

다섯 개의 결정 트리가 만들어낸 경계는 서로 다른 경계를 만들어 낸다는 것이 확인됩니다. 부트스트랩 샘플링 때문에 한쪽 트리에 나타나는 훈련 포인트가 다른 트리에는 포함되지 않을 수 있어 각 트리는 불완전합니다만, 랜덤 포레스트는 각 트리들의 평균값을 취합하기 때문에 각 트리들보다 훨씬 과대적합이 덜 되고 좋은 결정 경계를 만들어 낸다는 것이 확인됩니다.

유방암 데이터셋을 RandomForest로

이번엔 유방암 데이터셋에 100개의 트리로 이뤄진 랜덤 포레스트를 적용해 보겠습니다.

from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

forest = RandomForestClassifier(n_estimators=100, random_state=0)
forest.fit(X_train, y_train)

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

확인 결과 테스트 세트 정확도가 꽤나 높게 나오는 것이 확인됩니다. 단일 결정 트리에서 max_features 매개변수를 따로 조정하거나 사전 가지치기를 할 수도 있습니다만, 여러 튜닝을 하지 않아도 랜덤 포레스트는 꽤나 높은 결과를 얻을 수 있습니다.

결정 트리처럼 랜덤 포레스트도 특성 중요도를 제공합니다. 일반적으로 랜덤 포레스트에서 제공하는 특성 정확도가 단일 트리에서 제공하는 특성 보다 더 신뢰가 갈 것 같네요.

def plot_feature_importances_cancer(model):
    n_features = cancer.data.shape[1]
    plt.barh(range(n_features), model.feature_importances_, align='center')
    plt.yticks(np.arange(n_features), cancer.feature_names)
    plt.xlabel("특성 중요도")
    plt.ylabel("특성")
    plt.ylim(-1, n_features)
    
plot_feature_importances_cancer(forest)

단순히 그래프만 봐도 랜덤 포레스트에서는 단일 트리의 경우보다 훨씬 많은 특성이 중요도를 갖습니다. 단일 결정 트리의 worst radius도 랜덤 포레스트에서는 중요하게 생각하고 있고, 랜덤 포레스트는 더 추가해서 worst perimeter도 매우 중요한 특성으로 생각하는 것 같네요

결론적으로 랜덤 포레스트가 단일 결정 트리보다 훨씬 더 넓은 시각으로 데이터를 바라볼 수 있다는 것을 알 수 있습니다.

장단점과 매개변수

랜덤 포레스트는 회귀, 분류 가리지 않고 오늘날 매우 많이 사용하는 머신러닝 알고리즘입니다. 랜덤 포레스트는 성능이 매우 뛰어나고 딱히 매개변수 튜닝을 하지 않아도 잘 작동하며 데이터의 스케일을 맞춰줄 필요가 없습니다.

하지만 랜덤 포레스트의 모델을 만들 때는 트리의 개수가 많다면 시간이 약간 느려지기도 합니다만, n_job 매개변수를 통해 작업할 cpu개수를 지정하여 병렬 처리도 가능합니다. 참고로 n_job = -1 매개변수를 사용하면 cpu의 모든 코어를 사용하여 병렬처리 합니다.

랜덤 포레스트를 사용할 때 주의해야 할 점은 말 그래도 랜덤이기 때문에 random_state 매개변수에 값을 지정하지 않는다면 랜덤 포레스트로 모델을 생성할 때마다 다른 트리가 만들어져 전혀 다른 모델이 만들어지기도 합니다. 트리가 많을수록 random_state 값의 변화에 따른 변동이 적어집니다.
즉 항상 같은 모델을 만들어야 한다면 random_state를 지정해 주어야만 합니다.

랜덤 포레스트의 단점은 텍스트 데이터 같은 차원(feature)이 많고 희소한 데이터에는 잘 작동하지 않습니다. 이런 모델에는 오히려 선형 모델이 더 어울립니다.

랜덤 포레스트는 큰 데이터셋에도 잘 동작하고, CPU 개수까지 조절할 수 있으나, 선형 모델보다 더 많은 메모리를 사용하며 훈련과 예측이 느려집니다. 즉 속도와 메모리 사용에 제약이 있는 애플리케이션을 제작한다면 랜덤 포레스트 보다 선형 모델이 더 어울릴 수 있습니다.

중요한 매개변수로써 n_estimators, max_feature 및 max_depth 같은 사전 가지치기 옵션이 있습니다. 트리의 개수를 결정짓는 n_estimators의 값은 높을수록 트리를 많이 만들기 때문에 과대적합 가능성이 적어지지만 메모리와 긴 훈련시간이 필요하게 됩니다.

보통은 "가용한 시간과 메모리만큼 많이" 만드는 것이 좋습니다.

max_features는 각 트리가 얼마나 무작위가 될지를 결정하며 작은 max_features는 마찬가지로 과대적합을 줄여줍니다. 일반적으로는 그냥 기본값을 사용하는 것이 좋습니다.


그래디언트 부스팅(GradientBoosting)

마찬가지로 앙상블 모델로써 랜덤 포레스트와 비슷하게 여러 개의 결정 트리를 만듭니다. 이름은 회귀 트리지만 분류와 회귀 모두 사용 가능합니다.

랜덤 포레스트와의 차이점은 그래디언트 부스팅 회귀 트리에는 무작위성이 없다는 점입니다. 그래디언트 부스팅은 이전 트리의 오차를 보완하는 방식으로 순차적으로 트리를 만들어 냅니다. 무작위성을 포기하는 대신에 강력한 사전 가지치기를 사용합니다.

그래디언트 부스팅 회귀 트리에는 보통 1~5개 정도의 깊이를 가진 결정 트리를 사용하기 때문에 메모리를 적게 사용하고 예측도 빠릅니다. 이러한 얕은 트리 같은 간단한 모델을 약한 학습기(weak learner)라고도 하는데, 그래디언트 부스팅 회귀 트리는 이러한 약한 학습기를 여러개 연결합니다.

각각의 트리는 데이터의 일부에 대해서만 예측을 잘 수행할 수 있어서 트리가 많이 추가될수록 성능이 좋아지게 됩니다.

랜덤 포레스트 보다는 매개변수 설정에 대해 조금 민감하긴 하지만 잘 조정하면 더 높은 정확도를 제공합니다.

앙상블에서 사용하는 대표적인 매개변수인 사전 가지치기, 트리 개수 조절 외에도 그래디언트 부스팅에서 중요한 매개변수는 이전 트리의 오차를 얼마나 강하게 보정할 것인지를 제어하는 learning_rate를 잘 조절해야 합니다. 학습률이 커지면 보정을 강하게 하기 때문에 복잡한 모델을 만들어 냅니다. n_estimators 값을 커지게 하면 앙상블에 트리가 더 많이 추가되어 모델의 복잡도가 커지고 훈련 세트에서의 실수를 바로잡을 기회가 더 많아집니다.

마찬가지로 유방암 데이터셋을 이용해 GradientBoostingClassifier를 사용해 보겠습니다. 기본값인 깊이가 3인 트리 100개와 학습률 0.1을 사용합니다.

from sklearn.ensemble import GradientBoostingClassifier

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

gbrt = GradientBoostingClassifier(random_state=0)
gbrt.fit(X_train, y_train)

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

훈련 세트의 정확도가 100% 가 나왔기 때문에 과대적합된 거 같습니다. 과대적합을 만들기 위해 그래디언트 부스팅의 복잡도를 줄이기 위하여 트리의 최대 깊이를 줄여서 사전 가지치기를 강하게 하거나 학습률을 낮출 수 있습니다.

gbrt = GradientBoostingClassifier(random_state=0, max_depth=1)
gbrt.fit(X_train, y_train)

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

gbrt = GradientBoostingClassifier(random_state=0, learning_rate=0.01)
gbrt.fit(X_train, y_train)

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

위의 두 방식 모두 모델의 정확도를 감소시키기 대문에 훈련 세트의 정확도가 낮아지기 시작합니다. 학습률을 낮추는 것은 테스트 세트의 성능을 조금밖에 개선시키지 못했으나, 트리의 최대 깊이를 낮추는 것은 모델 성능 향상에 매우 큰 기여를 하였습니다.

랜덤 포레스트처럼 특성의 중요도를 시각화해보겠습니다. 트리를 100개나 사용했기 때문에 깊이가 1인 트리더라도 모든 트리를 전부 분석하기에는 쉽지는 않습니다.

gbrt = GradientBoostingClassifier(random_state=0, max_depth=1)
gbrt.fit(X_train, y_train)

plot_feature_importances_cancer(gbrt)

랜덤 포레스트의 특성 중요도와 비슷하게 등장하는데요, 랜덤 포레스트와 다르게 그래디언트 부스팅은 일부 특성은 완전히 무시하는 것이 보입니다.

비슷한 종류의 데이터에서 그래디언트 부스팅과 랜덤 포레스트 둘 다 잘 작동합니다만, 보통 더 안정적인 랜덤 포레스트를 먼저 사용합니다. 랜덤 포레스트가 잘 작동하더라도 예측 시간이 중요하거나 머신러닝 모델에서 마지막 성능까지 쥐어짜야 할 때 그래디언트 부스팅을 사용하면 도움이 됩니다.

장단점과 매개변수

마찬가지로 그래디언트 부스팅 결정 트리 역시 지도 학습에서 강력하고 널리 사용하는 모델 중 하나입니다. 단점은 매개변수에 너무 민감하다는 데에 있고, 훈련 시간이 꽤나 길다는 것입니다.

하지만 다른 트리 기반 모델처럼 특성의 스케일을 조정하지 않아도 되고 이진 특성이 연속적인 특성에서도 잘 동작합니다. 하지만 트리 기반 모델의 특성상 희소한 고차원 데이터에는 잘 작동하지 않습니다.

그래디언트 부스팅에서 중요한 매개변수는 n_estimators와 learning_rate가 중요합니다. 이 두 매개변수는 매우 깊게 연관되어 있으며 learing_rate를 낮추면 비슷한 복잡도의 모델을 만들기 위해서 더 많은 트리를 추가해야 합니다. n_estimators가 클수록 좋은 랜덤 포레스트와 다르게 그래디언트 부스팅에서 n_estimators 매개변수를 크게 하면 모델이 복잡해지고 과대적합될 가능성이 높아지게 됩니다.

일반적인 관례상 가용한 시간과 메모리 한도 내에서 n_estimators를 맞추고 나서 적절한 learning_rate를 찾는 것입니다.

또한 트리의 복잡도를 낮추기 위해 max_depth( 또는 max_leaf_nodes )를 조절해야 하는데, 통상적으로 그래디언트 부스팅에서는 max_depth를 작게 설정하여 트리의 깊이가 5보다 깊어지지 않게 하는 것이 좋습니다.

 

다음 포스팅에서는 서포트 백터 머신(SVM)에 대하여 알아보도록 하겠습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

2023.05.23 - [Programming/특성 공학] - [Machine Learning] 의사결정 트리(Decision Tree)

 

[Machine Learning] 의사결정 트리(Decision Tree)

이번 포스팅에서는 의사결정 트리(Decision Tree)에 대하여 알아보도록 하겠습니다! 결정 트리(Decision Tree) 분류와 회귀 문제에 널리 사용하는 모델입니다. 기본적으로 결정 트리는 스무고개 놀이와

yuja-k.tistory.com

앞서, Decision Tree에 관한 개념과 알고리즘을 통해 구현해 보았습니다. 이번 블로그에서는 Decision Tree의 시각화 및 특성 중요도에 대하여 알아보고 결정 트리의 장단점에 대하여 알아보도록 하겠습니다.

트리 시각화 하기

트리 모듈의 export_graphviz 함수를 이용하면 트리를 시각화할 수 있습니다.

from sklearn.tree import export_graphviz
export_graphviz(tree, out_file="tree.dot", class_names=["악성","양성"],
               feature_names=cancer.feature_names, impurity=False, filled=True)
with open("tree.dot") as f:
    dot_graph = f.read()

display(graphviz.Source(dot_graph))

트리를 시각화 함에 따라 알고리즘의 예측을 쉽게 할 수 있게 됐습니다. 깊이가 4만 되었는데도 불구하고 매우 복잡한데, 보통은 10이 정도의 깊이를 사용합니다. samples는 각 노드에 있는 샘플의 수를 의미하며, value는 클래스당 샘플 수를 제공합니다.

트리의 특성 중요도 ( Feature Importance )

전체 트리를 살펴보는 것은 힘든 일입니다. 대신 트리가 어떻게 작동하는지 요약하는 속성들을 사용할 수 있습니다. 가장 널리 사용되는 속성은 트리를 만드는 결정에 각 특성이 얼마나 중요한지를 평가하는 특성 중요도 이 값은 0과 1 사이의 숫자로, 각 특성에 대해 0은 전혀 사용되지 않았다는 것을 의미하고, 1은 완벽하게 타깃 클래스를 예측했다는 뜻이 됩니다.

print("특성 중요도 :\n{}".format(tree.feature_importances_))

def plot_feature_importances_cancer(model):
    n_features = cancer.data.shape[1]
    plt.barh(range(n_features), model.feature_importances_, align='center')
    plt.yticks(np.arange(n_features), cancer.feature_names)
    plt.xlabel("특성 중요도")
    plt.ylabel("특성")
    plt.ylim(-1, n_features)

plot_feature_importances_cancer(tree)

첫 번째 노드에서 사용한 특성인 worst radius 가 가장 중요한 특성으로 나타나는 것이 확인됩니다. 이 그래프는 첫 번째 노드에서 두 클래스( 악성, 양성 )를 꽤나 잘 나누고 있다는 것을 의미합니다.

feature_importance_의 값이 낮다고 아예 중요하지 않은 값은 아닙니다. 단지 트리가 그 특성을 선택하지 않은 것뿐이며 다른 특성이 동일한 정보를 지니고 있어서 일 수도 있습니다.

선형 모델의 계수와는 다르게 특성 중요도는 언제나 양수이며 특성이 어느 클래스를 지지하는지 ( 결정하는데 역할을 하는지 ) 알 수가 없습니다. 즉 특성 중요도의 값은 "worst radius"가 중요하다고 알려주지만, 이 특성이 양성을 의미하는지, 악성을 의미하는지는 알 수 없습니다.

사실 특성과 클래스 사이에는 간단하지 않은 관계가 있을 수 있기 때문에 다음 예를 들어 보겠습니다.

tree = mglearn.plots.plot_tree_not_monotone()
display(tree)

두 개의 특성과 두 개의 클래스를 가진 데이터셋을 표현하고 있습니다. X [1]에 있는 정보만 사용되었고, X [0]은 전혀 사용되지 않았습니다. 그런데 X [1]과 출력 클래스와의 관계는 단순히 비례나 반비례하지 않습니다. 즉 "X [1]의 값이 높으면 클래스 0이고 값이 낮으면 1"이라고 말할 수 없습니다.

결론적으로 데이터의 분포도와 트리에 사용된 특성을 참고하면서 트리에서 사용한 특성이 정말 중요한 특성인지, 혹시 놓친 특성은 없는지 살펴봐야 할 것 같습니다.


결정 트리 회귀

우리는 여기서 결정 트리를 가지고 분류에 대해서만 논하고 있지만 사실상 회귀에서도 비슷하게 적용됩니다. 회귀 트리의 사용법은 분류 트리와 매우 비슷합니다.
하지만 회귀를 위한 트리 기반의 모델을 사용할 때 확인 해 봐야 할 속성이 있습니다.

DecisionTreeRegressor( 그리고 모든 다른 트리 기반 회귀 모델 )는 외삽(extrapolation), 즉 훈련 데이터의 범위 밖의 포인트에 대해 예측을 할 수 없습니다.

import os
ram_prices = pd.read_csv(os.path.join(mglearn.datasets.DATA_PATH, "ram_price.csv"))

plt.semilogy(ram_prices.date, ram_prices.price)
plt.xlabel("년")
plt.ylabel("가격 ($/Mbyte)")

Text(0,0.5,'가격 ($/Mbyte)')

y축은 로그 스케일로써 선형적으로 그리기 좋기 때문에 비교적 예측이 쉬워집니다.

날짜 특성 하나만으로 램의 2000년도 전까지의 데이터로부터 2000년도 이후의 가격을 예측해 보겠습니다. 여기서는 간단한 두 모델인 DecisionTreeRegressor와 LinearRegression을 비교해 보도록 하겠습니다.

그래프 표현식을 위해 전체 데이터셋에 대해 예측을 수행하였지만, 테스트 데이터셋의 비교가 관심 대상입니다.

from sklearn.tree import DecisionTreeRegressor
from sklearn.linear_model import LinearRegression

# 2000년 이전을 훈련 데이터로, 2000년 이후를 테스트 데이터로
data_train = ram_prices[ram_prices.date < 2000]
data_test  = ram_prices[ram_prices.date >= 2000]

# 가격 예측을 위해 날짜 특성만을 이용합니다.
X_train = data_train.date[:, np.newaxis]

# 데이터와 타깃 관계를 간단하기 위해 로그 스케일로 바꿉니다.
y_train = np.log(data_train.price)

tree = DecisionTreeRegressor().fit(X_train, y_train)
linear_reg = LinearRegression().fit(X_train, y_train)

# 예측은 전체 기간에 대해서 수행합니다.
X_all = ram_prices.date[:, np.newaxis]

pred_tree = tree.predict(X_all)
pred_lr   = linear_reg.predict(X_all)

# 예측한 값의 로그 스케일을 되돌립니다.
price_tree = np.exp(pred_tree)
price_lr   = np.exp(pred_lr)
plt.semilogy(data_train.date, data_train.price, label="훈련 데이터")
plt.semilogy(data_test.date, data_test.price, label="테스트 데이터")
plt.semilogy(ram_prices.date, price_tree, label="트리 예측")
plt.semilogy(ram_prices.date, price_lr, label="선형 회귀 예측")
plt.legend()

두 모델은 확연한 차이를 보이고 있습니다. 선형 모델 ( 빨간 선 )은 우리가 이미 알고 있는 대로 데이터를 근사하여 직선을 2000년 이후 데이터를 꽤나 정확히 예측하고 있습니다. 하지만 트리 모델은 훈련 데이터를 ( 2000년도 이전 ) 완벽하게 예측합니다.

트리의 복잡도에 제한을 두지 않아서 저체 데이터셋을 모두 기억하기 때문입니다. 그러나 모델이 가진 데이터 범위 밖으로 나가면 단순히 마지막 포인트를 이용해 예측하는 것이 전부입니다.

트리 모델은 훈련 데이터 밖의 새로운 데이터를 예측할 능력이 없습니다. 이는 모든 트리 기반 모델의 공통적인 단점입니다.

장단점과 매개변수

결정 트리에서의 모델 복잡도를 조절하는 매개변수는 트리가 완전히 만들어지기 전에 멈추는 사전 가지치기 매개변수입니다. 우리는 실제 하나만 써 보았지만 3개의 매개변수가 있습니다.

  • max_depth
  • max_leaf_nodes
  • min_sample_leaf

위의 매개변수 중 하나만 조절해도 과대적합을 막는데 충분합니다.

결정 트리의 장점

이전에 소개한 다른 알고리즘보다 나은 점은 총 두 가지로 정리가 가능합니다.

  • 1) 만들어진 모델을 쉽게 시각화 할 수 있어서 비 전문가도 이해하기가 쉽습니다. ( 너무 크지 않다면...)
  • 2) 데이터의 크기게 구애 받지 않습니다.

각 특성이 개별적으로 처리되어 데이터를 분할하는데 데이터 스케일의 영향을 받지 않으므로 결정 트리에서는 특성의 정규화나 표준화 같은 전처리 과정이 필요가 없습니다.

특히 특성의 스케일이 서로 다르거나 이진 특성과 연속적인 특성이 혼합되어 있을 때도 잘 작동합니다.

결정 트리의 단점

매개변수를 조절해 사전 가지치기를 사용함에도 불구하고 과대적합되는 경향이 있어 일반화 성능이 좋지 못합니다. 따라서 다음에 해볼 랜덤포레스트 - 앙상블 방법을 단일 결정 트리의 대안으로 흔히 사용합니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅에서는 의사결정 트리(Decision Tree)에 대하여 알아보도록 하겠습니다!

결정 트리(Decision Tree)

분류와 회귀 문제에 널리 사용하는 모델입니다. 기본적으로 결정 트리는 스무고개 놀이와 비슷합니다. 던지는 질문에 Yes / No를 결정해 문제를 해결합니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from sklearn.model_selection import train_test_split
import platform
import graphviz
plt.rcParams['axes.unicode_minus'] = False

%matplotlib inline
path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')
mglearn.plots.plot_animal_tree()

4가지 동물( 매, 펭귄, 돌고래, 곰 )을 구분하는 모습을 보여주고 있습니다. 이 그림에서 트리의 노드는 질문이나 정답을 담은 네모 상자입니다.

마지막 정답이 들어있는 노드는 리프라고도 이야기합니다.

머신러닝 식으로 이야기하자면 "날개가 있나요"?, "날 수 있나요?", "지느러미가 있나요?"를 이용해 네 개의 클래스를 구분하는 모델을 만든 것입니다. 이런 모델을 직접 만드는 것이 아닌 지도 학습 방식으로 데이터로부터 학습할 수 있습니다.

결정 트리 만들기

2차원 데이터셋을 분류하는 결정트리를 만들어 봅시다. 이 데이터셋은 각 클래스에 데이터 포인트가 75개씩 존재합니다. 그리고 반달 두 개가 포개진듯한 모양을 하고 있습니다.

이 데이터셋을 two_moons라고 합니다.

결정 트리를 학습한다는 것은 정답에 가장 빨리 도달하는 예 / 아니오 질문 목록을 학습한다는 뜻입니다. 머신러닝에서는 이런 질문들을 테스트 라고합니다. ( 테스트 세트라고 생각하면 절대 안도미!)

위의 동물 예제처럼 예 / 아니오 형태의 특성으로 구성되지 않고, 2차원 데이터셋과 같이 연속된 특성으로 구성됩니다. 즉 "특성 𝑖는 값 𝑎 보다 큰가?"와 같은 형태입니다.

mglearn.plots.plot_tree_progressive()

알고리즘 고르기

트리를 만들 때 알고리즘은 가능한 모든 테스트에서 타깃값에 대해 가장 많은 정보를 가진 것을 고릅니다.

depth 1

트리의 깊이가 1인 상태에서의 테스트를 사려 보겠습니다. 데이터셋을 X [1] = 0.06에서 수평으로 나누는 것이 가장 많은 정보를 포함시키고 있습니다.
즉 이 직선이 0에 속한 포인트와 클래스 1에 속한 포인트를 가장 잘 나누고 있습니다. 파란 점은 클래스 0을 의미하며, 세모는 클래스 1을 의미합니다.

루트 노드라고도 이야기하는 맨 위 노드는 클래스 0에 속한 포인트 75개와 클래스 1에 속한 포인트 75개를 모두 포함한 전체 데이터셋을 의미합니다.

X [1] <= 0.6 테스트에 의해 true가 된 것들은 왼쪽 노드에 할당되고, 그렇지 않은 것들은 오른쪽에 할당됩니다.

왼쪽 노드에는 클래스 0에 속한 포인트는 2개, 클래스 1에 속한 포인트는 32개입니다. 오른쪽 노드에는 클래스 0에 속한 포인트는 48개, 클래스 1에 속한 포인트는 18개 있는 것으로 확인되네요

이 두 노드는 첫 번째 그림의 윗부분과 아랫부분으로 각각 분류됩니다.

대부분 잘 분류하기는 했지만 아직 완벽하게 분류하진 못한 것 같습니다.

depth 2

트리의 깊이가 2인 상태에서는 깊이가 1인 상태에서 보다 조금 더 각 클래스 별 정보를 영역에 담을 수 있도록 X [0] 값을 기준으로 왼쪽과 오른쪽 영역으로 나누고 있습니다.

이렇게 계속되는 테스트 ( 반복되는 프로세스 )는 각 노드가 테스트 하나씩을 가진 이진 결정 트리를 만들어 냅니다. 다르게 말하며 각 테스트는 하나의 축을 따라 데이터를 둘로 나누는 것이라고 생각해 볼 수도 있습니다. 이는 계층적으로 영역을 분할해 가는 알고리즘이라고 할 수 있습니다.

데이터를 분할하는 것은 각 분할된 영역이 ( 결정 트리의 리프 ) 한 개의 타깃값 ( 하나의 클래스나 하나의 회귀 분석 결과)을 가질 때까지 반복됩니다.
각 테스트는 하나의 특성에 대해서만 이루어지기 때문에 나누어진 영역은 항상 평행합니다. 이때 타깃 하나로만 이뤄진 리프 노드를 순수 노드(pure node)라고 합니다.

depth 9

순수 노드가 존재하는 최종 분할 트리라고 할 수 있는 깊이가 9인 상태를 보면 잘 보이지는 않지만 더 이상 분할 하지 않고 값을 결정 지어버리는 노드도 있습니다. 이 노드들이 위에서 이야기했던 순수 노드입니다.

결론

새로운 데이터 포인트에 대한 예측은 주어진 데이터 포인트가 특성을 분할한 영역들 중 어디에 놓이는지를 확인해 보면 됩니다.

  • 타깃 값중 다수를 차지하는 노드
  • 순수 노드로 결정 지어지는 경우

위의 두 가지로 예측결과를 지정합니다.

루트 노드에서 시작해 테스트의 결과에 따라 왼쪽 또는 오른쪽으로 트리를 탐색해 나가는 식으로 영역을 찾아낼 수 있습니다.

같은 방법으로 회귀 문제에도 트리를 사용할 수 있습니다. 예측을 하러면 각 노드의 테스트 결과에 따라 트리를 탐색해 나가고 새로운 데이터 포인트에 해당되는 리프 노드를 찾습니다. 찾은 리프 노드의 훈련 데이터 평균값이 이 데이터 포인트의 출력이 됩니다.

결정 트리 복잡도 제어

트리를 만들어 낼 때 모든 리프가 순수 노드가 될 때까지 진행한다면 모델이 매우 복잡해지고 훈련 데이터에 과대 적합합니다. 득 훈련 세트에 100% 정확하게 맞는다는 의미가 됩니다.

즉 순수 노드는 정확학 클래스의 리프노드라고 볼 수 있습니다. depth 9 일 때의 그림을 보시면 왼쪽 그래프가 굉장히 과대적합 되었다고 볼 수 있습니다.

클래서 1로 결정된 영역이 클래스 0에 속한 포인트들로 둘러싸인 것을 볼 수 있는데, 그 반대의 모습도 찾아볼 수 있습니다.

결정 경계가 클래스의 포인트들에서 멀리 떨어진 이상치(outlier)에 너무 민감해지기 때문이죠

과대적합 막기

과대적합을 막으려면 크게 두 가지로 전략을 세워야 합니다.

  • 트리 생성을 일찍 중단( 사전 가지치기 ( Pre pruning ) )
  • 트리를 다 만들고 데이터 포인트가 적은 노드를 삭제하거나 병합 ( 사후 가지치기( Post pruning ) )

먼저 사전 가지치기 방법은 트리의 최대 깊이나 리프의 최대 개수를 제한하거나 노드가 분할하기 위한 포인트의 최소 개수를 지정하는 것입니다.

scikit-learn에서 결정트리는 DecisionTreeRegressor와 DecisionTreeClassifier에 구현되어 있습니다. 사전 가지치기 만을 지원합니다.

유방암 데이터 셋을 이용해 사전 가지치기의 효과에 대해서 알아보겠습니다. 기본값 설정으로 완벽한 트리 ( 모든 리프 노드가 순수 노드가 될 때까지 생성한 트리 ) 모델을 만들어 봅니다.

from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier

cancer = load_breast_cancer()

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, stratify=cancer.target, random_state=42)
tree = DecisionTreeClassifier(random_state = 0)
tree.fit(X_train, y_train)

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

생각 한대로 모든 리프가 순수 노드이기 때문에 훈련 세트의 정확도는 100%입니다. 즉 트리는 훈련 데이터의 훈련 데이터의 모든 레이블을 완벽하게 기억하고 있을 만큼 충분히 깊습니다.

테스트 세트의 정확도는 이전에 본 선형 모델에서의 정확도인 95% 보다 약간 낮습니다.

결정 트리의 깊이를 제한하지 않으면 트리는 무한정 깊어지고 복잡해질 수 있습니다. 따라서 가지치기를 하지 않은 트리는 과대적합 되기 쉽고 새로운 데이터에 잘 일반화되지 않습니다.

사전 가지치기 적용

이제 유방암 데이터셋을 위한 결정 트리에 사전 가지치기를 통해 트리가 깊어지는 것을 막아 보겠습니다. 방법은 트리가 훈련 데이터에 완전히 학습되기 전에 트리의 성장을 막아보는 것입니다. max_depth 매개변수를 이용하며, 유방암 데이터셋에서는 4 옵션을 줘서 막을 수 있습니다. 즉 연속된 질문을 4개로 제한하게 됩니다.

트리의 깊이를 제한하면 과대적합이 줄어듭니다. 이는 훈련 세트의 정확도를 떨어뜨리지만 테스트 세트의 성능을 개선시킵니다.

tree = DecisionTreeClassifier(max_depth=4, random_state=0)
tree.fit(X_train, y_train)

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

다음 블로그에서는 앞서 다룬 Tree의 시각화 및 특성 중요도에 대하여 알아보고 결정 트리의 장단점에 대하여 알아보도록 하겠습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅은 다중 선형 분류에 대하여 알아보도록 하겠습니다

선형 이진 분류 또는 선형 회귀에 대해 알고 싶은 분들은 이전 포스팅들을 참고해 주세요~!

2023.05.09 - [Programming/특성 공학] - [Machine Learning] 선형 이진 분류

 

[Machine Learning] 선형 이진 분류

지난 선형 회귀 포스팅에 이어 이번 포스팅에서는 선형 이진 분류에 대하여 알아보도록 하겠습니다. 2023.05.02 - [Programming/특성 공학] - [Machine Learning] 선형 회귀 [Machine Learning] 선형 회귀 이번 블로

yuja-k.tistory.com

2023.05.02 - [Programming/특성 공학] - [Machine Learning] 선형 회귀

 

[Machine Learning] 선형 회귀

이번 블로그는 선형 모델에 대하여 알아보도록 합시다. 선형 모델은 매우 오래전 개발된 모델입니다. 선형 모델은 입력 특성에 대한 선형 함수를 만들어 예측을 수행합니다. 먼저 회귀의 선형

yuja-k.tistory.com

다중 클래스 분류란?

로지스틱 회귀는 기본적으로 softmax 함수를 이용하여 다중 분류를 지원하나, 다른 많은 모델들은 태생적으로 이진 분류만을 지원합니다. 즉 다중 클래스(Multi-class)를 지원하지 않습니다.

이진 분류 알고리즘을 다중 클래스 알고리즘으로 확장하는 방법은 일대다(One vs Rest 또는 One vs All) 방법입니다. 일대다 방식은 각 클래스를 다른 모든 클래스와 구분하도록 이진 분류 모델을 학습시킵니다.

결국 클래스의 개수만큼 이진 분류 모델이 만들어지며, 예측할 때 이렇게 만들어진 모든 이진 분류기가 작동하여 가장 높은 점수를 내는 분류기의 클래스를 예측값으로 선택하게 됩니다.

지금까지 해왔던 것과 마찬가지로 다중 클래스 분류도 어쨌든 이진 분류를 기반으로 생각해야 하기 때문에 방정식 자체가 똑같습니다.

다중 클래스 로지스틱 회귀의 수학은 다른 모델들의 위의 일대다 방식과는 조금 다릅니다. 하지만 여기서도 클래스마다 계수 벡터와 절편을 만들며, 예측 방법도 같습니다.

 

𝑖번째 데이터 포인트 𝑋𝑖의 출력 𝑌𝑖가 클래스 𝑐일 확률 𝑃𝑟(𝑌𝑖=𝑐)는 𝐾개의 클래스에 대한 각각의 계수를 데이터 포인트에 곱하여 자연상수(𝑒)에 지수함수를 적용한 합으로써 클래스에 대한 값을 나누어 계산합니다.

위의 함수를 소프트맥스 함수 표현식이라 하며, 수식의 간소화를 위해 계수벡터에 절편 𝑏가 포함 되어 있는 것으로 나타냅니다.

따라서 다중 클래스 로지스틱 회귀에서도 계수 벡터와 절편이 존재합니다.

세 개의 클래스를 가진 간단한 데이터셋에 일대다 방식을 적용시켜 보겠습니다. 이 데이터셋은 2차원이며 각 클래스의 데이터는 정규분포(가우시안 분포)를 따릅니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from sklearn.model_selection import train_test_split
import platform
plt.rcParams['axes.unicode_minus'] = False

path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')
from sklearn.datasets import make_blobs

X, y = make_blobs(random_state=42)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
plt.xlabel("특성 0")
plt.ylabel("특성 1")
plt.legend(["클래스 0", "클래스 1", "클래스 2"])

이 데이터셋으로 먼저 LinearSVC 분류기를 훈련해 보겠습니다.

from sklearn.svm import LinearSVC
linear_svm = LinearSVC().fit(X, y)
print("계수 배열의 크기 : ", linear_svm.coef_.shape)
df_coef = pd.DataFrame(columns=["특성 0","특성 1"] ,data=linear_svm.coef_)
df_coef

print("절편 배열의 크기 : ", linear_svm.intercept_.shape)
df_intercept = pd.DataFrame(columns=["절편"], data = linear_svm.intercept_)
df_intercept

coef_ 배열의 크기는 (3,2)입니다. coef_의 행은 세 개의 클래스가 각각 대응하는 계수 벡터들을 각각 담고 있으며, 열은 각 특성에 따른 계수 값을 가지고 있습니다. intercept_는 각 클래스의 절편을 담아낸 1차원 벡터입니다.

세 개의 이진분류기가 만드는 경계를 시각화해보겠습니다.

mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15) # -15 ~ 15 까지 50개의 수열을 생성

for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, mglearn.cm3.colors):
    plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color) # 판별 함수 사용

plt.ylim(-10, 15)
plt.xlim(-10, 8)
plt.xlabel("특성 0")
plt.ylabel("특성 1")
plt.legend(['클래스 0', '클래스 1', '클래스 2', '클래스 0 경계','클래스 1 경계', '클래스 2 경계'], loc=(1.01, 0.3))

각 훈련 데이터의 클래스들에 대한 결정 경계를 그려 보았습니다. 파란색 선은 클래스 0으로, 주황색 선은 클래스 1로, 초록색 선은 클래스 2로 경계합니다. 각 경계에서 겹치는 부분들은 조금 더 가까운 쪽으로 예측을 하게 됩니다.

중앙의 삼각형 영역은 모든 데이터 포인트가 나머지로 분류한 곳으로써 분류 공식의 결과가 가장 높은 클래스가 포인트로써 지정되게 됩니다.

조금 더 알아보기 쉽도록 경계면을 그려 보겠습니다.

mglearn.plots.plot_2d_classification(linear_svm, X, fill=True, alpha=.7)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15)

for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, mglearn.cm3.colors):
    plt.plot(line, -(line * coef[0] + intercept) / coef[1], c=color)

plt.legend(['클래스 0', '클래스 1', '클래스 2', '클래스 0 경계', '클래스 1 경계', '클래스 2 경계'], 
           loc=(1.01, 0.3))
plt.xlabel('특성 0')
plt.ylabel('특성 1')

선형 모델의 주요 매개변수는 회귀 모델은 alpha, 분류 모델 (LinearSVC, LogisticRegression)에서는 C입니다. alpha의 값이 클수록, C 값이 작아질수록 모델은 단순해집니다.

회귀 모델은 이러한 매개변수를 조절하는 것이 꽤나 중요하며 보통 C와 alpha는 로그 스케일 ( 10배 단위로 조절 하는 것. 0.01, 0.1, 1, 10 등 )로 최적치를 정하게 됩니다.

또한 L1 규제와 L2 규제를 정해야 하는데 어떠한 규제를 사용해야 할지 결정 지어 주는 상황은 다음으로 정리해 볼 수 있겠습니다.

  • 중요한 특성이 많지 않으면 L1 규제를 사용해 예측에 사용하지 않도록 만들 수 있습니다.
  • 모델의 해석이 중요한 요소일 때도 ( 특정 요소가 매우 중요한 요소일 경우 ) L1 규제를 사용할 수 있습니다.
  • 중요한 특성이 많으면 L2 규제를 사용해 약간이라도 예측에 영향을 미치도록 만들 수 있습니다.

선형 모델은 학습 속도가 빠르고 예측도 매우 빠릅니다. 매우 큰 데이터셋이던, 희소한 데이터셋이던 잘 작동합니다.

참고로 수십만 ~ 수백만 개의 샘플로 이뤄진 대용량 데이터 셋이라면 기본 설정보다 더 빨리 처리할 수 있도록 LogisticRegression과 Ridge에 solver='sag' 옵션을 부여해 줄 수 있습니다.

아니면 SGDClassifier 또는 SDGRegressor를 사용해 볼 수도 있습니다.

선형 모델은 샘플에 비해 특성이 많을 때 잘 작동하며 다른 모델로 학습하기 어려운 매우 큰 데이터셋에도 선형 모델을 많이 사용합니다.

하지만 저 차원의 데이터셋에서는 ( 특성이 많이 없는 ) 데이터셋에서는 다른 모델들의 일반화 성능이 더 좋습니다. 

 

다음 블로그에서는 의사결정 트리에 대하여 다뤄보도록 하겠습니다!

728x90
반응형
LIST
728x90
반응형
SMALL

지난 선형 회귀 포스팅에 이어 이번 포스팅에서는 선형 이진 분류에 대하여 알아보도록 하겠습니다.

2023.05.02 - [Programming/특성 공학] - [Machine Learning] 선형 회귀

 

[Machine Learning] 선형 회귀

이번 블로그는 선형 모델에 대하여 알아보도록 합시다. 선형 모델은 매우 오래전 개발된 모델입니다. 선형 모델은 입력 특성에 대한 선형 함수를 만들어 예측을 수행합니다. 먼저 회귀의 선형

yuja-k.tistory.com

선형 모델은 '분류'에서도 사용됩니다.

먼저 이진 분류부터 확인해 보겠습니다! 이진 분류를 위한 방정식은 다음과 같습니다.

위의 방정식은 선형 회귀와 매우 비슷한데, 이러한 특성들의 가중치 합을 그냥 사용하는 대신, 그 결과가 임계치라고 할 수 있는 0과 비교하여 0보다 작으면 클래스를 -1로 분류하고, 0보다 크면 +1로 예측합니다.

위의 규칙은 모든 선형 모델에서 동일하게 작동하며, 여기에서도 𝑤와 𝑏를 찾기 위한 여러 가지 방법들이 있습니다.

먼저 회귀에서는 𝑦̂ 이 특성의 선형 함수가 되었었습니다. 분류용 선형 모델에서는 결정 경계가 입력 특성의 선형 함수입니다.

즉 이진 선형 분류기는 선, 평면, 초평면을 사용하여 두 개의 클래스를 구분하는 분류기라고 생각하면 됩니다.

선형 모델을 학습시키기 위한 알고리즘은 다양한데, 다음의 두 방법으로 구분합니다.

.

  • 특정 계수(𝑤)와 절편(𝑏)의 조합이 훈련 데이터에 얼마나 잘 맞는지 측정하는 방법
  • 사용할 수 있는 규제가 있는지, 있다면 어떤 방식인지

각 알고리즘마다 훈련세트를 잘 학습하는지를 측정하는 방법은 각기 다릅니다. 불행하게도 수학적이고 기술적인 이유로, 알고리즘이 만드는 잘못된 분류의 수를 최소화하도록 𝑤와 𝑏를 조정하는 것은 불가능합니다. 손실이 일어난다고 할 수 있고, 완벽히는 아니지만 손실을 최소화하는 방법이 여럿 존재 합니다.

 

위에서 이야기한 첫 번째 목록( 손실 함수 loss function 라 합니다. )에 대한 차이는 별로 중요하지는 않습니다. 직접 잘못된 결과를 나타내는 0-1 손실 함수는 완전한 계단 함수입니다. 따라서 대신 사용할 수 있는 함수( surrogate loss function )를 사용하여 대신 최적화 합니다.

우리가 가장 널리 사용 할 수 있는 함수는 두 가지가 있습니다.

  • 로지스틱 회귀 (logistic Regression) - linear_model.LogisticRegression에 구현되어 있음 - 이진 분류에서 logistic 손실 함수 사용, 다중 분류에서 교차 엔트로피( cross-entropy ) 손실 함수 사용
  • 서포트 벡터 머신 ( Support Vector Machine - SVM ) - 제곱 힌지 ( squared hinge ) 손실 함수 사용

LogisticRegression은 회귀(Regression)가 들어가 있기는 하지만 회귀 알고리즘이 아닌 분류 알고리즘 이기 때문에 LinearRegression(선형 회귀)와 혼동하면 안 됩니다.

이진 분류용 모델인 forge 데이터 세트를 이용하여 LogisticRegression과 LinearSVC 모델을 각각 만들어 이 선형 모델들이 만들어낸 결정 경계를 확인해 보겠습니다.

참고로 두 모델 전부다 L2 규제를 사용하며, 차이점은 사용하는 손실 함수가 다르다는 것뿐입니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from sklearn.model_selection import train_test_split
plt.rcParams['axes.unicode_minus'] = False

import platform
path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry')
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC

X, y = mglearn.datasets.make_forge()

fig, axes = plt.subplots(1, 2, figsize=(10, 3))

for model, ax in zip([LinearSVC(), LogisticRegression()], axes):
    clf = model.fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=False, eps=0.5, ax=ax, alpha=.7)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{}".format(clf.__class__.__name__))
    ax.set_xlabel("특성 0")
    ax.set_ylabel("특성 1")
    
axes[0].legend()

먼저 forge 데이터셋의 첫 번째 특성을 x축에, 두 번째 특성을 y축에 배치시켰습니다.

LinearSVC와 LogisticRegression으로 만들어낸 결정 경계가 직선으로 표현되어 아래쪽은 특성 0으로, 위쪽은 특성 1로 구분한 것이 확인됩니다.
즉, 새롭게 추가될 데이터가 직선을 기준으로 위로 놓이게 되면 특성 1을 의미하고, 아래쪽으로 놓이면 특성 0으로 분류할 것이라고 분류될 것입니다. 두 모델은 비슷한 결정 경계를 만들었는데, 각각 똑같이 두 개의 포인트를 잘못 구분한 것이 확인됩니다.


각 모델의 규제의 강도를 줄이는 매개변수는 C 값을 활용합니다. 여기서 C 값이 높아지면 규제가 감소하고, C값이 낮아지면 규제가 증가합니다.

즉, C값을 높이 지정하면 훈련 세트에 최대한 가깝게 맞추기 위해 노력하고, C값을 낮추면 계수(𝑤)를 0에 가깝게 맞추도록 노력하게 됩니다.

다르게 설명할 수도 있는데, C값이 낮아지면 데이터 포인트 중 다수에 맞추려고 노력하고, C 값을 높이면 개개의 데이터 포인트를 정확히 분류하려고 노력합니다.

 

다음은 C값에 따라서 LinearSVC의 결정경계가 달라지는 모양을 알아봅니다.

mglearn.plots.plot_linear_svc_regularization()

왼쪽 그림은 너무 낮은 C값 때문에 규제가 많이 적용되었습니다. 잘 보면 다수의 데이터 포인트에 몰린 쪽으로 직선이 그어져 있는 것이 확인됩니다. 즉 다수의 포인트에 맞추려고 노력했다는 증거가 될 수 있겠네요

중간 그림은 C값이 조금 커져서 잘못 분류한 샘플에 굉장히 민감해진 것이 확인됩니다. 잘못 분류된 데이터 쪽으로 결정 경계가 그어져 있는 것이 확인되나요?

오른쪽 그림에서 C값을 아주 크게 설정했더니 결정 경계가 엄청나게 기울어졌고 클래스 0의 모든 데이터를 완벽하게 구분한 것이 확인됩니다.

forge 데이터셋의 모든 포인트를 직선으로 완벽히 구분하는 것은 불가능하기에 클래스 1의 포인트 한 개는 여전히 잘못 구분하였습니다.

오른쪽 그림의 모델은 모든 데이터 포인트를 정확하게 분류하려고 애썼지만 클래스의 전체적인 배치를 잘 파악하지 못한 것 같습니다. 즉 과대적합 되었다고 볼 수 있겠네요

회귀와 비슷하게 선형 모델은 낮은 차원의 데이터에서는 결정 경계가 직선 또는 평면이어서 매우 제한적인 것처럼 보입니다. 하지만 고차원에서는 분류에 대한 선형 모델이 매우 강력해지며 특성이 많아지면 과대적합 되지 않도록 규제를 조절하는 것이 중요합니다.

from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()

X_train, X_test, y_train, y_test = train_test_split( cancer.data, cancer.target, stratify=cancer.target, random_state=42)
logreg = LogisticRegression().fit(X_train, y_train)

print("훈련 세트 점수 : {:.3f}".format(logreg.score(X_train, y_train)))
print("테스트 세트 점수 : {:.3f}".format(logreg.score(X_test, y_test)))

기본값 C=1이 훈련 세트와 테스트 세트 양쪽에 95% 정도로 매우 좋은 정확도를 보이긴 하지만 두 세트의 성능이 매우 비슷합니다. 따라서 과소적합인 것 같으니 제약을 더 풀어주기 위해 C를 증가시켜 보겠습니다.

logreg100 = LogisticRegression(C=100).fit(X_train, y_train)

print("훈련 세트 점수 : {:.3f}".format(logreg100.score(X_train, y_train)))
print("테스트 세트 점수 : {:.3f}".format(logreg100.score(X_test, y_test)))

C=100을 사용하니 훈련 세트의 정확도가 높아졌고 테스트 세트의 정확도도 조금 증가하였습니다. 이는 복잡도가 높은 모델일수록 성능이 좋아진다는 것을 의미합니다.

반대로 규제를 더 강하게 하기 위해 C=0.01을 사용해 보겠습니다.

logreg001 = LogisticRegression(C=0.01).fit(X_train, y_train)

print("훈련 세트 점수 : {:.3f}".format(logreg001.score(X_train, y_train)))
print("테스트 세트 점수 : {:.3f}".format(logreg001.score(X_test, y_test)))

C=1 인 상태에서 과소 적합이었는데, 여기서 더 규제가 강해져 계수가 미치는 영향도가 줄어들었기 때문에 더욱더 과소적합 되었다고 볼 수 있겠습니다.

규제 매개변수 C 설정을 세 가지로 다르게 하여 계수를 시각화해서 확인해 보겠습니다.

plt.plot(logreg.coef_.T, 'o', label="C=1")
plt.plot(logreg100.coef_.T, '^', label="C=100")
plt.plot(logreg001.coef_.T, 'v', label="C=0.01")
plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
plt.hlines(0, 0, cancer.data.shape[1])
plt.ylim(-5, 5)
plt.xlabel("특성")
plt.ylabel("계수 크기")
plt.legend()

위의 그림을 잘 살펴보면 C 매개변수가 특성에 미치는 영향을 파악할 수 있는데, 릿지 회귀와 비슷한 모양새를 보이고 있습니다.

규제를 강하게 할수록( C 값이 감소할수록 ) 계수들을 0에 가깝게 만들지만 완전한 0으로 만들지는 않는 것이 보이고 있습니다.

그리고 세 번째 계수인 mean perimeter를 보면 C=100, C = 1 일 때는 음수지만 C=0.0001 이면 양수가 되며, C = 1일 때보다 절댓값이 더 큰 것을 확인할 수 있습니다.

이와 같이 모델을 해석하면 계수가 클래스와 특성의 연관성을 알려줄 수도 있습니다.

다른 예로 texture error 특성은 악성인 샘플과 영향이 깊다는 것도 알 수 있습니다. ( 음수 ) 하지만 mean perimeter는 계수의 부호가 바뀜에 따라서 양성이나 악성의 신호 모두가 될 수 있다고도 판단할 수 있습니다.

다음은 L1 규제를 사용한 LogisticRegression입니다.

for C, marker in zip([0.001, 1, 100], ['o', '^', 'v']):
    lr_l1 = LogisticRegression(C=C, penalty="l1").fit(X_train, y_train)
    print("C={:.3f} 인 로지스틱 회귀의 훈련 정확도 : {:.2f}".format(C, lr_l1.score(X_train, y_train)))
    print("C={:.3f} 인 로지스틱 회귀의 테스트 정확도 : {:.2f}".format(C, lr_l1.score(X_test, y_test)))
    plt.plot(lr_l1.coef_.T, marker, label="C={:.3f}".format(C))

plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
plt.hlines(0, 0, cancer.data.shape[1])
plt.xlabel("특성")
plt.ylabel("계수 크기")

plt.ylim(-5, 5)
plt.legend(loc=3)

이진 분류에서의 선형 모델과 회귀에서의 선형 모델 사이에는 유사점이 굉장히 많습니다.

penalty 매개변수를 활용하여 전체 특성을 사용할지( L2 규제 ), 일부 특성만을 사용할지 ( L1 규제 )를 사용할지를 결정할 수 있습니다.

penalty="l2" 또는 penalty="l1"을 설정할 수 있습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 블로그는 선형 모델에 대하여 알아보도록 합시다.

선형 모델은 매우 오래전 개발된 모델입니다. 선형 모델은 입력 특성에 대한 선형 함수를 만들어 예측을 수행합니다. 먼저 회귀의 선형 모델부터 알아보겠습니다

회귀의 선형 모델을 위한 일반화된 예측 함수는 다음과 같습니다.

𝑦̂ =𝑤[0]∗𝑥[0]+𝑤[1]∗𝑥[1]+...+𝑤[𝑝]∗𝑥[𝑝]+𝑏

위의 식에서 𝑥[0]부터 𝑥[𝑝]까지는 하나의 데이터 포인트에 대한 특성을 나타내고, (특성의 수는 𝑝+1 )와 𝑏는 모델이 학습해야 할 파라미터입니다. 𝑦̂ 는 모델이 만들어낸 예측값입니다.

그렇다면 특성이 한 개인 예측 함수는 어떻게 될까요? 다음과 같습니다.

𝑦̂ =𝑤[0]∗𝑥[0]+𝑏

위의 함수를 보면 예전 수학시간에 배운 직선의 방정식이 떠오릅니다. 𝑤[0]은 직선의 기울기( 계수(cofficient)라고도 합니다 )가 되고, 𝑏는 y 축과 만나는 절편( offset 또는 intercept )이 됩니다.

특성이 많아질수록 𝑤는 각 특성에 해당하는 기울기를 모두 가지게 됩니다. 즉 예측값은 입력특성에 𝑤의 가중치를 모두 더한 가중치의 합으로 볼 수 있겠습니다.

머신러닝에서 알고리즘이 주어진 데이터로부터 학습하는 파라미터라서 𝑤와 𝑏를 모델 파라미터라고 합니다.

나중에 살펴보겠지만 모델이 학습할 수 없어 사람이 직접 설정해 줘야 하는 파라미터를 하이퍼 파라미터(Hyper Parameter)라고 합니다.


wave 데이터셋을 이용해 눈으로 확인해 보겠습니다.

 

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
plt.rcParams['axes.unicode_minus'] = False

import platform
path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')




# mglearn 샘플 그래프 보기
mglearn.plots.plot_linear_regression_wave()

 

그려진 그래프를 보면 직선의 방정식이 생각나는데요, 기울기는 대략 0.4, 절편은 0에 가깝게 나타나고 있는 것이 확인됩니다.

회귀 모델을 위한 선형 모델은 특성이 하나인 경우에는 직선, 두 개면 평면이 되며, 세 개 이상( 더 높은 차원 )이 되면 초평면(Hyperplane)이 되는 회귀 모델의 특징을 가지고 있습니다.

위의 그래프와 이전에 했었던 KNeighborsRegressor를 사용하여 만든 그래프를 비교해 보면 어떤가요? 직선을 지나는 점이 얼마 없는 것으로 보아 데이터의 상세정보를 대부분 잃어버린 것처럼 보이지 않나요?

사실 wave 같은 저 차원 데이터 셋에서는 타깃의 𝑦의 특성이 선형 조합이라고 생각하는 것은 매우 비현실 적인 가정입니다. 직선을 따라 데이터가 쭉 연결되지는 않으니까요.

하지만 1차원 데이터셋만 놓고 봐서 생긴 우리의 편견 일 수도 있습니다. 특성이 많은 데이터 셋이라면 선형 모델은 매우 훌륭한 성능을 발휘하며, 훈련 데이터보다 특성이 더 많은 경우엔 어떤 타깃 𝑦도 완벽하게 훈련 세트에 대해서 선형 함수로 모델링할 수 있습니다.

 

회귀를 위한 선형 모델은 다양합니다.

인기 있는 몇 가지 선형 모델을 살펴보려고 합니다. 이 모델들은 훈련 데이터로부터 모델 파라미터 𝑤와 𝑏학습하는 방법모델의 복잡도를 제어하는 방법에서 차이가 납니다.

선형 회귀 Linear Regression (최소제곱법)

선형 회귀(Linear Regression) 또는 최소 제곱법(OLS, Ordinary Least Squares)은 가장 간단하고 오래된 회귀용 선형 알고리즘이라고 할 수 있습니다.

선형 회귀는 훈련 세트에 있는 타깃 y 사이에 평균 제곱 오차(MSE - Mean Squared Error)를 최소화하는 모델 파라미터 𝑤와 𝑏를 찾습니다. 참고로 MSE는 다음과 같습니다.

 

위의 수식의 𝑛은 샘플의 개수입니다. 이를 𝐿2 norm을 적용했다라고 이야기 합니다.

위의 수식이 조금 불편 하긴 하지만 사실 MSE는 모델이 예측한 예측값( 𝑦𝑖^ )과 훈련 세트로 인해 훈련된 값 타깃값( 𝑦𝑖 )의 차이를 제곱하여 더한 후에 평균을 구한 것이라고 보면 됩니다. ( 샘플의 개수로 나눈 것 )


from sklearn.model_selection import train_test_split # 일반화 성능 평가를 위해 기존 데이터를 훈련 세트와 테스트 세트로 나눔

from sklearn.linear_model import LinearRegression
X, y = mglearn.datasets.make_wave(n_samples=60) # 60개의 샘플 데이터 준비
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42) # 훈련, 테스트 데이터셋 준비

lr = LinearRegression().fit(X_train, y_train) # 선형 회귀 모델에 훈련!

모델이 데이터를 입력받고 훈련을 통해 알아내야 할 𝑤( 가중치 - weight 또는 계수 - cofficient )와 𝑏( 편향 - offset 또는 절편 - intercept ) 은 각각 coef와 intercept 변수에 들어 있습니다.

print("lr의 계수(weight 또는 cofficient) : {}".format(lr.coef_))
print("lr의 편향(offset 또는 intercept) : {}".format(lr.intercept_))

위의 결과에서 알 수 있는 사실 중 하나는 coef값은 NumPy 배열 형태이지만 intercept 값은 언제나 실수(float) 값 하나라는 사실입니다.

즉 coef 값은 각 특성 부여되는 가중치들의 배열이라는 사실을 알 수 있고, intercept 속성은 그 가중치에 대한 조정값이라는 점입니다.

wave 데이터 셋은 입력 특성이 하나밖에 없기 때문에 배열의 길이도 1이라는 사실을 알 수 있습니다.

print("훈련 세트 점수 : {}".format(lr.score(X_train,y_train)))
print("테스트 세트 점수 : {}".format(lr.score(X_test, y_test)))

 

단순히 선형 회귀(LinearRegression) 모델을 훈련시킨 후 점수를 확인해 보니 𝑅2 값이 66% 정도로 별로 좋지 않습니다. 또한 훈련 세트의 점수와 테스트 세트의 점수가 거의 비슷한 것을 확인할 수 있는데, 이는 과소적합인 상태를 의미합니다. 많이 생각할 필요 없이 우리가 테스트 용도로 사용한 wave 데이터 셋은 특성이 하나뿐인 1차원 데이터 셋이기 때문에 과대적합을 걱정하지 않아도 됩니다. 하지만 지금부터 사용해 볼 고차원 데이터 셋인 보스턴 주택 가격 데이터셋에 대해서는 선형 모델의 성능이 매우 높아지기 때문에 과대적합이 될 가능성이 있습니다!

X, y = mglearn.datasets.load_extended_boston()

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
lr = LinearRegression().fit(X_train, y_train)

print("훈련 세트 점수 : {:.2f}".format(lr.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lr.score(X_test, y_test)))

 

테스트 결과 훈련 세트의 𝑅2는 95%지만, 테스트 세트의 점수는 61%입니다. 이는 모델이 과대적합되었다는 확실한 신호입니다. 따라서 우리는 모델의 일반화를 위해 복잡도를 제어할 수 있어야 하겠습니다. (각 특성별 가중치를 조절합니다.) 기본 선형 회귀 방식인 LinearRegression 모델로는 파라미터를 통해 복잡도를 제어 할 수 없으니, 여러 가지 회귀 모델을 알아보도록 하겠습니다.


릿지 Ridge 회귀

릿지(Ridge)도 회귀를 위한 선형 모델이므로 최소 제곱법 같은 예측 함수를 사용합니다. 릿지 회귀에서의 가중치(𝑤) 선택은 훈련 데이터를 잘 예측하기 위해서 뿐만 아니라 추가 제약 조건을 만족시키기 위한 목적도 있습니다. 즉 𝑤의 모든 원소가 0에 가깝게 만들어 가중치의 절댓값을 가능한 한 작게 한다는 뜻입니다. 결론적으로는 모든 특성이 예측(출력)에 주는 영향을 최소화하겠다는 뜻이 됩니다. 즉 𝑤에 의한 그래프의 기울기가 작아집니다. 이러한 제약 사향들을 규제(regularzation)이라고 합니다. 규제란 과대적합이 되지 않도록 모델을 강제로 제한한다는 뜻이 됩니다. 먼저 아무런 규제의 페널티가 없는 상황부터 살펴보겠습니다.

from sklearn.linear_model import Ridge

ridge = Ridge().fit(X_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(ridge.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge.score(X_test, y_test)))

 

결과를 확인해 보니 훈련 세트에 대한 점수는 낮지만 테스트 세트에 대한 점수는 더 높네요. 선형 회귀(LinearRegression)는 보스턴 데이트 셋에 대해 과대적합 되지만 Ridge 회귀 방식은 더 자유로운 ( 특성에 제한이 걸리는 ) 모델이기 때문에 과대적합이 적어진다고 볼 수 있습니다.

따라서 모델의 적합도가 낮아졌다고 볼 수 있는데, 이렇게 모델의 복잡도가 낮아지면 훈련 세트에서의 성능은 나빠지지만 더욱 일반화된 모델이 됩니다.

우리는 테스트 세트에 대한 성능이기 때문에 보스턴 데이터셋에는 일반 선형 회귀보다는 Ridge 회귀가 어울리는 것 같네요


페널티

여기서 페널티에 대해 잠깐 이야기 하자면, 패널티란 예측 결과물에 대한 오차 범위 허용이라고 볼 수 있습니다. 이정도 오차는 괜찮아~ 라고 말 하는 것과 비슷합니다. 간단한 예로 택시의 예상 도착 시간을 예측 한다고 했을 때 예상 한 것 보다 1~2분 늦는 것은 별로가 문제가 되지 않으나, 10 ~ 20분 늦는 것은 예측이 매우 실패 했다 라고 판단 할 수 있습니다. 우리가 위에서 사용한 MSE(Mean Squad Error) 같은 공식이 예측값의 패널티에 대한 공식 같은 것이라고 판단하면 됩니다. MSE의 공식을 자세히 보면 오차 제곱( 타깃값 - 예측값의 제곱 )을 구하고 있는데, 이는 오차가 커지면 커질수록 더욱더 많은 페널티를 부여한다고 보면 됩니다. 보통 사용되는 다른 공식으로써 MAE(Mean Absolute Error)라는 것이 있습니다.

MSE와 다른 점은 MAE는 오차에 대한 페널티가 단순히 오차의 절대 값인 것을 확인할 수 있습니다. 이를 𝐿1 norm이라고 합니다. 즉 MSE는 오차가 커질수록 페널티가 커지고, MAE는 오차가 커질 수록 패널티가 일정 하다 라고 생각 해 볼 수 있겠습니다. 패널티를 계산하는 공식에는 RMSE, RMAE 등등의 여러가지 공식들이 있습니다.

Ridge 회귀에서의 패널티

Ridge는 모델을 단순하게 ( 계수 - 𝑤를 0에 가깝게 ) 해주고 훈련 세트와 테스트 세트 사이의 선능 사이를 절출 할 수 있는 방법을 제공합니다. 우리는 Ridge 회귀의 alpha 매개변수를 조절하여 모델의 성능을 단순화할 수 있습니다. 매개변수를 아무것도 넣지 않으면 alpha는 1.0을 기본적으로 사용하고 있었습니다. 참고로 alpha 값을 높이면 계수를 0으로 점점 가깝게 설정해 페널티의 효과가 커져 가중치가 차지하는 값이 0에 가까워져 모델이 단순해지고, alpha 값을 낮추면 점점 가중치가 높아져 모델이 복잡해집니다. Ridge 회귀를 사용할 때 최적화된 alpha 값은 사용하는 데이터셋에 따라 달라집니다. 바로 예를 들어 한번 보겠습니다. alpha 값을 10으로 조절한 경우입니다.

ridge10 = Ridge(alpha=10).fit(X_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(ridge10.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge10.score(X_test, y_test)))

alpha값을 10으로 높였더니 페널티의 효과가 높아져 가중치가 감소 한 것이 확인 됩니다. 즉 모델이 점점 단순화 되어 과소 적합 되어 가고 있다고 판단 할 수 있습니다.

이번엔 반대로 alpha 계수를 낮춰서 패널티의 효과를 줄이고 가중치를 증가시켜 보겠습니다.

ridge01 = Ridge(alpha=0.1).fit(X_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(ridge01.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge01.score(X_test, y_test)))

테스트 세트의 점수가 꽤나 높아졌습니다. 보스턴 주택가 데이터셋을 Ridge 회귀로 분석했을 때 alpha=0.1이 꽤나 좋은 성능을 내는 것 같네요.

이번엔 alpha 값에 따라서 각 모델의 coef_ ( 가중치 값 )이 어떻게 달라지는지 시각화해서 살펴보겠습니다.

예상을 해보자면 높은 alpha 값은 제약이 적은 모델이기 때문에 ( 가중치가 0에 점점 가까워지기 때문에 ) coef_의 절댓값의 크기가 작을 것 같네요. 확인해 보겠습니다.

plt.plot(ridge10.coef_, '^', label="Ridge alpha 10")
plt.plot(ridge.coef_, 's', label="Ridge alpha 1.0")
plt.plot(ridge01.coef_, 'v', label="Ridge alpha 0.1")

plt.plot(lr.coef_, 'o', label="LinearRegression")
plt.xlabel("계수 목록")
plt.ylabel("계수 크기")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)
plt.legend()

뭔가 굉장히 복잡해 보이네요, 먼저 X축은 coef_의 원소를 위치대로 나열한 것입니다. 즉 x=0은 첫 번째 특성, 약간 100을 넘는 값은 마지막 특성이라고 보면 될 것 같습니다.

y축은 계수의 수치를 나타내는데, alpha=10 일 때 ( 파란색 세모 ) 대부분의 계수는 -3부터 3 사이에 위치하는 것을 볼 수 있습니다. alpha=1 ( 주황색 네모 )의 계수의 크기는 조금 더 커져 가중치가 증가한 것이 확인됩니다. alpha=0.1 ( 초록색 세모 ) 같은 경우는 계수의 크기가 더 커져 가중치가 1일 때 보다 더 커진 것을 확인할 수 있고

alpha 값이 0인 ( 규제가 전혀 없는 ) LinearRegression 같은 경우는 그래프를 벗어나는 특성도 존재하는 것을 확인해 볼 수 있습니다.

 

Ridge에서 alpha 값은 고정되고, 데이터의 개수를 조절한다면?

규제의 효과를 확인해 보기 위해서 alpha를 1로 고정한 채로 훈련 데이터의 크기만 변화를 시켜 데이터 세트의 크기에 대해 훈련 효과를 확인해 보겠습니다.

보스턴 주택 가격 데이터세트에서 여러 가지 크기로 훈련시켜 LinearRegression과 Ridge(alpha=1)을 적용한 그래프를 확인 해 보겠습니다.

mglearn.plots.plot_ridge_n_samples()

릿지와 선형 회귀 모두 훈련 세트의 점수 ( 점선 )가 테스트 세트의 점수 ( 실선 ) 보다 높은 것을 확인할 수 있습니다.

여기서 살펴볼 수 있는 사실은 릿지 회귀에는 규제가 적용되기 때문에 훈련 데이터의 점수가 대체적으로 선형 회귀보다 낮은 것을 확인할 수 있습니다. 이는 데이터 세트의 개수가 적으면 적을수록 더 확연히 확인해 볼 수 있습니다.

데이터 크기가 400 미만에서는 선형 회귀는 무엇도 학습하지 못하고 있는 것이 확인됩니다.

즉 두 모델의 성능은 ( 테스트 데이터세트의 결과 ) 데이터가 많으면 많을수록 좋아지며, 마지막에는 선형 회귀가 릿지 회귀의 테스트 점수를 따라잡는 것이 확인됩니다.

정리하자면 데이터를 충분히 주게 되면 규제 자체는 덜 중요해져 릿지 회귀와 선형 회귀의 성능이 같아질 것이라는 것을 예상해 볼 수 있다는 점입니다.

또 하나 이상한 점은 주황색 점선 ( 훈련 데이터셋 점수 )가 점점 내려가는 것을 확인할 수 있는데, 이는 선형 회귀의 훈련 데이터셋에 대한 성능이 점점 감소하는 것을 의미합니다.

이는 데이터가 많아지면 많아질수록 모델이 데이터를 기억하거나 과대적합 하기 어려워진다는 것을 의미합니다.


라쏘 Lasso 회귀

라쏘 회귀 방식도 릿지와 비슷하게 계수에 규제를 걸어 계수를 0에 가깝게 만들기 위한 노력을 합니다. 릿지 회귀와의 차이점은 릿지 회귀는 L2 규제 방식을 사용하는데 비해 라쏘 회귀는 L1 규제 방식을 사용하며, 실제 어떤 계수는 실제로 0이 되기도 한다는 점입니다.

계수가 0이 되면 해당 특성은 전혀 상관이 없이 완전히 제외된다는 뜻이 됩니다.

어떻게 보면 라쏘 회귀는 특성 선택( feature selection )이 자동으로 이루어진다고도 볼 수 있습니다.

일부 계수를 0으로 만들면 모델을 이해하기가 쉬워지고 이 모델의 가장 중요한 특성이 무엇인지가 드러납니다.

보스턴 주택가격 데이터셋에 라쏘를 적용시켜 보겠습니다.

from sklearn.linear_model import Lasso

lasso = Lasso().fit(X_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(lasso.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso.score(X_test, y_test)))
print("사용한 특성의 수 : {}".format(np.sum(lasso.coef_ != 0)))

확인 결과 라쏘는 훈련 세트와 테스트 세트의 점수가 전부 다 좋지 않습니다. 사용한 특성도 4개 정도밖에 안 되는 것으로 보아 과소적합이라고 생각할 수 있겠습니다.

릿지와 비슷하게 라쏘도 계수를 얼마나 강하게 보낼지를 조절하는 alpha 매개변수가 있습니다. 앞서 본 릿지에서는 기본적으로 alpha=1.0을 사용했었습니다.

과소적합을 줄이기 위해 alpha 값을 줄여보겠습니다. 하지만 이때 최대 반복 횟수를 의미하는 max_iter 값을 늘려 줘야 합니다.

max_iter는 내부적으로 Lasso의 학습 과정이 진행되는 최대 횟수를 의미합니다. 한 특성 씩 좌표축을 따라 최적화되는 좌표 하강법 방식을 사용하며 학습 과정이 max_iter에 지정된 횟수만큼 반복 횟수가 설정 되게 됩니다. lasso.niter를 이용해 반복 횟수를 확인할 수 있습니다.

lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(lasso001.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso001.score(X_test, y_test)))
print("사용한 특성의 수 : {}".format(np.sum(lasso001.coef_ != 0)))

alpha 값을 줄여 봤더니 모델의 복잡도가 증가하여 훈련 세트와 테스트 세트의 점수가 모두 좋아졌습니다. 성능 자체가 릿지보다 조금 더 낫네요!

사용된 특성 자체가 105개 중 33개뿐이어서 모델을 분석하기가 쉬워진 것 같습니다.

하지만 alpha 값을 너무 낮추면 규제가 그만큼 효과가 없어지기 때문에 과대적합이 되므로 LinearRegression의 결과와 비슷해집니다.

lasso0001 = Lasso(alpha=0.0001, max_iter=1000000).fit(X_train, y_train)

print("훈련 세트 점수 : {:.2f}".format(lasso0001.score(X_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso0001.score(X_test, y_test)))
print("사용한 특성의 수 : {}".format(np.sum(lasso0001.coef_ != 0)))

마찬가지로 alpha 값에 따른 다른 모델들의 계수를 그래프로 그려 보겠습니다.

plt.plot(lasso.coef_, 's', label="Lasso alpha=1")
plt.plot(lasso001.coef_, '^', label="Lasso alpha = 0.01")
plt.plot(lasso0001.coef_, 'v', label="Lasso alpha = 0.0001")

plt.plot(ridge01.coef_, 'o', label="Ridge alpha = 0.1")
plt.legend(ncol=2, loc=(0, 1.05))
plt.ylim(-25, 25)
plt.xlabel("계수 목록")
plt.ylabel("계수 크기")

alpha가 1일 때( 파란색 )는 계수의 대부분이 0인 것을 알 수 있고, 나머지 계수들도 크기가 작다는 것이 확인됩니다. alpha를 0.01로 줄이면 ( 주황색 세모 ) alpha가 1일 때보다는 적지만 마찬가지로 계수 대부분이 1인 것이 확인 됩니다.

하지만 alpha 값이 0.0001이 되면 ( 초록색 세모 ) 계수 대부분이 0이 아니게 되고 그 값이 커지는 것이 확인 됩니다.

alpha 값이 0.1인 릿지 모델은 Lasso 모델과 비교해 성능은 비슷하지만 어떠한 계수도 0이 되지 않는 것이 확인 됩니다.

실제로 Lasso와 Ridge 중에서 릿지 회귀를 선호합니다.

하지만 입력 특성 자체가 많고 그중 일부분만 중요한 특성일 경우에는 Lasso가 더 좋은 선택이 될 수가 좋습니다. 또한 분석하기 쉬운 모델을 원한다면 Lasso가 일부 모델만 사용하므로 쉽게 해석할 수 있는 모델을 만들어 주게 될 수도 있습니다.

 

728x90
반응형
LIST
728x90
반응형
SMALL

지난 2023.04.18 - [Programming/특성 공학] - [Machine Learning] 지도 학습의 종류

 

[Machine Learning]지도 학습의 종류

2023.04.14 - [Programming/특성 공학] - [Machine Learning]지도 학습에서 언급했듯이 모델 파라미터 즉, 매개변수의 종류는 다양합니다. 그래서 이번 포스트에서는 지도 학습의 종류에 대하여 알아보도록

yuja-k.tistory.com

에 이어 먼저 붓꽃 분류를 위해 사용했었던 k-최근접 이웃(k-NN) 알고리즘부터 다시 시작 해 보겠습니다.

K-NN은 무엇인가

k-NN(k-Nearest Neighbors) 알고리즘은 제일 간단한 머신러닝 알고리즘 입니다. 단순히 훈련할 데이터셋(training data set) 저장하는 것이 머신러닝 모델을 만드는 것이 전부입니다.

새로운 데이터 포인트를 예측할 때는 훈련 데이터셋으로 만들어 놓은 k-NN 모델에서 가장 가까운 데이터 포인트, 즉 최근접 이웃을 찾습니다.

#필요 라이브러리 임포트
from IPython.display import display
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
plt.rcParams['axes.unicode_minus'] = False

import platform
path = 'c:/Windows/Fonts/malgun.ttf'
from matplotlib import font_manager, rc
if platform.system() == 'Darwin':
    rc('font', family='AppleGothic')
elif platform.system() == 'Windows':
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry!')
K-NN 분류 모델

mglearn 라이브러리에 이미 forge 데이터 셋을 이용해 k-NN 알고리즘을 적용하고 나서 시각화 한 내용이 있습니다. 바로 확인해 보죠!

mglearn.plots.plot_knn_classification(n_neighbors=1) # n_neighbors : 이웃의 갯수

뭔가 복잡한 것 같지만, 모양으로 한번 확인해 보겠습니다.

동그라미 모양의 데이터들은 훈련 데이터입니다. 입니다. k-NN 모델 객체에 훈련시킨 데이터가 표시되어 있습니다.

별 모양의 데이터들은 테스트 데이터로써, 선을 이용해 각 훈련된 데이터 포인트에서 가장 가까운 이웃과 선이 연결되어 있습니다.

n_neighbors 파라미터의 값을 변경하면 가장 가까운 여러 개의 이웃이 선택되고, 둘 이상의 이웃이 선택되면 레이블( 분류 결과 - 그래프에서는 색상 )을 정하기 위해 투표를 합니다.

즉 테스트 포인트 하나에 대해서 클래스 0( 파란색 )에 속한 이웃이 몇 개인지, 클래스 1( 주황색 )에 속한 이웃이 몇 개인지를 셉니다. 그리고 이웃이 더 많은 클래스를 레이블로 지정합니다.

정리하자면 테스트 데이터에 대해 k-최근접 이웃 중 다수의 클래스가 레이블이 된다고 볼 수 있습니다. 이어서 3개의 최근접 이웃을 사용한 예를 보겠습니다.

mglearn.plots.plot_knn_classification(n_neighbors=3) # 이웃이 3개

이웃의 개수 ( n_neighbors 파라미터 )를 3개로 조절했더니 그래프 상에서는 별 모양의 테스트 데이터에 대해 3개의 훈련 데이터 포인트가 연결된 것을 확인할 수 있습니다.

또한 이웃을 한 개만 이용했을 때와, 세 개의 이웃을 사용했을 때 결과가 달라지는 것도 확인할 수 있습니다.

단순한 특성 1, 특성 2를 활용한 단순한 이진 분류 문제이지만, 우리가 k-NN 모델을 사용한다면 클래스가 다수인 데이터셋에도 같은 방법을 적용할 수 있습니다.

클래스가 여러 개일 때도 각 클래스에 속한 이웃이 몇 개인지를 헤아려 가장 많은 클래스를 예측값으로 사용합니다. 본격적으로 k-NN 알고리즘 적용에 대해 알아보겠습니다.

from sklearn.model_selection import train_test_split # 일반화 성능 평가를 위해 기존 데이터를 훈련 세트와 테스트 세트로 나눔
X, y = mglearn.datasets.make_forge()

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

모델을 만드는 방법은 간단합니다. k-NN 이웃 알고리즘은 scikit-learn에서 KNeighborsClassifier로 제공되고 있습니다

from sklearn.neighbors import KNeighborsClassifier #k-NN 분류 임포트
clf = KNeighborsClassifier(n_neighbors = 3) # 이웃의 갯수를 3개 갖는 모델 생성

이어서 훈련 세트를 사용해 KNeighborsClassifier 모델 객체( clf )를 훈련( fit ) 시켜 봅시다.

clf.fit(X_train, y_train) # 훈련하기

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=3, p=2, weights='uniform')


잘 훈련되었으면 테스트 데이터에 대해 예측( predict ) 해보겠습니다.

print("테스트 세트 예측: {}".format(clf.predict(X_test)))

테스트 세트 예측: [1 0 1 0 1 0 0]

 

방금 만든 모델이 얼마나 잘 일반화되었는가를 판단하기 위해 score 메소드에 테스트 데이터와 테스트 레이블을 넣어서 확인합니다.

print("테스트 세트 정확도: {:.2f}".format(clf.score(X_test, y_test)))

테스트 세트 정확도: 0.86


우리가 만든 모델의 정확도는 86%가 나왔습니다. 즉 모델이 테스트 데이터셋에 있는 샘플 중 86%를 정확히 예측한 것입니다.

이어서 이웃의 수에 따라서 k-NN 모델이 어떻게 데이터를 구분하는지 평면에 색을 칠해 경계를 나눠 보겠습니다.

이처럼 클래스 0과 클래스 1로 지정한 영역으로 나뉘는 경계를 결정 경계 (decision boundary)라고 합니다

fig, axes = plt.subplots(1, 5, figsize=(20,3))

for n_neighbors, ax in zip([1,3,6,9,26], axes):
    # fit 메소드는 self 반환을 하기 때문에 객체 생성과 메소드를 한줄에 사용 할 수 있습니다.
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:,0], X[:,1],y, ax=ax)
    ax.set_title("{} 이웃".format(n_neighbors))
    ax.set_xlabel("특성 0")
    ax.set_ylabel("특성 1")
    
axes[0].legend(loc=3)

<matplotlib.legend.Legend at 0x1 c14 acab38>


위의 그래프를 한번 분석해 보겠습니다.

  • 이웃이 1개인 경우는 결정 경계가 훈련데이터에 가깝게 나눠지고 있습니다. 즉 모델의 복잡도가 증가했습니다. (과대적합 가능성)
  • 이웃이 3개인 경우는 결정 경계가 1개일 때보다 약간 부드러워졌네요. 이는 모델의 복잡도가 감소한 것을 의미합니다.
  • 이웃이 6개인 경우는 결정 경계가 클래스들이 위치한 것과 비슷한 구역을 각각 나눠 갖은것 같습니다.
  • 이웃이 9개인 경우는 결정 경계가 6개 일 때 보다 훨씬 완만해집니다. 가운데쯤에 있는 특성 1 때문에 그런 것 같습니다. 모델이 점점 더 단순해지는 것 같네요( 과소 적합 가능성)
  • 극단적으로 26개의 이웃을 가진 경우는 모든 데이터를 하나로 분석해 버립니다. k-nn은 이웃의 개수로 투표를 하기 때문인 것 같습니다.

위의 분석 내용과 그래프로 알 수 있는 사실은 모델의 개수가 너무 적으면 복잡도가 증가해 과대적합 가능성이 생겨버리고, 모델의 개수가 많으면 복잡도가 감소해 과소 적합 가능성이 생긴 다는 것을 알 수 있습니다.

 

유방암 데이터를 이용해 k-NN 알아보기

모델의 복잡도와 일반화 사이의 관계를 입증해 보도록 하겠습니다. 이웃의 개수에 따라 얼마나 k-NN이 잘 일반화되는지를 알아보겠습니다.

먼저 유방암 데이터에 대해 훈련 세트와 테스트 세트를 준비해 보겠습니다. 그러고 나서 이웃의 개수를 따로 하여 얼마나 정확도가 증가하고 알맞은 모델이 되는지 평가해 보겠습니다.

from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer() #유방암 데이터 불러오기

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, 
                                                    stratify=cancer.target, random_state=66) # 테스트 세트와 훈련 세트 분할

training_accuracy = [] # 각 이웃 개수 별 훈련 세트에 대한 정확도를 저장할 리스트
test_accuracy = [] # 각 이웃 개수 별 테스트 세트에 대한 정확도를 저장할 리스트

#이웃의 개수 설정 (1개 ~ 10개 까지)
neighbors_settings = range(1, 11)

for n_neighbors in neighbors_settings:
    #모델 생성하기
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train, y_train)
    
    #훈련 세트 정확도 저장
    training_accuracy.append(clf.score(X_train, y_train))
    #일반화 정확도 저장
    test_accuracy.append(clf.score(X_test, y_test))
    
plt.plot(neighbors_settings, training_accuracy, label="훈련 정확도") # 이웃 개수에 대한 훈련 세트 정확도 선 그래프 그리기
plt.plot(neighbors_settings, test_accuracy, label="테스트 정확도") # 이웃 개수에 대한 테스트 세트 정확도 선 그래프 그리기
plt.ylabel("정확도")
plt.xlabel("n_neighbors")
plt.legend()

<matplotlib.legend.Legend at 0x102 cdf5 f8>


그래프를 보면 과대적합과 과소적합의 특성을 알 수 있습니다.

  • 이웃의 개수가 적으면 훈련세트의 정확도는 높지만 테스트 세트의 정확도는 낮고 - 과대적합
  • 이웃의 개수가 많아지면 모델이 단순해지면서 훈련 정확도와 테스트 정확도가 동시에 낮아집니다. - 과소적합

여기서 알 수 있는 사실은 이웃이 1개인 경우에는 너무 모델을 복잡하게 만들어 낸다는 사실을 알 수 있네요, 반대로 이웃을 10개 사용했을 때는 모델이 너무 단순해서 정확도가 더욱더 나빠진다는 사실을 알 수 있게 됩니다.

가장 좋은 이웃은 몇 개일까요?테스트 세트의 정확도가 가장 높은 6개 정도의 이웃을 사용했을 때 가장 일반화가 잘 됐다라고 할 수 있겠습니다.

 

K-NN Regression

k-NN 알고리즘은 회귀 분석을 위해서도 사용합니다. wave 데이터셋을 이용해 알아보도록 하죠.

분류와 마찬가지로 mglearn 패키지에 wave 데이터 셋을 이용한 회귀 시각화 그래프가 이미 존재합니다. 먼저 이웃이 한 개인 경우의 회귀 결과입니다.

mglearn.plots.plot_knn_regression(n_neighbors=1)

먼저 파란색 원은 트레이닝 데이터, 초록색 별은 입력한 특성, 마지막으로 파란색 별은 입력한 특성에 대한 회귀 분석 결과입니다.

k-NN 회귀는 이웃의 개수를 다수로 지정하면 이웃 간의 평균이 그 예측값이 됩니다.

mglearn.plots.plot_knn_regression(n_neighbors=3)

이웃의 개수가 한 개일 때는 단순하게 제일 가까운 이웃만을 따져서 파란색 별의 위치가 결정되었지만, 이웃의 개수가 3개가 되면 가장 가까운 3개의 점을 찾아 그 평균을 회귀 결괏값으로 사용하는 것을 알 수 있습니다.

k-NN 회귀는 k-NN 분류와 비슷하게 사용할 수 있습니다. KNeighborsRegressor에 구현되어 있습니다.

from sklearn.neighbors import KNeighborsRegressor # k-NN 회귀를 위한 KNeighborsRegressor 임포트

X, y = mglearn.datasets.make_wave(n_samples=40)

#wave 데이터셋을 훈련 세트와 테스트 세트로 나누기
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# 이웃의 수를 3으로 하여 모델 객체 생성하기
reg = KNeighborsRegressor(n_neighbors = 3)

# 훈련 데이터와 타깃을 사용하여 모델 학습 시키기
reg.fit(X_train, y_train)

print("테스트 세트 예측 :\n{}".format(reg.predict(X_test)))

테스트 세트 예측 :
[-0.05396539  0.35686046  1.13671923 -1.89415682 -1.13881398 -1.63113382
  0.35686046  0.91241374 -0.44680446 -1.13881398]

 


이 역시 score 메소드를 이용해 점수를 알 수 있는데요, score 메소드는 회귀분석일 때는 $R^2$ 값을 반환합니다.

여기서 $R^2$ 값은 결정 계수 라고 하며 회귀 모델에서의 예측의 적합도를 0 ~ 1 사이의 값으로 계산한 것입니다. 공식은 다음과 같습니다. \begin {align} \\R^2=1-\frac {\sum{({y-\hat {y})^2}}}{\sum{({y-\bar {y})^2}}} \end {align}

의미하는 바는 다음과 같습니다. $y$ 는 타깃값이고, $\bar {y}$는 타깃값($y$ 들)의 평균이며, $\hat {y}$는 모델의 예측값입니다.

즉 $y$는 우리가 맞춰야 할 값( 훈련된 데이터 ), $\bar {y}$는 훈련된 데이터들의 평균값, $\hat {y}$는 우리가 만든 모델이 테스트 데이터에 대해 예측한 값입니다.

따라서 훈련데이터들(X_train)의 타깃값으로 사용한 y_train을 예측 데이터로 사용하게 되면 $R^2$의 공식에서 $\hat {y}$이 $\bar {y}$와 같게 되고, 분자와 분모가 같아져 $R^2$값이 0이 되게 됩니다.

1은 예측이 완벽한 경우, 0은 훈련 세트의 출력값인 y_train의 평균으로만 예측하는 모델의 경우입니다.

print("테스트 세트 R^2 : {:.2f}".format(reg.score(X_test, y_test)))

테스트 세트 R^2 : 0.83

 

우리가 만든 모델에서 예측한 값은 83% 정도로 비교적 잘 맞는 것 같네요!

wave 데이터셋을 계속 이용하여 이웃의 개수(n_neighbors)에 따른 테스트 세트의 성능을 판단해 보겠습니다.

fig, axes = plt.subplots(1,4, figsize=(20,4))
#-3과 3 사이에 1000개의 데이터 만들기 -> 테스트 용도로 사용함
line = np.linspace(-3, 3, 1000).reshape(-1, 1)
for n_neighbors, ax in zip([1,3,5,9], axes):
    # 이웃의 개수를 1,3,9로 하여 예측하는 모델을 만듭니다
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train, y_train)
    ax.plot(line, reg.predict(line)) # 테스트 용도로 만든 데이터를 예측하고 예측 결과를 선으로 표현합니다.
    ax.plot(X_train, y_train, '^', c=mglearn.cm2(0), markersize=8) # 훈련 데이터를 그래프에 표시합니다.
    ax.plot(X_test, y_test, 'v', c=mglearn.cm2(1), markersize=8)   # 테스트 데이터를 그래프에 표시합니다.
    
    # 훈련 데이터의 점수와 테스트 데이터의 점수를 제목에 표현합니다.
    ax.set_title("{} 이웃의 훈련 스코어: {:.2f} / 테스트 스코어 : {:.2f}".format(n_neighbors, reg.score(X_train, y_train), reg.score(X_test, y_test)))
    ax.set_xlabel("특성")
    ax.set_ylabel("타깃")

axes[0].legend(["모델 예측", "훈련 데이터/타깃", "테스트 데이터/타깃"], loc="best")

<matplotlib.legend.Legend at 0x1 c1744 d588>


첫 번째 그래프부터 확인해 보겠습니다.

이웃의 개수가 1개인 첫 번째 그래프는 모델을 예측한 라인들이 모두 훈련 데이터를 지나가는 것을 확인할 수 있습니다. 이는 훈련 세트의 각 데이터 포인트들이 예측에 주는 영향이 커서 매우 불안정한 예측이라고 할 수 있습니다.

이에 반에 이웃의 개수가 많아질수록 훈련 스코어가 점점 줄어드는 것을 볼 수 있는데 이는 이웃을 많이 사용할수록 훈련 데이터에는 잘 맞지 않을 수 있지만, 더 안정적으로 예측을 할 수 있게 됩니다.

이웃의 개수가 3개 일 때는 적절히 훈련 데이터와 테스트 데이터를 지나가는 모습을 볼 수 있으며, 그 이상의 이웃이 설정될수록 예측 라인들이 훈련데이터를 빗겨 지나가는 모습을 확인할 수 있습니다. (정확도가 점점 떨어집니다.)

 

장단점과 매개변수

우리는 지금까지 한 개의 매개변수(n_neighbors)만 사용해서 이웃의 개수를 조절하면서 모델의 성능을 체크해 보았습니다. 보통이면 두 개의 매개변수를 활용하는데, 다른 하나는 거리 조절 공식을 따로 준비하는 것입니다.

기본적으로 k-NN은 metic 매개변수를 활용하여 거리 측정 방식을 변경할 수 있으며, 기본값은 민코프스키 거리를 의미하는 'minkowski'가 설정되어 있습니다.

이 민코프스키 거리를 제곱하여 크기를 정하는 p의 기본값이 2일 때 k-NN의 기본 거리 측정 공식인 유클라디안 거리와 같게 됩니다.

k-NN의 장점은 이해하기가 매우 쉬운 모델이라는 점입니다. 또한 많이 조정할 필요 없이 좋은 성능을 발휘하여 k-NN 보다 더 복잡한 알고리즘을 적용하기 전에 테스트해볼 수 있는 좋은 시작점이 됩니다.

단점은 모델 자체는 매우 빠르게 만들어 볼 수 있지만, 훈련 세트가 매우 크면( 특성 또는 샘플 데이터의 개수가 많으면 ) 예측이 느려지게 됩니다. 또한 수백 개의 특성을 가진 데이터 셋에는 잘 동작하지 않고, 희소한 데이터셋 ( 특성값의 대부분이 0인 ) 데이터셋과는 특히 잘 작동할 수 없습니다.

위의 단점에 따라 k-NN은 예측이 느리고 많은 특성을 처리하는 능력이 부족하기에 현업에서는 잘 사용하지 않습니다.

선형모델을 통해 k-NN 알고리즘의 단점을 극복할 수 있습니다.

 

다음 블로그에서는 선형 회귀에 대하여 알아보도록 하겠습니다.

728x90
반응형
LIST

+ Recent posts