K-Means 클러스터

학습의 종류에는 레이블 데이터의 포함 여부에 따라서 지도학습(Supervised Learning)과 비지도학습(Unsupervised Learning)으로 나눌 수 있습니다. 지도학습 알고리즘은 종속변수의 특징에 따라서 분류(Classification)와 회귀(Regression)로 나눌 수 있습니다.
반면 비지도 학습은 레이블 데이터가 없는 형태의 데이터로 클러스터링(Clustering)이 가장 대표적인 기법입니다. 학습 데이터의 Feature를 파악해서 특징을 추출하고 이를 통해서 공통점이 있는 데이터를 묶어주는 형태의 분석기법입니다.

예를 들어서 클러스터링 기법을 활용해서 고객의 구매특징에 따라서 고객군을 묶어 줄 수 있습니다. 그렇게 된다면 고객군을 대상으로하는 맞춤형 마케팅도 가능합니다. 이밖에도 네트워크 유해 트래픽 탐지, 영화나 TV 장면 분류, 권역 설정, 뉴스나 토픽 클러스터링 등 다양한 분야에 활용됩니다. 그리고 이러한 알고리즘은 단독으로 사용되기도 하지만 또 여러 다른 알고리즘과 결합되서 사용되기도 합니다.

이중에서 K-Means 알고리즘은 가장 유명한 클러스터링 알고리즘입니다. “K”는 분석 대상 데이터로부터 클러스터 할 수 있는 수를 의미합니다. 그리고 Means는 각 클러스터의 중심의 평균거리를 의미합니다. 종합해보면 각 클러스터의 중심(Centroid)을 기준으로 주변에 있는 가까운 데이터들을 하나로 묶어주는 과정이라고 할 수 있습니다.

K-Means 알고리즘은 아래와 같은 과정으로 수행됩니다.

  1. Centroid 설정
  2. 각 데이터들을 가까운 Centroid에 속한 그룹에 할당
  3. 2번 과정을 통해서 만들어진 클러스터의 Centroid를 새롭게 지정
  4. 2번,3번의 과정을 Centroid가 변하지 않을때까지 반복 수행

아래의 예제를 통해서 기본적인 컨셉을 알아보겠습니다. 먼저 필요한 라이브러리들을 임포트합니다.

from sklearn.datasets import make_blobs
import pandas as pd
import numpy as np
import math
import scipy as sp
import matplotlib.pyplot as plt

테스트용 데이터를 만들기 위해서 sklearn의 make_blobs() 함수를 사용합니다. 샘플 데이터는 [300 × 2] 행렬입니다. 데이터는 4개의 군집을 가지고 있습니다.

x, y = make_blobs(n_samples=300, centers=4, n_features=2)
df = pd.DataFrame(x, y, columns=['x','y']).reset_index(drop=True)

생성한 데이터에서 4개의 centroid 값을 임의로 추출해봅니다. 샘플 데이터의 그룹과 추출한 값을 붉은색 점으로 표시해보겠습니다. 그림1을 보니 4개의 군집을 이루는 데이터를 확인했습니다. 또 4개의 임의의 점을 표시한 부분을 보니 각 군집의 중앙값과는 상당히 거리가 멀어보입니다. 이제 이러한 학습데이터를 통해서 Clustering을 해보겠습니다.

centroids = df.sample(4)
plt.scatter(x[:,0], x[:,1])
plt.scatter(centroids['x'], centroids['y'], c='r')
그림1. 임의의 Centroid 설정

아래의 함수는 각 테스트 데이터와 4개의 점의 거리를 계산하는 함수입니다. 아래의 함수를 실행하면 [300 × 4]의 행렬이 나오게됩니다. 그 이유는 4개의 중앙값과 샘플 데이터의 거리를 측정하기 때문입니다. 이렇게 측정한 값에서 np.argmin() 함수를 실행하면 4개의 점 중에서 가장 가까운 점의 값을 리턴하게됩니다. 그 데이터를 cluster_num에 입력합니다.

그리고 result라는 데이터셋을 리턴하게됩니다. 그러니까 result 데이터셋은 pandas dataframe의 자료형태를 가지고 있고 컬럼은 기존의 x, y외에 0,1,2,3 중에 하나의 값을 담고 있는 cluster라는 새로운 컬럼을 포함하고 있습니다.

def get_distance(center_df):
    # 각 데이터에 대하여, 각 중심점과의 유클리드 거리 계산
    distance = sp.spatial.distance.cdist(df, center_df, "euclidean")
    cluster_num = np.argmin(distance, axis=1)
    result = df.copy()
    result["cluster"] = np.array(cluster_num)
    return result

이 dataframe에서 cluster로 groupby한 후에 평균값을 계산하면 각 그룹의 x, y값 좌표를 리턴하게됩니다. 그 값을 아래의 scatter 그래프로 표시해보변 그림2와 같은 형태가 표시됩니다.

# cluster별로 묶어서 평균 계산
c = r.groupby("cluster").mean()
r = get_distance(c)
plt.scatter(r['x'], r['y'], c=r['cluster'])

그림2 그래프는 한눈에 봐도 clustering이 안돼보입니다. 이제 4가지 색의 군집의 중앙값을 구한 후에 centroid를 옮겨주고 다시 거리를 계산해봅니다. 이런 과정을 계속해보면 그림3, 그림4와 같이 점점 cluster별로 각기 다른 색으로 분류되는 것을 확인 할 수 있습니다.

그림2. 첫번째 수행
그림3. 두번째 수행
그림4. 3번째 수행

즉, centroid 값을 임의로 정해주고 그 포인트를 중심으로 clustering을 수행한 후에 clustering한 값을 중심으로 다시 centroid를 정하고 다시 clustering을 수행하는 작업을 더이상의 centroid 값이 변화가 없을 때까지 수행하면 군집이 형성되는 것이 바로 군집분석의 기본 알고리즘입니다.

sklearn K-Means 사용

sklearn에는 다른 머신러닝 알고리즘과 마찬가지로 비지도학습을 위한 클러스터링 알고리즘인 K-Means 알고리즘을 패키지 형태로 제공하고 있습니다. sklearn을 사용하면 방금 위에서 했던것과 같은 복잡한 작업을 대신해주기 때문에 편리하게 데이터 분석을 할 수 있습니다.

테스트 데이터로 그동안 사용했던 fitness.csv 데이터를 활용해서 테스트해보겠습니다. 데이터의 수가 많지 않아서 분류 결과가 아쉽게도 좋지 않지만 그래도 수행하는 방법에 대해서 가이드가 될 수 있을듯합니다. 테스트는 먼저 파일을 읽은 다음 해당 데이터셋은 레이블이 없기 때문에 테스트 삼아 임의로 레이블을 만들어보고 클러스터가 어떻게 예측했는지 비교해보겠습니다. 다시 말씀드리지만 정확성을 위해서 수행하는 부분은 아님을 알려드립니다.

dataset = pd.read_csv('./fitness.csv')
dataset.loc[ dataset['age'] < 40, 'ACODE']= 0
dataset.loc[ (dataset['age'] >= 40) & (dataset['age'] <50), 'ACODE']= 1
dataset.loc[ (dataset['age'] >= 50) & (dataset['age'] <60), 'ACODE']= 2
dataset['ACODE'] = dataset['ACODE'].astype('int32')
dataset.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 31 entries, 0 to 30
Data columns (total 8 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   age       31 non-null     int64  
 1   weight    31 non-null     float64
 2   oxygen    31 non-null     float64
 3   runtime   31 non-null     float64
 4   runpulse  31 non-null     int64  
 5   rstpulse  31 non-null     int64  
 6   maxpulse  31 non-null     int64  
 7   ACODE     31 non-null     int32  
dtypes: float64(3), int32(1), int64(4)
memory usage: 1.9 KB

sklearn 패키지에서 KMeans 패키지를 임포트합니다. 사용할 때에 culster가 우리는 3개로 알고 있기 때문에 n_cluster=3으로 설정해줍니다. 해당 알고리즘에서 가장 중요한 부분이 centroid를 초기에 어떻게 설정할것인가에 의한 것인데 init을 정해주지 않는다면 기본적으로 k-means++ 방법을 사용합니다. n_init는 30회 중앙값을 각기 다른 포인트로 설정해주고 그중에 가장 best 값을 활용합니다. 이 외에도 다양한 파라메터가 존재하니 공식 홈페이지를 살펴보시는 것을 추천합니다.

https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html

from sklearn.cluster import KMeans 
kmeans = KMeans(n_clusters=3, n_init=30,)
kmeans.fit(dataset[dataset.columns[:-1]]) # ACODE 제외
dataset['ACODE2'] = kmeans.labels_

예측결과를 ACODE2라는 컬럼에 데이터를 추가해봅니다.

(dataset['ACODE'].values == dataset['ACODE2'].values).sum()/len(dataset)
# 0.3225806451612903

예제로 사용했던 데이터의 경우는 사전에 3개의 클래스를 알고 있었지만 비지도 학습은 이에 대한 정보가 주어지지 않기 때문에 어떻게 군집을 만드는 것이 가장 좋은 케이스인지 알 수 없는 경우가 대부분입니다. 그럴 경우 아래와 같은 방식으로 num_cluster를 체크해볼 필요가 있습니다. 그림5의 경우는 num_cluster를 정하기가 어렵습니다. 그 이유는 데이터가 군집하기 어려운 형태로 분산되어 있기 때문입니다. 굳이 한다면 4,5정도가 좋을 듯합니다.

반면 그림6은 클러스터의 갯수가 명확합니다. 3개 정도가 가장 좋은 케이스라고 여집니다. 이것 역시 데이터에 따라서 차이가 있기 때문에 사전에 확인을 해보는 것도 좋은 방법입니다.

num_cluster = range(1,10)
inertia_ = []

for c in num_cluster:
    model = KMeans(n_clusters=c)
    model.fit(dataset[dataset.columns[:-2]])
    inertia_.append(model.inertia_)

# Plot ks vs inertias
plt.plot(num_cluster, inertia_, '-o')
plt.xlabel('number of clusters, k')
plt.ylabel('inertia_')
plt.xticks(num_cluster)
plt.show()
그림 5 num_cluster
그림 6. num_cluster

그림 6은 health.csv 데이터셋의 주성분분석으로 나타낸 그림입니다. 확인 결과 클러스터링에는 적절치 않은 데이터로 확인되네요. 아마도 데이터의 수가 많지 않기 때문이라고 생각됩니다.

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
dim2 = pca.fit_transform(dataset[dataset.columns[:-2]])
plt.scatter(dim2[:,0], dim2[:,1], c=dataset['ACODE'].values )
그림 6. health cluster

위와 같이 k-Means가 항상 좋은 결과를 낼 수 있는 것은 아닙니다.
각각의 데이터가 잘 모여져있다면 좋은 결과를 내지만 그렇지 않고 그림6과 같이 군집이 약할 경우는 좋은 결과를 얻을 수 없습니다.

그림 7
그림 8

K-Means가 좋은 결과를 얻지 못하는 경우는 그림7과 같은 형태의 데이터일 경우도 좋은 성능을 발휘할 수 없습니다. K-Means는 클러스터의 방향성을 고려하지 않고 무조건 거리가 가까운 데이터를 클러스터로 묶어주기 때문에 위와 같은 형태의 데이터는 잘 반영하지 못합니다. 그림에서와 같이 클러스터를 3개로 분류했지만 한눈에 보기에도 좋은 분류가 아님을 확인할 수 있습니다.

이와 마찬가지로 그림8도 역시 좋은 결과를 얻을 수 없습니다.

랜덤포레스트(Random Forest)

랜덤포레스트는 의사결정트리(Decision Tree)와 닮은 점이 많은 지도학습 예측모델입니다. 두 모델 모두 어떤 질문에 의해서 데이터 셋을 분리하는(가지를 만드는) 기본적인 방식은 닮았지만 의사결정나무가 전체 데이터를 통해서 성능이 좋은 하나의 나무를 만드는데 목적이 있다면 램덤포레스트는 하나의 나무를 만들기 보다는 데이터셋을 랜덤하게 샘플링해서 여러개의 예측 모델을 만들고 그 이러한 모델들을 종합해서 하나의 예측 결과를 리턴하는 방법으로 최종 예측을 수행합니다.

이러한 과정을 Bagging(= Bootstrap + Aggregation)이라고 합니다. 즉, 주어진 하나의 큰 데이터를 여러 개의 부트스트랩 자료(중복허용)를 생성하고 각 부트스트랩 자료를 모델링한 결과를 통합하여 최종의 예측 모델을 산출하는 방법입니다. 이런 예측 모델은 데이터가 변동성이 큰 경우 원자료(Raw Data)로부터 여러번의 샘플링읕 통해서 예측 모델의 정확도를 높이는 기법입니다. 이런 과정을 통해서 n개의 예측 모델이 만들어집니다. 그러나 결국 필요한 것은 하나의 데이터이기 때문에 각각의 모델의 결과 값에 대해서 회귀분석(평균계산)을 하던가 과반 투표(분류 모델)를 통해서 최종 결과 값을 만들게 됩니다.
이러한 방법의 알고리즘 중에 가장 대표적인 모델이 바로 랜덤포레스트(Random Forest)입니다.

이러한 복잡한 알고리즘을 sklearn의 ensemble 패키지의 RandomForestClassifier에서 훌륭하게 구현하고 있습니다.

import numpy as np
import pandas as pd

from sklearn.datasets import make_blobs, make_classification
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

테스트 데이터 생성을 위해서 sklearn의 make_classification를 사용하겠습니다. 데이터의 수는 총 300개, feature는 5개이며이며 각각의 feature는 종속변수와 상관관계가 존재합니다. 해당 데이터 셋의 클러스터는 1이고 데이터의 클래스는 3입니다. 즉, 최종 예측은 0,1,2 이 셋 중에 하나의 값을 가진다는 뜻입니다.

위에 보면 등분산성 데이터를 만들어주는 make_blobs()를 사용한 부분이 있는데 이렇게 하면 데이터가 분류에 너무 최적화 되어 있기 때문에 make_classification()을 사용합니다.

#x, y = make_blobs(n_samples=300, n_features=5, centers=3) 
x, y = make_classification(n_samples=300, n_features=5, n_informative=5, n_redundant=0, n_clusters_per_class=1, n_classes=3)

데이터 셋을 만든 다음 모델의 정확도를 검증하기 위해서 train, test 데이터 셋으로 분리합니다. 분리는 8:2 정도로 하겠습니다.

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state=0) # 8:2
print(x_train.shape, x_test.shape)
# (240, 5) (60, 5)

sklearn에 보면 RandomForestClassifier를 만드는데 몇가지 파라메터들이 있습니다. 그중에 예제에서는 n_estimators(The number of trees in the forest.)를 사용합니다. 해당 파라메터는 하나의 나무를 만드는 의사결정나무(Decision-Tree)와는 다르게 여러개의 모델을 만드는 RandomForest의 특징입니다. 나무를 많이 만들면 예측의 정확도는 높아 질 수 있지만 그만큼 많은 자원을 필요로 하고 또 일정 수준 이상으로는 높아지지 않기 때문에 가능하면 테스트를 하면서 수를 늘려가는 방식으로 수행하는 것을 추천합니다.

해당 모델은 데이터셋이 비교적 구분이 잘되어 있는 데이터셋이기 때문에 10으로 셋팅합니다.

from sklearn.ensemble import RandomForestClassifier
randomfc = RandomForestClassifier(n_estimators=10).fit(x_train, y_train)
randomfc
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                       max_depth=None, max_features='auto', max_leaf_nodes=None,
                       min_impurity_decrease=0.0, min_impurity_split=None,
                       min_samples_leaf=1, min_samples_split=2,
                       min_weight_fraction_leaf=0.0, n_estimators=10,
                       n_jobs=None, oob_score=False, random_state=None,
                       verbose=0, warm_start=False)

모델의 정확도는 85%로 측정되었습니다. 데이터 셋은 랜덤으로 만들어지기 때문에 만들 때마다 정확도가 다르게 측정됩니다.

predict = randomfc.predict(x_test)
print(randomfc.score(x_test, y_test))
# 0.85

더 자세한 결과를 보기 위해서 confusion_matrix를 체크해봅니다. 2~4개의 오차가 발견되지만결과 관대한 저에게는 대부분 정확하게 예측을 한것으로 보입니다. (다르게 보일 수도 있습니다.)

from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predict)
# output #
array([[14,  1,  3],
       [ 1, 18,  1],
       [ 3,  0, 19]])

classification_report를 통해서 결과를 더 자세히 살펴보겠습니다. 각각의 용어들은 아래와 같은 의미가 있습니다.

정확도(accuracy) : 예측한 값의 몇개를 맞췄는가?
정밀도(precision) : 예측한 것중에 정답의 비율은?
재현율(recall) : 정답인 것을 모델이 어떻게 예측했는가?
F1 Score : 정밀도와 재현율의 가중조화평균(weight harmonic average)을 F점수(F-score)라고 정의합니다. 즉, F1 Score 값이 높으면 성능이 높다고 할 수 있습니다.

from sklearn.metrics import classification_report
report = classification_report(y_test, predict)
# output #
              precision    recall  f1-score   support

           0       0.78      0.78      0.78        18
           1       0.95      0.90      0.92        20
           2       0.83      0.86      0.84        22

    accuracy                           0.85        60
   macro avg       0.85      0.85      0.85        60
weighted avg       0.85      0.85      0.85        60

이제 랜덤하게 생성된 임의의 데이터가 아닌 load_digits 데이터셋을 활용해보도록 하겠습니다. 해당 데이터셋에 대한 설명은 생략하겠습니다.

from sklearn.datasets import load_digits
digits = load_digits()

x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size = 0.2, random_state=0) # 8:2
print(x_train.shape, x_test.shape)
# (1437, 64) (360, 64)
randomfc = RandomForestClassifier(n_estimators=10).fit(x_train, y_train)
print(randomfc.score(x_test, y_test) )
# 0.9472222222222222
predict = randomfc.predict(x_test)
confusion_matrix(y_test, predict)

array([[27,  0,  0,  0,  0,  0,  0,  0,  0,  0],
       [ 0, 34,  0,  0,  0,  1,  0,  0,  0,  0],
       [ 1,  0, 33,  2,  0,  0,  0,  0,  0,  0],
       [ 0,  0,  0, 29,  0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0, 28,  0,  0,  2,  0,  0],
       [ 0,  0,  0,  0,  0, 39,  0,  0,  1,  0],
       [ 0,  1,  0,  0,  0,  0, 42,  0,  1,  0],
       [ 0,  0,  0,  0,  0,  0,  0, 38,  1,  0],
       [ 0,  2,  0,  2,  0,  0,  0,  0, 35,  0],
       [ 0,  3,  0,  1,  0,  0,  0,  1,  0, 36]])
report = classification_report(y_test, predict)
print(report)

              precision    recall  f1-score   support

           0       0.96      1.00      0.98        27
           1       0.85      0.97      0.91        35
           2       1.00      0.92      0.96        36
           3       0.85      1.00      0.92        29
           4       1.00      0.93      0.97        30
           5       0.97      0.97      0.97        40
           6       1.00      0.95      0.98        44
           7       0.93      0.97      0.95        39
           8       0.92      0.90      0.91        39
           9       1.00      0.88      0.94        41

    accuracy                           0.95       360
   macro avg       0.95      0.95      0.95       360
weighted avg       0.95      0.95      0.95       360

서포트벡터머신(Support Vector Machine)

서포트벡터머신(SVM,Support Vector Machine, 이하 SVM)은 강력한 머신러닝 모델이며 또 다양한 정형 데이터셋에서 좋은 성능을 보여줍니다. SVM은 데이터의 특징이 몇개 되지 않더라도 복잡한 결정경계(Decision Boundary)를 만들어줍니다.

SVM은 저차원, 고차원의 모델에서 좋은 성능을 발휘하지만 샘플이 많을 경우 예를 들어 100,000개 이상의 데이터를 처리하는데는 성능이 좋지 않습니다. 또 데이터 전처리(MinMaxScaler와 같은 작업이 필요)와 매개변수 설정에 좀 더 고민해야 할 부분들이 많이 있고 예측이 어떤 결과를 통해서 이뤄졌는지에 대한 모델 설명이 쉽지 않은 부분이 있습니다.

그럼에도 SVM은 특징이 비슷한 단위이고 샘플 수가 많지 않다면 좋은 결과를 얻을 수 있는 모델입니다.

아래와 같은 예제를 통해서 SVM 모델을 테스트해보겠습니다.

from sklearn.datasets import make_classification
from sklearn.datasets import make_blobs
from sklearn import svm

import numpy as np

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, GridSearchCV

테스트 데이터는 sklearn의 make_classification() 함수를 사용해서 만들었습니다. 그렇기 때문에 이 코드를 통해서 테스트하시는 분들은 다른 형태의 그래프가 그려집니다. 데이터를 계속 새로 만들면서 결정경계가 어떻게 표시되는지 테스트해보시는 것도 좋겠습니다.

저는 2개의 feature가 있는 1,000개의 샘플 데이터를 생성했습니다. 생성한 데이터를 통해서 시각화 해보면 아래와 같은 그래프가 표시됩니다. 이 그래프는 선형으로 분류가 불가능합니다. 두개의 클래스가 겹쳐있기 때문입니다. 그렇기 때문에 차원을 높여서 비선형(Nonlinear) 방식의 분류가 필요합니다.

예제를 수행하기에 앞서 간단히 설명하면 서포트벡터머신(Support Vector Machine)은 선형 데이터 분류와 비선형 데이터 분류 모두 가능합니다. 그 방법은 데이터를 분류할 수 있는 직선을 긋고 직선을 기준으로 데이터를 분류하는 것입니다. 테스트 예제인 그림 1의 경우는 직선으로 분류할 수 없기 때문에 커널(kernel)이라는 형태의 방법이 필요하지만 그림2의 경우는 데이터가 굉장히 명확하게 구분되어 있기 때문에(몇개의 아웃라이어가 있지만…) 하나의 직선으로 두개의 데이터 그룹을 분리 할 수 있습니다. 정리하면 그림1은 비선형, 그림 2는 선형 이라고 하고 SVM은 이 두가지 모두 가능합니다.

그림2에서 좀 더 자세히 설명하면 두개의 데이터 그룹이 있고 한 그룹마다 데이터가 많이 존재하고 있지만 실제로 모든 데이터가 결정경계(Decision Boundary)를 만드는 것은 아니고 일부의 데이터만 결정경계를 만드는데 사용됩니다. 이것은 비교적 적은 연산 과정으로도 결과를 얻을 수 있다는 의미이며 또 속도가 빠르다는 의미도됩니다.
이러한 데이터들을 서포트 벡터(Support Vector)라고 표현합니다. 풀어서 말하면 결정경계를 존재하게 하는 지지 벡터라고 할 수 있습니다. 그런데 왜 점이라고 하지 않고 벡터라고 했을까를 생각해보면 어떤 포인트의 연속된 데이터 형태를 표현하기 위해서 라고 이해할 수 있습니다.

색을 표시하기 위해서 아래와 같은 컬러 코드를 사용했습니다.

red_RGB = (1,0,0)
blue_RGB = (0,0,1)
data_colors = [red_RGB, blue_RGB]

def get_colors(y):
    return [data_colors[label] for label in y]
X,y = make_classification(n_samples=1000, n_features=2, n_informative=1, n_redundant=0, n_clusters_per_class=1)
plt.scatter(X[:,0], X[:,1], c=get_colors(y), s=10)
그림 1
그림 2

이제 그림1의 데이터로 다시 돌아와서 train 데이터와 test 데이터로 나눠줍니다. 분리는 8:2의 형태로 나누겠습니다.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=0) # 8:2

데이터를 표시하기 위해서 시각화 함수를 정의합니다.

def plot_decision_function_helper(X, y, clf, show_only_decision_function = False):

    colors = get_colors(y)
    plt.axis('equal')
    plt.tight_layout()

    plt.scatter(X[:, 0], X[:, 1], c=colors, s=10, edgecolors=colors)
    ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    # Create grid to evaluate model
    xx = np.linspace(xlim[0], xlim[1], 30)
    yy = np.linspace(ylim[0], ylim[1], 30)
    YY, XX = np.meshgrid(yy, xx)
    xy = np.vstack([XX.ravel(), YY.ravel()]).T # xy.shape = (900, 2)
    Z = clf.decision_function(xy).reshape(XX.shape)

    if  show_only_decision_function:
        ax.contour(XX, YY, Z, colors='k', levels=[0], alpha=0.5,
                 linestyles=['-'])
    else :
        ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
                 linestyles=['--', '-', '--'])

def plot_decision_function(X_train, y_train, clf):
    colors = get_colors(y_train)
    
    plt.figure(figsize=(8,4), dpi=150)
    plt.title('Support Vector Machine Classifier')
    plot_decision_function_helper(X_train, y_train, clf, False)

SVM은 비선형 데이터를 고차원으로 확장하여 분리할 수 있도록 rbf, linear, poly 커널을 제공합니다. 기본값은 rbf 커널입니다.

clf = svm.SVC() #default kernel ='rbf'    
print(clf)
clf.fit(X_train, y_train)

plot_decision_function(X, y, clf)
print("Accuracy: {}%".format(clf.score(X_test, y_test) * 100 ))
#Accuracy: 92.5%
clf2 = svm.SVC(kernel='linear', C=1)    
clf2.fit(X, y)
plot_decision_function(X, y, clf2)
print("Accuracy: {}%".format(clf2.score(X_test, y_test) * 100 ))
#Accuracy: 91.5%
clf4 = svm.SVC(kernel='poly', C=1)    
clf4.fit(X, y)
plot_decision_function(X, y, clf4)
print("Accuracy: {}%".format(clf4.score(X_test, y_test) * 100 ))
#Accuracy: 90.5%

참고로 결정경계를 만들때 고려해야 할 내용은 마진을 어떻게 결정하는가? 에 대한 내용입니다. 이것은 “C”를 어떻게 설정할 것인가에 따라 달라집니다. C는 기본값은 1이지만 데이터의 특징에 따라 더 많이 설정할 수도 있습니다.

만약 아웃라이어를 최대한 허용하지 않고 모든 데이터를 대상으로 까다롭게(?) 만드는 경우 이것을 하드 마진(hard margin)이라고 부릅니다. 이렇게 되면 서포트 벡터와 결정 경계 사이의 거리가 매우 좁다. 즉, 마진이 매우 작아진다. 이렇게 개별적인 학습 데이터들을 다 놓치지 않으려고 아웃라이어를 허용하지 않는 기준으로 결정 경계를 정해버리면 오버피팅(overfitting) 문제가 발생할 수 있다.

반대로 마진(margin)을 어느 정도 오류값들이 포함되도록 너그럽게 기준을 세운다면 이것을 소프트 마진(soft margin)이라고 부릅니다. 이렇게 너그럽게(?) 잡아 놓으면 서포트 벡터와 결정 경계 사이의 거리가 멀어지는 즉, 마진이 현상이 나타납니다. 그렇게되면 언더피팅(underfitting) 문제가 발생할 수 있다. 그렇기 때문에 훈련 데이터의 오류를 어느 정도는 허용할 것인가에 대한 기준을 잡고 모델을 설계하는 것이 필요합니다.

또 하나 고려해야 할 부분은 gamma 값입니다. gamma는 훈련 샘플이 미치는 영향의 범위를 의미하는 것으로 작은 값은 넓은 영역을 큰 값이라면 미치는 범위가 제한적인 특징이 있습니다.

Reference

https://www.learnopencv.com/svm-using-scikit-learn-in-python/

로지스틱 회귀(Logistic Regression)

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
import matplotlib.pyplot as plt

아래와 같은 데이터가 있다고 생각해보겠습니다. 독립변수 x는 0-9까지의 값이 입력되어 있고 종속변수 y는 연속된 수치 형태의 값이 아닌 0,1의 이항변수로 되어 있습니다. 데이터를 통해 보니 0-4까지는 0, 5-9까지는 1을 리턴하는 형태입니다. 예를 들어서 체력 테스트를 하는데 턱걸이 0-4까지는 0(불합격), 5-9까지는 합격(1) 이라고 가정해보겠습니다.

이러한 문제를 선형회귀의 형태로 분석해본다면 어떻게될까요? 분석이 가능할까요?
가능해보기도 합니다. 먼저 데이터를 시각화 해보겠습니다.

x = [[1],[2],[3],[4],[0],[5],[6],[7],[8],[9]]
y = [0,0,0,0,0,1,1,1,1,1]
line = np.linspace(0,1,num=10)
yline = np.linspace(0.5,0.5,num=10)

plt.scatter(x,y)
plt.plot(line)
plt.plot(yline)

데이터를 시각화 해보면 위와 같은 형태의 그래프가 표시됩니다. 그리고 이러한 데이터라면 선형회귀로도 가능할듯 보입니다. 0-4, 5-9의 데이터를 중간에 주황색 선을 0.5를 기준으로 입력되는 데이터가 0.5 보다 크면 1을 출력하고 작으면 0을 출력하게 하면 될것같습니다.
이러한 기본 컨셉을 가지고 선형회귀를 통해서 해당 내용을 구현해보겠습니다.

from sklearn.linear_model import LinearRegression
linear = LinearRegression().fit(x,y)
predict = linear.predict([[50]])
print(predict)
# 7.39393939

위와 같은 모델을 구현하고 테스트 해보니 0-9까지의 턱걸이 갯수로는 예측이 비교적 잘되는듯 보입니다. 하지만 어떤 사람이 와서 턱걸이를 50회 혹은 그 이상을 하게되면 예측치가 합격(1)/불합격(0)을 벗어서나 7이라는 숫자가 나오게됩니다. 더 큰 숫자를 입력하면 예측치가 더 높게 나오겠죠.

이렇게되면 이 모델은 사용할 수가 없습니다.
만약 이럴 때에 턱걸이를 아무리 많이 해도 합격과 불합격으로만 결과치를 표시하고 싶다면 어떻게 하는게 좋을까요?

이럴 때에 사용하는 것이 로지스틱 회귀입니다. 같은 데이터로 sklearn의 로지스틱회귀(LogisticRegression) 패키지를 사용해서 모델을 만들어보면 50이라는 큰 숫자를 입력해도 합격을 의미하는 1이라는 값을 보여주게됩니다.

from sklearn.linear_model import LogisticRegression
logistic = LogisticRegression().fit(x,y)
predict = logistic.predict([[50]])
print(predict)
# 1

이러한 것을 가능하게 해주는 것은 Hypothesis가 기존의 선형회귀 모델과 다른 특별한 형태를 가지기 때문입니다. 이것을 Sigmoid라고 부릅니다.

이 함수에서 보면 z의 값은 선형회귀의 Wx+b의 값, 즉 선형회귀에서의 출력값을 사용합니다. 수식에 따라서 출력은 0-1 사이의 실수 값을 리턴하게 되고 0.5를 기준으로 작으면 0을 크면 1을 출력해줄 수 있게됩니다.

그렇다면 최적화는 어떻게 하게될까? 선형회귀에서는 MSE(Mean Square Error)를 사용하지만 로지스틱에서는 아래와 같은 Cross-Entropy를 사용합니다.

https://towardsdatascience.com/cross-entropy-for-classification-d98e7f974451

위의 식은 두개의 식을 하나로 합친 것입니다.

결정트리(Decision Tree)

결정트리는 결론에 이르기 위해서 “예/아니오”의 답변을 요구하는 질문을 반복하면서 학습을 진행합니다. 마치 스무고개 질문과 비슷하죠. 최소한의 적은 질문으로 어떤 문제를 해결하기 위해서는 질문을 잘해야 하는것처럼 결정트리의 중요한 부분도 “어떻게 질문하는가?” 하는 것 중요합니다.

https://kr.akinator.com/

위의 프로그램은 “akinator”라는 게임입니다. 사용자는 아키네이터의 질문에 따라서 답을 고르게 됩니다. 이런 방법으로 몇차례 질문과 답을 주고 받으면 내가 머리속으로 그려낸 인물에 대해서 정확하게 예측합니다. 이것은 이미 이 프로그램을 통해 게임을 진행했던 사람들의 많은 데이터가 축적되어 있기 때문에 가능한 일입니다. 제가 테스트 했던 인물은 축구선수 손흥민이 이었는데 손흥민선수는 이미 222,308회 선택되어 졌기 때문에 많은 데이터가 축적되어 있었습니다. 그렇기 때문에 몇번 안돼서 아키네이터가 답을 맞췄습니다.

결정트리가 마치 이와 같습니다. 결정트리도 데이터셋에서 질문을 통해서 분류(classification) 작업을 수행합니다. 맨 마지막에 마지막 답이 남을 때까지 데이터를 분류합니다. 이렇게 남는 맨 마지막 노드를 리프(lefa) 노드라고 합니다. 그리고 각 노드들은 엣지(edge)로 연결되어 있습니다.

분류에도 여러 알고리즘들이 있는데 그렇다명 언제 결정트리(Decision Tree)를 사용하면 좋을까요?
예를 들어서 고객이 은행에 대출요청을 했고 은행이 고객에 대한 수락 요청을 거부했을 경우 고객에게 어떤 이유로 대출이 불가한지 설명해야 한다면 바로 이 의사결정트리가 유용한 알고리즘이 될 수있습니다.

해당 알고리즘이 가장 높은 성능을 발휘한다는 보장은 없지만 그래도 어떤 결정에 대해서 설명이 가능하다는 것은 중요한 이유가됩니다. 바로 한눈에 보고 이해할 수 있다는 이러한 정점이 있기 때문에 어떤 결정에 합리적인 판단 기준으로 제시하기 위해 해당 알고리즘을 사용합니다.

의사결정나무은 예측 변수를 기반으로 결과를 분류하거나 예측하는데 이러한 의사결정의 규칙(Decision Rule)을 나타내는 과정이 마치 나무구조와 같다고 해서 붙여진 이름입니다. 해당 알고리즘을 활용하면 분류(classification)나 예측(prediction)도 수행이 가능합니다.

아래의 예제는 붓꽃 데이터를 Decision-Tree 알고리즘을 통해 구성한 결과입니다.

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

# DecicionTreeClassifier 생성
tree_iris = DecisionTreeClassifier()

# 붓꽃 데이터를 로딩하고, 학습과 테스트 데이터 세트로 분리
iris_data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, test_size=0.2, random_state=11)

# DecisionTreeClassifier 학습
tree_iris.fit(X_train, y_train)
from sklearn.tree import export_graphviz
export_graphviz(tree_iris, out_file='tree-iris.dot', class_names=['Setosa','Versicolour','Virginica'], feature_names=iris_data.feature_names, impurity=False, filled=True)

분류를 수행하고 그 결과를 ‘tree_iris.dot’이라는 파일로 기록합니다.

digraph Tree {
node [shape=box, style="filled", color="black"] ;
0 [label="petal length (cm) <= 2.45\nsamples = 120\nvalue = [41, 40, 39]\nclass = Setosa", fillcolor="#fffdfd"] ;
1 [label="samples = 41\nvalue = [41, 0, 0]\nclass = Setosa", fillcolor="#e58139"] ;
0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ...

해당 파일을 읽어보면 위와 같이 코드의 형태로 표시됩니다. 이렇게 만들어진 코드를 바로 이해해도 되겠지만 무리가 있죠. 파이썬의 graphviz라는 패키지를 이용하면 이러한 데이터를 훌륭히 시각화 할 수 있습니다.

# 아래와 같이 패키지를 설치합니다.
conda install python-graphviz

패키지를 설치하고 tree-iris.dot 파일을 읽어보겠습니다.

import graphviz

with open('./tree-iris.dot') as f:
    dot_graph = f.read()
display(graphviz.Source(dot_graph))

위의 그림을 살펴보면 결정트리를 IF(petal length <= 2.45) THEN Setosa ELSE IF(petal width <= 1.55) and IF(petal length <= 5.25) THEN vesicolour … 와 같은 방법으로 표현할 수 있습니다. 그렇기 때문에 어떤 결과를 얻었을 때에 규칙을 통해서 데이터를 얻었다고 이야기 할 수 있는 것입니다.

가장 위에 있는 노드는 Root-Node 라고 하고 Parent-Child Node의 연결이 마치 나무의 구조와 같다고 해서 의사결정나무라고도 부릅니다. 그리고 맨 마지막에 있는 것이 Teminal-Node라고 부릅니다. 각 노드의 연결선을 엣지(Edge) 라고 하고 Yes(True)/No(False)를 의미합니다.

루트노드는 가장 첫번째 질문으로 매우 중요합니다. 이 질문은 가능한 많은 데이터를 분류 할 수 있는 질문이어야 합니다. 위의 경우는 Petal Length <= 2.45를 기준으로 총 120개의 샘플 데이터를 41:79로 분류했습니다. 그리고 41은 전부 “Setosa”라는 종류라는 것을 얻었습니다. 그리고 나머지 79개의 데이터를 다시 Petal Width <= 1.55라는 조건을 통해서 38:41의 데이터로 분류해 냅니다. 이런 과정을 반복하면서 데이터를 마지막가지 분류하게됩니다.

이 결정트리를 그동안 사용했던 fitness.csv를 통해서 적용해 보겠습니다.

dataset = pd.read_csv('./fitness.csv')
dataset.loc[ dataset['age'] < 40, 'ACODE']= 1
dataset.loc[ (dataset['age'] >= 40) & (dataset['age'] <50), 'ACODE']= 2
dataset.loc[ (dataset['age'] >= 50) & (dataset['age'] <60), 'ACODE']= 3

x_data = dataset[dataset.columns[1:-1]].values
y_data = dataset[dataset.columns[-1]].values

fit_tree = DecisionTreeClassifier()
fit_tree.fit(x_data, y_data)

from sklearn.tree import export_graphviz
export_graphviz(fit_tree, out_file='tree-fit.dot', class_names=['30','40','50'], feature_names=dataset.columns[1:-1], impurity=False, filled=True)

with open('./tree-fit.dot') as f:
    dot_graph = f.read()
display(graphviz.Source(dot_graph))

위에서 보시는것처럼 IF maxpulse <= 174 AND oxygen <= 46.723 THEN 50 라는 예측결과를 얻었습니다. 이런 방법으로 조건의 만족 여부를 따라서 이동하다보면 결국 class 값을 얻을 수 있습니다.

위 예제에서는 이지분리(Binary Split)을 사용했지만 알고리즘에 따라서 다지분리(Multi Split)도 가능합니다.

로지스틱 회귀(Logistic Regression) 다중분류

이전까지는 age, weight, oxygen, runtime, runpulse, rstpulse 데이터를 통해서 maxpulse를 예측하는 예제를 살펴봤습니다. maxpulse는 연속된 값을 가지고 있는 수치-연속형 데이터입니다.

dataset = pd.read_csv('./fitness.csv')
dataset.head()

데이터의 특징은 아래와 같습니다.

dataset.info()

RangeIndex: 31 entries, 0 to 30
Data columns (total 7 columns):
# Column Non-Null Count Dtype
— —— ————– —–
0 age 31 non-null int64
1 weight 31 non-null float64
2 oxygen 31 non-null float64
3 runtime 31 non-null float64
4 runpulse 31 non-null int64
5 rstpulse 31 non-null int64
6 maxpulse 31 non-null int64
dtypes: float64(3), int64(4)
memory usage: 1.8 KB

앞으로 하려고 하는 부분은 weight, oxygen, runtime, runpulse, rstpulse, maxpulse 칼럼 정보를 통해서 이 사람이 어느 나이대인가를 예측하는 분류의 문제를 해결해보도록 하겠습니다.

그러나 아쉽게도 예제 데이터는 범주형 컬럼은 없고 모두 수치형-연속형 데이터들입니다. 그렇기 때문에 범주형-순서형 데이터 컬럼을 하나 만들어줘야합니다. 아래와 같은 범주형 데이터 컬럼을 하나 만들겠습니다.
나이가 40대 이하이면 1, 40~50 사이에 있으면 2, 50~60 사이에 있으면 3 이렇게 넣어보겠습니다.

범주형 : 몇개의 범주로 나눠진 자료로 명목형, 순서형 데이터가 있음
* 명목형 : 성별, 성공여부, 혈액형 등 단순히 분류된 자료
* 순서형 : 개개의 값들이 이산적이며 그들 사이에 순서 관계가 존재하는 자료

수치형 : 이산형과 연속형으로 이뤄진 자료로 이산형과 연속적인 형태의 자료가 있음
* 이산형 : 이산적인 값을 갖는 데이터로 출산 횟수 등을 의미
* 연속형 : 연속적인 값을 갖는 데이터로 키나 몸무게 등을 의미

dataset.loc[ dataset['age'] < 40, 'ACODE']= 1
dataset.loc[ (dataset['age'] >= 40) & (dataset['age'] <50), 'ACODE']= 2
dataset.loc[ (dataset['age'] >= 50) & (dataset['age'] <60), 'ACODE']= 3

훈련에 사용하는 컬럼은 나이를 제외한 나머지 컬럼들입니다. 어떤 내용들이 있는지 살펴보면 아래와 같습니다.

해당 데이터를 3차원 평면에 나타내보면 아래와 같습니다. 그래프를 보면 3개의 포인터가 다른 색으로 분류되어 있습니다. 데이터가 많지 않고 5차원 데이터를 3차원으로 축소한 형태이기 때문에 각 분류가 정확하지 않은것 같습니다. 학습 데이터가 좋은 형태로 되어 있다면 아마도 그래프의 각 요소들이 잘 구분되어 있을테지만 아쉽게도 예제 데이터는 그렇지 않은듯합니다.

from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(1, figsize=(8, 6))
ax = Axes3D(fig, elev=-150, azim=110)
X_reduced = PCA(n_components=3).fit_transform(dataset[dataset.columns[:-1]])
ax.scatter(X_reduced[:, 0], X_reduced[:, 1], X_reduced[:, 2], c=y,
           cmap=plt.cm.Set1, edgecolor='k', s=40)
ax.set_title("First three PCA directions")
ax.set_xlabel("1st eigenvector")
ax.w_xaxis.set_ticklabels([])
ax.set_ylabel("2nd eigenvector")
ax.w_yaxis.set_ticklabels([])
ax.set_zlabel("3rd eigenvector")
ax.w_zaxis.set_ticklabels([])

plt.show()

이제 sklearn 패키지의 분류문제를 풀수 있는 LogisticRegression를 사용해보겠습니다. 사용하는 방법은 LinearRegression과 같이 간단하게 사용할 수 있습니다. x 데이터와 y 데이터는 위에서 설명해드린 데이터를 사용합니다.

그런다음 LogisticRegression에서 옵션을 선택하고 해당 모델을 학습합니다. sklearn은 효율적인 학습을 위해 몇가지 효율적인 학습 알고리즘을 제시합니다. 특히 feature의 수, 학습 데이터의 양, 분류할 문제의 수 등을 따라서 필요한 알고리즘을 선택합니다.

이번 예제는 3개의 분류 문제(multiclass problems)를 풀어야 하기 때문에 ‘newton-cg’ 알고리즘을 사용하도록 하겠습니다. 이 외에도 여러 알고리즘과 파라메터가 있습니다. sklearn 공식 사이트에서 해당 내용들을 확이해보시기 바랍니다.

https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
x = dataset[dataset.columns[1:-1]].values
y = dataset['ACODE'].values

from sklearn.linear_model import LogisticRegression
clf = LogisticRegression(solver='newton-cg', max_iter=100).fit(x, y)

predict = clf.predict(x)
accuracy=(predict.reshape(-1,1) == y.reshape(-1,1)).sum()/len(y)
print(accuracy)
# 0.8387096774193549 정확도

알고리즘을 통해 확인해보니 0.8387 의 정확도를 보여줍니다. 학습용 데이터가 작기 때문에 테스트용 데이터를 만들 수 없었던 이유로 정확도 계산을 한다고 하기도 좀 애매하지만 더 많은 데이터를 통해서 훈련과 테스트를 해보시길 권해드립니다.

그리고 학습이 완료된 후에 기울기와 절편 정보를 출력해보면 아래와 같습니다.

print('W:{}, b:{}'.format(clf.coef_.T, clf.intercept_.T))
W:[[ 0.46533128 -0.20477993 -0.26055162]
 [ 0.60397447 -0.08600717 -0.5179662 ]
 [-0.13946355  0.42710757 -0.28764394]
 [ 0.21778426 -0.00474545 -0.2130358 ]
 [ 0.00648806  0.03361824 -0.04010692]
 [ 0.05094977 -0.07150677  0.02055985]], b:[-116.45602409   30.69276337   85.76326072]

그리고 이러한 데이터를 통해서 직접 행렬곱을 해봐도 같은 결과가 나오는 것을 확인할 수 있습니다.

y_hat = np.matmul(x,clf.coef_.T)+clf.intercept_
y_hat.argmax(axis=1)+1

회귀분석(다중회귀)

이전 글에는 하나의 독립변수를 사용한 예측을 테스트했습니다. 이번에는 2개 이상의 독립변수를 포함하는 다중회귀분석에 대해서 동일한 데이터셋을 활용해서 알아보겠습니다.

dataset = pd.read_csv('./fitness.csv')
dataset[0:10]

지난 예제에서 runpulse를 통해서 maxpulse를 예측하는 회귀분석을 수행했습니다. 여기서 runpulse는 독립변수로서 종속변수인 maxpulse에 영향을 주는 변수입니다. 이번에도 maxpulse를 예측할 것인데 독립변수가 age, weight, oxygen, runtime, runpulse, rstpulse 이렇게 6개입니다.

먼저 예측할 maxpulse를 제외한 데이터셋을 만들어줍니다. 이것을 dataset2라고 정의하겠습니다. dataset2은 6개의 column과 31개의 row를 가진 [31 × 6] 행렬이 됩니다. 이것은 이전 시간에 하나의 독립변수를 통해서 예측을 하기 위해서 작성했던 수식인 y = Xw+b를 확장한 개념입니다.

이것을 풀어서 쓰게 되면 y = X1w1 + X2w2 + X3w3 + X4w4 + X5w5 + X6w6 + b가 되는 것이고 이런 y가 31개가 있다는 의미가 됩니다. 그러니까 각각의 요소에 w1~w6개의 값을 곱해주는 [31 × 6] × [6 × 1] + b의 행렬곱 연산이 되고 이는 [1 × 6] × [6 × 1] + b 이런 벡터의 내적의 합이 31개가 된다는 동일한 의미입니다.

dataset2 = dataset[dataset.columns[0:-1]]
print(dataset2.values)

이제 이전에 단순회귀에서 했던것처럼 sklearn 패키지의 LinearRegression을 임포트 하고 기울기와 절편을 계산합니다. fit()에 두개의 인자값을 주는데 하나는 6개의 독립변수들의 값이 있는 2차원 행렬이고 또 하나는 실제 계산 값이 들어있는 데이터셋입니다. 여기서는 알고자 하는 값인 maxpulse 값이 되겠습니다.

from sklearn.linear_model import LinearRegression
lr = LinearRegression().fit(dataset2.values, dataset['maxpulse'].values.reshape(-1,1))
print('W:{}, b:{}'.format(lr.coef_, lr.intercept_))
#W:[[-0.00794636  0.09986232  0.57982346  1.18233886  0.87556793  0.05439718]], b:[-25.0634534]

간단히 계산이 완료되었고 예상했던것처럼 알고자 했던 각 독립변수의 가중치 값인 6개와 절편 값을 얻었습니다. 이 모델이 어느정도 결과값과 일치하는지 차이를 보기 위해서 실제값과 예측값을 그래프로 시각화해보겠습니다.

plt.plot(lr.predict(dataset2.values),'*')
plt.plot(dataset['maxpulse'],'x')

실제값 “x”와 예측값 “*”를 비교해보니 일부 오차가 큰 것들도 있지만 제법 합리적으로 예측을 한것같습니다. 그리고 이 값은 아래와 같이 행렬 곱으로 계산할 수도 있습니다. 여기서 x는 독립 변수들의 값이고 y는 LinearRegression을 통해서 얻은 w, b 값입니다. 이 값들을 활용해서 y = Xw + b 형식으로 풀어낸 값과 동일합니다.

x = dataset2.values
y = lr.coef_.reshape(-1,1)
predict = np.matmul(x,y) + lr.intercept_

회귀분석(단순회귀)

선형모델은 100여년 전부터 사용되어 왔고 현재도 널리 사용되는 모델입니다. 이 모델은 입력 특성에 대한 선형함수 모델을 만들어서 예측을 수행하는 모델입니다. 간단히 직선의 방정식을 생각하면 됩니다. 기울기 w와 y축과 만나는 절편 b 값을 알아내는 것이 해당 모델의 핵심이라고 할 수 있습니다.

예를 들어 아래와 같은 fitness.csv 데이터셋이 있다고 가정해봅니다. 해당 데이터는 [‘age’, ‘weight’, ‘oxygen’, ‘runtime’, ‘runpulse’, ‘rstpulse’,’maxpulse’]의 7개의 Feature로 되어 있습니다. pandas 패키지로 파일을 읽어서 상위 10개의 데이터를 표시해봅니다.

dataset = pd.read_csv('./fitness.csv')
dataset[0:10]

각각의 column 혹은 feature 정보는 관계가 있을 수도 혹은 별다른 관계가 없을 수도 있습니다. 예를 들어서 위의 feature 정보를 통해서 아래와 같이 3개의 산점도(scatter)를 그려보면 1번은 두개의 변수간에 상관관계가 약하다고 할 수 있지만 아래의 두개 즉, runpulse-maxpulse, oxygen-runtime은 어느정도 상관관계가 있다고 할 수 있습니다. 이것을 방향에 따라서 양의 상관관계, 음의 상관관계라고 할 수 있습니다.

2번째 그래프와 같이 runpulse과 maxpulse의 관계를 통해서 본다면 runpulse 값이 증가할 수록 maxpulse 값도 함께 증가하는 것을 알 수 있습니다. 그렇기 때문에 이런 관계를 통해서 어떤 규칙성을 만들면 runpulse가 주어졌을 때 maxpulse를 어느정도는 예측할 수 있습니다. 이것을 통계적인 용어로 보면 독립변수인 runpulse의 변화에 따른 종속변수인 maxpulse의 상관관계를 파악하는 것이라고 할 수 있습니다.

fig, axes = plt.subplots(3,1,figsize=(10,12))
axes[0].set_title('runtime - maxpulse')
axes[0].scatter(dataset['runtime'],dataset['maxpulse'])

axes[1].set_title('runpulse - maxpulse')
axes[1].scatter(dataset['runpulse'],dataset['maxpulse'])

axes[2].set_title('oxygen - runtime')
axes[2].scatter(dataset['oxygen'],dataset['runtime'])

회귀분석을 위해서는 특정 독립 변수 값에 해당하는 종속변수의 값이 정규분포를 이뤄야합니다. 그래야 어떤 규칙성을 발견할 수 있습니다. 또 종속변수들의 값은 서로 독립적이어야 하는데 만일 그렇지 않으면 어떤 부분이 종속변수에 영향을 미치는지 발견하기가 어렵습니다. 이에 대한 연장으로 독립변수가 여러 개인 경우 변수간에 영향을 주지 않아야 합니다.

이런 이유로 회귀분석을 생각해 보면 아래의 표와 같이 독립변수의 수, 척도, 관계 등에 의해 회귀분석의 종류를 나눌 수 있습니다.

이훈영의 연구방법론, p.400

아래의 runpulse-maxpulse 그래프를 다시 살펴보면 데이터의 어떤 규칙성을 발견할 수 있습니다. 이제 이 데이터를 특징을 가장 잘 나타내는 직선을 긋는다고 생각해보겠습니다.

사람은 직관에 의해서 선을 한번에 그을 수 있습니다. 비록 정확하진 않더라도 정답과 비슷한 모양으로 선을 그을 수 있지만 컴퓨터는 그렇게 할 수 없습니다. 선형회귀는 바로 컴퓨터가 점들을 잘 표현하는 직선(Y = Xw + b)을 그리는 과정이라고 할 수 있습니다. 여기서 궁금한 것이 바로 w와 b 값입니다.

그중에서 가장 많이 사용하는 알고리즘을 sklearn에서 구현한 LinearRegression을 통해서 runpulse-maxpulse 회귀분석을 구현해보겠습니다. 구현은 생각보다 간단합니다. sklearn 패키지는 이런 복잡한 작업들을 단 2줄에 해결 할 수 있도록 편리한 함수를 제공해줍니다.

from sklearn.linear_model import LinearRegression
lr = LinearRegression().fit(dataset['runpulse'].values.reshape(-1,1),dataset['maxpulse'].values.reshape(-1,1))
print('W:{}, b:{}'.format(lr.coef_, lr.intercept_))
# W:[[0.83109283]], b:[32.78331594]

간단히 우리가 구하고자 하는 w, b 값을 구했습니다. 이제 두개의 미지수를 찾았으니 어떤 X 입력 값에 대해서 Y(여기서는 maxpulse)를 쉽게 예측할 수 있습니다. 실제로 데이터 예측을 해보겠습니다. fitness.csv 데이터가 많다면 훈련용 셋과 테스트 셋을 나눠서 정확도를 보겠지만 원본 데이터의 갯수가 30개라서 테스트용 데이터를 나누지 않고 위의 값 중에서 없는 runpulse 값을 찾고 이때에 maxpulse를 예측해보겠습니다.

dataset.loc[(dataset['runpulse']>=178) & (dataset['runpulse']<=180)]

위와 같은 조건으로 검색해보니 179가 없는 것을 확인했습니다. 179를 입력했을 때에 180과 185 사이의 값으로 예측된다면 예측 모델이 비교적 정확하다고 할 수 있겠습니다.

y_hat = lr.predict([[179]])
#array([[181.54893295]])

예측 결과 181.54 정도가 나와서 비교적 합리적인 값을 도출해냈습니다. 이렇게 해도 되고 y=Xw+b의 식에 값을 대입해도 동일한 y 값을 얻을 수 있습니다.

plt.plot(dataset['runpulse'],lr.predict(dataset['maxpulse'].values.reshape(-1,1)),'*')
plt.plot(dataset['runpulse'],dataset['maxpulse'],'x')

최근접이웃 알고리즘(K-NN)

k-NN(Nearest Neighbors) 알고리즘은 가장 간단한 머신러닝 알고리즘입니다. 훈련용 데이터셋을 통해서 모델을 만들고 새로운 데이터가 입력될 때는 훈련 데이터셋에서 가장 가까운 “최근접 이웃”을 찾습니다.

KNN 알고리즘의 좋은 설명을 해주는 사이트의 허민석님의 강의를 올려드리니 참고해보시면 좋겠습니다. 이 외에도 알고리즘을 설명하는 많은 강의 사이트가 있으니 개념이 궁금하신 분들은 찾아보시길 추천해드립니다.

이번 글에서는 개념에 대한 설명보다는 바로 예제 코드를 살펴보도록 하겠습니다. 해당 알고리즘은 sklearn에서 이미 잘 구현했기 때문에 사용자가 별도의 알고리즘을 구현한 필요가 없습니다. 사용자는 단 몇줄의 코드만으로 해당 알고리즘을 사용할 수 있습니다. 예제는 sklearn에서 제공하는 KNeighborsClassifier를 사용하도록 하겠습니다. 사용하는 데이터 역시 sklearn에서 제공하는 load_iris() 데이터를 사용해보겠습니다.

Introduction to Machine Learning with Python, KNeighborsClassifier

sklearn에서 제공하는 다양한 데이터셋이 있습니다. 그중에 이번 예제는 붗꽃 데이터를 사용해보겠습니다. 붗꽃 데이터는 꽃받침과 꽃잎의 넓이와 길이 정보와 붗꽃의 종류(setosa, versicolor, virginica) 데이터의 형식으로 되어 있습니다. 4개의 feature 정보와 label 컬럼이 있고 데이터의 수는 150개 정도이기 때문에 분류 문제를 테스트해보기에 적절한 예제입니다.

from sklearn.datasets import load_iris
iris = load_iris()
iris.keys()
#dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename'])

feature 정보는 아래와 같이 sepal(꽃받침) length, sepal width, petal(꽃잎) length, petal width의 네개 컬럼 정보가 들어있습니다.

iris.feature_names
#['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

해당 데이터를 pandas의 데이터프레임으로 데이터 타입을 바꾸면 좀 더 편하게 데이터의 내용을 확인 할 수 있고 pandas에서 제공하는 다양한 함수를 사용할 수 있습니다.

import pandas as pd
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
df.head()
df.describe()

sklearn의 KNeighborsClassifier 패키지를 임포트합니다. 그리고 데이터를 훈령용 세트와 테스트용 세트를 8:2로 분리해서 x_train, y_train, x_test, y_test 형태로 데이터를 생성합니다. 데이터 세트를 분리한 후에 shape을 보면 120:30의 형태로 데이터가 나뉜 것을 확인할 수 있습니다.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, shuffle=False, random_state=701)
print(x_train.shape, x_test.shape)
#(120, 4) (30, 4)

n_neighbors의 적절한 이웃 값을 찾기 위해서 데이터 셋을 테스트해봅니다. 이웃 값을 너무 적게 하면 모델의 복잡도가 올라가고 너무 많게 하면 모델의 예측력이 떨어지기 때문에 적절한 값을 찾는 것이 중요합니다.

train_accuracy = []
test_accuracy = []
neighbors_set = range(1,11)
for n_neighbors in neighbors_set:    
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(x_train, y_train)
    score = clf.score(x_test, y_test)
    train_accuracy.append(clf.score(x_train, y_train))
    test_accuracy.append(clf.score(x_test, y_test))
import matplotlib.pyplot as plt

plt.plot(neighbors_set, train_accuracy, label='train')
plt.plot(neighbors_set, test_accuracy, label='test')
plt.legend()

위의 결과 값과 같이 이웃 값(n_neighbors)이 5일 경우에 가장 높은 예측 정확도를 보여줍니다. 모델을 생성한 후 예측의 정확도를 보기 위해 테스트 데이터를 사용해서 예측을 수행하고 이 값을 테스트 값과 비교해본 결과 80%의 예측 정확도를 얻었습니다.

clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(x_train, y_train)
clf.predict(x_test)
# array([2, 2, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1])
(clf.predict(x_test) == y_test).sum()/len(y_test) # 0.8

다만 이 알고리즘을 사용할 경우 이웃을 어떻게 적절히 정의할 것인가에 대한 고민이 필요합니다. 만약 이웃을 적게 사용한다면 모델의 복잡도가 높아지고 많이 사용하면 복잡도는 낮아집니다. 위의 이미지에서 가장 오른쪽에 이미지의 경계면이 가장 부드럽지만 이렇게되면 모델이 지나치게 일반화 되어서 예측하는 값의 정확도가 낮아질 염려가 있습니다.

k-NN 알고리즘의 특징은 이해하기 매우 쉬운 모델이라는 점입니다. 사용이 비교적 간단하지 좋은 성능을 발휘하기 때문에 어떤 높은 난이도의 문제를 해결하기 전에 시도해봄직한 모델이라고 할 수 있습니다. 그러나 쉬운 모델이지만 훈련용 세트가 커지만 예측이 느려지는 특징이 있기 때문에 널리 사용되진 않습니다.

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class ANN(nn.Module):
    
    def __init__(self, D_in, H, D_out):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(D_in, H),
            nn.ReLU(),
            nn.Linear(H, D_out),
        )
    
    def forward(self, x):
        x = x.float()
        return self.layers(x)

# input dim, hidden size, ont-hot
model = ANN(tx_train.size(dim=1),5,torch.unique(ty_train).size(dim=0))
model

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

nb_epochs = 5001
for epoch in range(nb_epochs):
    model.train()
    predict = model(tx_train)
    loss = criterion(predict, ty_train.squeeze().long())
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if epoch % 250 == 0:
        print('{}/{}, cost:{:.5f}'.format(epoch,nb_epochs,loss.item()))

참고로 위의 코드는 pytorch를 사용해서 동일한 예측 코드를 Linear Regression으로 구현한 것입니다.