게으른 우루루

agglomerative algorithm군집 알고리즘을 적용하는데 어려운 점은 

algorithm이 잘 작동하는지 평가하거나 여러 algorithm의 출력을 비교하기가 매우 어려움

# library import

import matplotlib

import matplotlib.pyplot as plt

import numpy as np

import mglearn

from sklearn.datasets import make_moons

from sklearn.preprocessing import StandardScaler

from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN

from sklearn.metrics.cluster import adjusted_rand_score

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글출력

plt.rcParams['axes.unicode_minus'] = False # 축 -표시

# dataset

x, y = make_moons(n_samples=200, noise=0.05, random_state=0)

# pre-processing

scaler = StandardScaler().fit(x)

x_scaled = scaler.transform(x)

# model list

algorithms = [KMeans(n_clusters=2),

              AgglomerativeClustering(n_clusters=2),

                      DBSCAN()]

kmean_pred = algorithms[0].fit_predict(x_scaled)

# random cluster

random_state = np.random.RandomState(seed=0)

random_clusters = random_state.randint(low=0, high=2, size=len(x))

### visualization

fig, axes = plt.subplots(2, 2,

                         subplot_kw={'xticks':(), 'yticks':()})

axes[0,0].scatter(x_scaled[:, 0], x_scaled[:, 1], c=random_clusters,

                cmap=mglearn.cm3, s=60, edgecolors='k')

axes[0,0].set_title('random assign - ARI: {:.3f}'.format(

    adjusted_rand_score(y, random_clusters))) # 실제, 모델로 구한 클러스터

axes[0,1].scatter(x_scaled[:, 0], x_scaled[:, 1], c=kmean_pred,

                  cmap=mglearn.cm3, s=60, edgecolors='k')

axes[0,1].set_title('{} - ARI: {:.3f}'.format(algorithms[0].__class__.__name__, #__class__.__name__ ==> 클래스에서 이름 속성

                                              adjusted_rand_score(y, kmean_pred)))

for ax, algorithm in zip(axes.ravel()[2:], algorithms[1:]):

    clusters = algorithm.fit_predict(x_scaled)

    ax.scatter(x_scaled[:, 0], x_scaled[:, 1], c=clusters,

               cmap=mglearn.cm3, s=60, edgecolors='k')

    ax.set_title('{} - ARI: {:.3f}'.format(algorithm.__class__.__name__,

                                           adjusted_rand_score(y, clusters)))

plt.show()

# library import

from sklearn.metrics.cluster import silhouette_score

# datasets

x, y = make_moons(n_samples=300, noise=0.05, random_state=0)

# pre-processing

scaler = StandardScaler().fit(x)

x_scaled = scaler.transform(x)

# random cluster

random_state = np.random.RandomState(seed=0)

random_clusters = random_state.randint(0, 2, size=len(x)) # randint(low, high, size)

# K-Means 모델

kmeans = KMeans(n_clusters=2)

kmeans_pred = kmeans.fit_predict(x_scaled)

### visualization

fig, axes = plt.subplots(2, 2,

                         subplot_kw={'xticks':(), 'yticks':()})

ax = axes.ravel()

# random cluster 그리기

ax[0].scatter(x_scaled[:, 0], x_scaled[:,1], c=random_clusters,

            cmap=mglearn.cm2, edgecolors='k', s=60)

ax[0].set_title('random assign - silhouette score: {:.3f}'.format(silhouette_score(x_scaled, random_clusters))) # silhouette_score(훈련데이터, 예측한 클러스터)

# K-Means 그리기

ax[1].scatter(x_scaled[:, 0], x_scaled[:, 1], c=kmeans_pred,

           cmap=mglearn.cm2, edgecolors='k', s=60)

ax[1].set_title('{} - silhouette score: {:.3f}'.format(kmeans.__class__.__name__,

                                                 silhouette_score(x_scaled, kmeans_pred)))

# AgglomerativeClustering과 DBSCAN 그리기

algorithms = [AgglomerativeClustering(n_clusters=2), DBSCAN()]

for ax, model in zip(ax[2:], algorithms):

    cluster = model.fit_predict(x_scaled)

    ax.scatter(x_scaled[:, 0], x_scaled[:, 1], c=cluster,

               cmap=mglearn.cm2, edgecolors='k', s=60)

    ax.set_title('{} - silhouette score: {:.3f}'.format(model.__class__.__name__,

                                                  silhouette_score(x_scaled, cluster)))

plt.show()

DBSCAN^{density-based spatial clustering of application with noise}은 클러스터의 갯수를 미리 지정하지 않는 군집 알고리즘

DBSCAN은 병합 군집이나 k-평균보다는 다소 느리지만 비교적 큰 데이터셋에도 적용

데이터의 밀집지역이 한 클러스터를 구성하며 비교적 비어있는 지역을 경계로 다른 클러스터와 구분함

DBSCAN은 특성 공간에서 가까이 있는 데이터가 많아 붐비는 지역의 포인트를 찾음

이런 지역을 밀집 지역^{dense region}이라 함

밀집 지역에 있는 포인트를 핵심 포인트^{core point}라고함

핵심 포인트: min_samples, eps^epsilon

한 데이터 포인트에서 eps 거리 안에 데이터가 min_samples 갯수만큼 들어 있으면 이 데이터 포인트를 핵심 포인트로 분류

eps(거리)보다 가까운 핵심 샘플은 동일한 클러스터로 분류

알고리즘

1. 무작위로 데이터 포인트를 선택

2. 그 포인트에서 eps 거리안의 모든 포인트를 찾음

2-1 eps 거리 안에 있는 데이터 포인트 수가 min_samples보다 적다면 어떤 클래스에도 속하지 않는 잡음noise로 레이블

2-2 eps 거리 안에 있는 데이터 포인트 수가 min_samples보다 많으면 핵심 포인트로 레이블하고 새로운 클러스터 레이블할당

3. 2-2의 핵심 포인트의 eps거리안의 모든 이웃을 살핌

3-1 만약 어떤 클러스터에도 아직 할당되지 않았다면 바로 전에 만든 클러스터 레이블을 할당

3-2 만약 핵심 포인트면 그 포인트의 이웃을 차례로 확인

4. eps 거리안에 더이상 핵심 포인트가 없을 때까지 진행

핵심포인트, 경계포인트(핵심 포인트에서 eps거리 안에 있는 포인트), 잡음 포인트가 핵심

DBSCAN을 한 데이터셋에 여러 번 실행하면 핵심 포인트의 군집은 항상 같고, 매번 같은 포인트를 잡음으로 레이블함

그러나 경계포인트는 한 개 이상의 핵심 포인트 샘플의 이웃일 수 있음

# library import

import mglearn

import matplotlib.pyplot as plt

from matplotlib import rc

# matplotlib 설정

rc('font', family='AppleGothic') 

plt.rcParams['axes.unicode_minus'] = False

# 예제

mglearn.plots.plot_dbscan()

plt.show()

eps 매개변수는 가까운 포인트의 범위를 결정하기 때문에 매우 중요

eps를 매우 작게 하면 어떤 포인트도 핵심 포인트가 되지 못하고, 모든 포인트가 잡음 포인트가 될 수 있음

eps를 매우 크게 하면 모든 포인트가 단 하나의 클러스터에 속하게 됨

min_samples 설정은 덜 조밀한 지역에 있는 포인트들이 잡은 포인트가 될 것인지, 아니면 하나의 클러스터가 될 것인지를 결정

min_samples보다 작은 클러스터들은 잡음포인트가 되기 때문에 클러스터의 최소 크기를 결정

DBSCAN은 클러스터의 갯수를 지정할 필요가 없지만 eps의 값은 간접적으로 클러스터의 갯수 제어

적절한 eps 값을 찾기 위해 전처리^{preprocessing}(StandardScaler, MinMaxScaler)로 조정하는 것이 좋음

### DBSCAN은 새로운 테스트 데이터에 대해 예측

### 할 수 없으므로(병합군집, 매니폴드학습과 동일) fit_predict를 사용

# library import

from sklearn.cluster import DBSCAN

from sklearn.datasets import make_blobs

# dataset

x, y = make_blobs(n_samples=12, random_state=0)

# 모델생성 및 클러스터 레이블

dbscan = DBSCAN()

clusters = dbscan.fit_predict(x)

# 클러스터 레이블 출력

print('clusters \n클러스터레이블: {}'.format(clusters))

### 모든 포인트에 잡은 포인트를 의미하는 '-1'이 할당

### eps와 min_samples 기본값이 작은 데이터셋에 적절하지 않음

# library import

from sklearn.datasets import make_moons

from sklearn.preprocessing import StandardScaler

from sklearn.preprocessing import MinMaxScaler

import numpy as np

# dataset

x, y = make_moons(n_samples=200, noise=0.05, random_state=0)

# MinMaxScaler 메소드로 전처리

scaler_MMS = MinMaxScaler().fit(x)

x_scaled_MMS = scaler_MMS.transform(x) # 전처리 메소드를 훈련데이터에 적용

dbscan = DBSCAN() # 모델생성

clusters_MMS = dbscan.fit_predict(x_scaled_MMS) # 모델 학습

print('np.unique(clusters_MMS)\n예측한 레이블: {}'.format(np.unique(clusters_MMS))) # [0]

### 예측한 레이블이 0으로 전부 하나의 클러스터로 표현

### MinMaxScaler전처리가 적합하지 않음

scaler_ss = StandardScaler().fit(x)

x_scaled_ss = scaler_ss.transform(x) 

dbscan = DBSCAN()

clusters_ss = dbscan.fit_predict(x_scaled_ss)

print('np.unique(clusters_ss)\n예측한 레이블:{}'.format(np.unique(clusters_ss))) # [0 ,1]

### 2차원 데이터셋을 0과 1로 구분했기 때문에 전처리가 잘되었음을 확인

# visualization

df = np.hstack([x_scaled_ss, clusters_ss.reshape(-1, 1)]) # x_scaled_ss 오른쪽에 1열 붙이기

df_ft0 = df[df[:,2]==0, :] # 클러스터 0 추출

df_ft1 = df[df[:,2]==1, :] # 클러스터 1 추출

# matplotlib로 그래프 그리기

plt.scatter(df_ft0[:, 0], df_ft0[:, 1], label='cluster 0', cmap='Pairs') # x, y, label, 색상

plt.scatter(df_ft1[:, 0], df_ft1[:, 1], label='cluster 1', cmap='Pairs')

plt.xlabel('feature 0')

plt.ylabel('feature 1')

plt.legend()

plt.show()

# library import

import mglearn

import matplotlib

import matplotlib.pyplot as plt

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

# 알고리즘 설명 시각화

mglearn.plots.plot_agglomerative_algorithm()

plt.show()

# library import

from sklearn.cluster import AgglomerativeClustering

from sklearn.datasets import make_blobs

import numpy as np

# dataset

x, y = make_blobs(random_state=1)

# 모델 생성 및 학습

agg = AgglomerativeClustering(n_clusters=3)

assign = agg.fit_predict(x)

# 배열 x 오른쪽에 열 한개 추가

a = assign.reshape(-1, 1)

x1 = np.hstack([x, a])

# 각 클래스별로 데이터 추출

x_0 = x1[x1[:, 2]==0, :]

x_1 = x1[x1[:, 2]==1, :]

x_2 = x1[x1[:, 2]==2, :]

# 시각화

plt.scatter(x_0[:, 0], x_0[:, 1], cmap=mglearn.cm3)

plt.scatter(x_1[:, 0], x_1[:, 1], cmap=mglearn.cm3)

plt.scatter(x_2[:, 0], x_2[:, 1], cmap=mglearn.cm3)

plt.legend(['cluster 0', 'cluster 1', 'cluster 2'], loc=2)

plt.show()

mglearn.plots.plot_agglomerative()

plt.show()

# library import

from scipy.cluster.hierarchy import dendrogram, ward^[각주:1]

# dataset

x, y = make_blobs(random_state=0, n_samples=12)

### 데이터 배열 x에 ward 함수를 적용

### scipy의 ward 함수는 병합 군집을 수행할 때 생성된 거리 정보가 담긴 배열을 반환

linkage_array = ward(x)

dendrogram(linkage_array)

ax = plt.gca() # get current axes

bounds = ax.get_xbound() # x축 데이터(처음과 끝), 즉 최소/최대값을 가진 (1,2)리스트

ax.plot(bounds, [7.25, 7.25], linestyle='--', c='k') # 임의로 라인 생성

ax.plot(bounds, [4, 4], linestyle='--', c='k')

ax.text(bounds[1], 7.25, ' 두 개의 클러스터', va='center', fontdict={'size':15}) # bounds: x축 끝

ax.text(bounds[1], 4, ' 세 개의 클러스터', va='center', fontdict={'size':15})

plt.xlabel('샘플 번호')

plt.ylabel('클러스터 거리')

plt.show()

0. 살펴보기

1. PCA, NMF, k-평균에서 추출한 성분을 바탕으로 시각화

# library import

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt

import matplotlib

import numpy as np

from sklearn.decomposition import NMF

from sklearn.decomposition import PCA

from sklearn.cluster import KMeans

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

# people객체 생성

people = fetch_lfw_people(min_faces_per_person=20, resize=0.7, color=False) # 겹치치 않는 최소사람 수, 비율, 흑백

image_shape = people.images[0].shape 

# 특성 50개 추출(True)

idx = np.zeros(people.target.shape, dtype=np.bool) # 3023개의 False생성

for target in np.unique(people.target): 

    idx[np.where(people.target == target)[0][:50]] = 1 

# 데이터 추출

x_people = people.data[idx]

y_people = people.target[idx]

# 데이터 분할

x_train, x_test, y_train, y_test = train_test_split(

    x_people, y_people, # 분할할 데이터

    stratify=y_people, random_state=0) # 그룹, 랜덤상태

# 모델생성 및 학습

nmf = NMF(n_components=100, random_state=0).fit(x_train) 

pca = PCA(n_components=100, random_state=0).fit(x_train)

kmeans = KMeans(n_clusters=100, random_state=0).fit(x_train)

### pca.transform(x_test): 주성분 갯수만큼 차원을 줄인 데이터

### pca.inverse_transform(pca.transform(x_test)): 차원을 줄인 주성분으로 원래 데이터에 매핑

### kmeans.cluster_centers_[kmeans.predict(x_test)] k-평균 중심에서 k-평균으로 구한 라벨을 행 인덱스로 추출하여 재구성

x_reconst_nmf = np.dot(nmf.transform(x_test), nmf.components_) # nmf.inverse_transform(nmf.transform(x_test)) 와 동일

x_reconst_pca = pca.inverse_transform(pca.transform(x_test))

x_reconst_kmeans = kmeans.cluster_centers_[kmeans.predict(x_test)]

# visualization

fig, axes = plt.subplots(3, 5,

                         subplot_kw={'xticks':(), 'yticks':()})

for ax, comp_nmf, comp_pca, comp_kmeans in zip(

        axes.T, nmf.components_, pca.components_, kmeans.cluster_centers_): # 행방향 순서로 그림을 채우기 때문에 Transfrom을 

    ax[0].imshow(comp_nmf.reshape(image_shape))

    ax[1].imshow(comp_pca.reshape(image_shape))

    ax[2].imshow(comp_kmeans.reshape(image_shape))

axes[0, 0].set_ylabel('nmf')

axes[1, 0].set_ylabel('pca')

axes[2, 0].set_ylabel('kmeans')

plt.gray()

plt.show()

# library import 

fig, axes = plt.subplots(4, 5,

                         subplot_kw={'xticks':(), 'yticks':()}) # subplot 축 없애기

for ax, orig, rec_nmf, rec_pca, rec_kmeans in zip(

        axes.T, x_test, x_reconst_nmf, x_reconst_pca, x_reconst_kmeans):

    ax[0].imshow(orig.reshape(image_shape))

    ax[1].imshow(rec_nmf.reshape(image_shape))

    ax[2].imshow(rec_pca.reshape(image_shape))

    ax[3].imshow(rec_kmeans.reshape(image_shape))

for i, name in zip(range(4), ['원본', 'kmeans', 'pca', 'nmf']):

    axes[i, 0].set_ylabel(name)

plt.gray()

plt.show()

2. 특성의 수보다 많은 클러스터중심을 사용한 k-평균

# library import

from sklearn.datasets import make_moons

# dataset생성

x, y = make_moons(n_samples=200, noise=0.05, random_state=0) # noise: 퍼짐정도

# 모델 생성 및 학습, 예측

kmeans = KMeans(n_clusters=10, random_state=0).fit(x)

y_pred = kmeans.predict(x)

plt.scatter(x[:, 0], x[:, 1], c=y_pred, s=60, cmap='Paired', edgecolors='black', alpha=0.7) # cmap: palette

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], c=np.unique(kmeans.labels_), # c: group

            s=100, marker='s', linewidths=2, cmap='Paired', edgecolors='black')

plt.xlabel('특성 0')

plt.ylabel('특성 1')

plt.show()

0. 살펴보기

# library import

import mglearn

import matplotlib

import matplotlib.pyplot as plt

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글 출력

plt.rcParams['axes.unicode_minus'] = False #  축 -

mglearn.plots.plot_kmeans_algorithm()

plt.show()

# 경계선 그리기

mglearn.plots.plot_kmeans_boundaries()

plt.show() 

1. make_blobs(인위적 데이터셋)에 k-평균 알고리즘을 적용

# library import

from sklearn.datasets import make_blobs

from sklearn.cluster import KMeans

import numpy as np

# 데이터 만들기

x, y = make_blobs(random_state=1)

# 모델 생성 및 학습

kmean = KMeans(n_clusters=3) # 클러스터 수

kmean.fit(x)

print('클러스터 레이블: \n{}'.format(kmean.labels_)) 

3개의 클러스터를 지정했으므로 각 클러스터는 0 ~ 2까지 번호가 붙음

### predict메소드를 통해 새로운 데이터 클러스터 레이블을 예측할 수 있음

### 예측은 각 포인트에 가장 가까운 클러스터 영역으로 할당하는 것이며 기존 모델을 변경하지 않음

### 훈련 세트에 대해 predict 메소드를 실행하면 labels_와 같은 결과를 얻게 됨

print('예측 레이블: \n{}'.format(kmean.predict(x)))

### 클러스터는 각 데이터 포인트가 레이블을 가진다는 면에서 분류와 비슷함

### 그러나 정답을 모르고 있으며 레이블 자체에 의미가 없음

### 알고리즘이 우리에게 주는 정보는 각 레이블에 속한 데이터는 서로 비슷하다는 것

mglearn.discrete_scatter(x[:, 0], x[:, 1], kmean.labels_, markers= 'o') # x, y, group, marker

mglearn.discrete_scatter(

    kmean.cluster_centers_[:, 0], kmean.cluster_centers_[:, 1], y=np.unique(kmean.labels_),# x, y, group

    markers='^', markeredgewidth=2) # marker, 두께

plt.show()

3. 클러스터수를 변경하여 비교

fig, axes = plt.subplots(2, 2, gridspec_kw={'hspace':0.5}) # gridspec_kw: 그래프 수평간격

n_clusters_set = [2, 4, 5, 6] 

for n, ax in zip(n_clusters_set, axes.ravel()):

    kmeans = KMeans(n_clusters=n) # 클러스터 갯수

    kmeans.fit(x)

    mglearn.discrete_scatter(x[:, 0], x[:, 1], y=kmeans.labels_, ax=ax) # x, y, group, ax = plot객체

    mglearn.discrete_scatter(

        kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], y=np.unique(kmeans.labels_), # x, y, group

        markeredgewidth=3, ax=ax, s=15) # 두께, 그림객체, 사이즈

    ax.set_title('n_cluster: {}'.format(n)) # title

    ax.set_xlabel('feature 0')

    ax.set_ylabel('feature 1')

plt.show()

4. k-평균 알고리즘이 실패하는 경우

4-1 클러스터의 밀도가 다를 때

x1, y1 = make_blobs(n_samples=200, cluster_std=[1, 2.5, 0.5], random_state=170) # 샘플수, 밀도, 랜덤상태

y_pred = KMeans(n_clusters=3, random_state=0).fit_predict(x1) # 모델 생성 및 훈련 후 예측

mglearn.discrete_scatter(x1[:, 0], x1[:, 1], y=y_pred) # x, y, group

plt.legend(['cluster 0', 'cluster 1', 'cluster 2']) # 범례

plt.xlabel('feature 0')

plt.ylabel('feature 1')

plt.show()

4-2 클러스터가 원형이 아닐  때

x2, y2 = make_blobs(n_samples=600, random_state=170) # 샘플 갯수, 램덤상태

rng = np.random.RandomState(74).normal(size=(2,2)) # 랜덤상태, (2,2)size로 normal분포의 숫자 무작위추출

x2_reshape = np.dot(x2, rng) # np.dot 행렬곱

kmeans = KMeans(n_clusters=3).fit(x2_reshape) # 모델 생성

y2_pred = kmeans.predict(x2_reshape) # 예측

mglearn.discrete_scatter(x2_reshape[:, 0], x2_reshape[:, 1], y=kmeans.labels_, alpha=0.7) # x, y , group, 투명도

mglearn.discrete_scatter(

    kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1], y=np.unique(kmeans.labels_), # x, y, group

    markeredgewidth=3, s=15) # 두께, size

plt.xlabel('feature 0')

plt.ylabel('feature 1')

plt.show()

4-3 클러스터의 구조가 복합형태를 나타낼 때

from sklearn.datasets import make_moons

x3, y3 = make_moons(n_samples=200, noise=0.05, random_state=0) # 갯수, 퍼짐정도, 랜덤상태

kmeans = KMeans(n_clusters=2).fit(x3) # 모델 객체 생성 및 학습

y3_pred = kmeans.predict(x3) # 모델 적용

plt.scatter(x3[:, 0], x3[:, 1], c=y3_pred, s=60, edgecolors='black', cmap=mglearn.cm2) # x, y, group, 점크기 60%, 테두리색 black, palette

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], # x, y

            marker='^', s=120, linewidth=2, edgecolors='k', c=[mglearn.cm2(0), mglearn.cm2(1)]) # marker,  점크기 120%, 두께, 테두리색, 색상 

plt.xlabel('feature 0')

plt.ylabel('feature 1')

plt.show()

1. 손글씨 숫자 데이터셋에 t-SNE maniford learnning을 적용

# load library

from sklearn.datasets import load_digits

import matplotlib

import matplotlib.pyplot as plt

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글 출력

plt.rcParams['axes.unicode_minus'] = False # 축 - 설정

# data load

digits = load_digits()

# subplot 객체 생성

fig, axes = plt.subplots(2, 5, #  subplot객체(2x5)를 axes에 할당

                         subplot_kw={'xticks':(), 'yticks':()}) # subplot 축 눈금 해제

for ax, img in zip(axes.ravel(), digits.images): # axes.ravel()과 digits.images를 하나씩 할당

    ax.imshow(img)

plt.gray() # 그래프 흑백

plt.show() # 그래프 출력

2. PCA를 사용하여 데이터를 2차원으로 축소해 시각화

### 처음 두 개의 주성분을 이용해 그래프를 그리고 각 샘플을 해당하는 클래스의 숫자로

from sklearn.decomposition import PCA

# PCA 모델을 생성

pca = PCA(n_components=2) # 주성분 갯수

pca.fit(digits.data) # PCA 적용

# 처음 두 개의 주성분으로 숫자 데이터를 변환

digits_pca = pca.transform(digits.data) # PCA를 데이터에 적용

colors = ['#476A2A', '#7851B8', '#BD3430', '#4A2D4E', '#875525',

               '#A83683', '#4E655E', '#853541', '#3A3120', '#535D8E']

for i in range(len(digits.data)): # digits.data의 길이까지 정수 갯수

    # 숫자 텍스트를 이용해 산점도 그리기

    plt.text(digits_pca[i, 0], digits_pca[i, 1], str(digits.target[i]), # x, y, 그룹; str은 문자로 변환

             color=colors[digits.target[i]], # 산점도 색상

             fontdict={'weight':'bold', 'size':9}) # font 설정

plt.xlim(digits_pca[:, 0].min(), digits_pca[:,1].max()) # 최소, 최대

plt.ylim(digits_pca[:, 1].min(), digits_pca[:,1].max()) # 최소, 최대

plt.xlabel('first principle component') # x 축 이름

plt.ylabel('second principle componet') # y 축 이름

plt.show()

3. 같은 데이터셋에 t-SNE를 적용해 결과를 비교

### TSNE모델에는 transform 메소드가 없고 fit_transform만 있음

# library import

from sklearn.manifold import TSNE

# t-SNE 모델 생성 및 학습

tsne = TSNE(random_state=0)

digits_tsne = tsne.fit_transform(digits.data)

# 시각화

for i in range(len(digits.data)): # 0부터  digits.data까지 정수

    plt.text(digits_tsne[i, 0], digits_tsne[i, 1], str(digits.target[i]), # x, y , 그룹

             color=colors[digits.target[i]], # 색상

             fontdict={'weight': 'bold', 'size':9}) # font

plt.xlim(digits_tsne[:, 0].min(), digits_tsne[:, 0].max()) # 최소, 최대

plt.ylim(digits_tsne[:, 1].min(), digits_tsne[:, 1].max()) # 최소, 최대

plt.xlabel('t-SNE 특성0') # x축 이름

plt.ylabel('t-SNE 특성1') # y축 이름

plt.show() # 그래프 출력

1. NMF를 사용하여 데이터를 재구성하는데 성분의 갯수가 어떤 영향을 주는지 살펴보기

# library import

from sklearn.datasets import fetch_lfw_people

import matplotlib

import matplotlib.pyplot as plt

import numpy as np

import mglearn

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글 설정

plt.rcParams['axes.unicode_minus'] = False # 축 -설정

people = fetch_lfw_people(min_faces_per_person=20, resize=0.7, color=False) # 겹치지 않는 최소사람 수, 사이즈비율, 흑백

images_shape = people.images[0].shape # 이미지 한개의 사이즈 저장

counts = np.bincount(people.target) # 갯수 새기

for i, (count, names) in enumerate(zip(counts, people.target_names)): # counts와 people.target_names에서 원소 하나씩 할당하여 인덱스 부여

    print('{0:25} {1:3}'.format(names, count), end='\t') # names에서 25자리, count에서 3자리, 끝에 탭할당

    if i % 3 == 0: # 3의 배수

        print() # 개행

idx = np.zeros(people.target.shape, dtype=np.bool) # False배열 3023개 설정

people_target_unq = np.unique(people.target) # target에서 unique값 할당

for target in people_target_unq: # perploe_target_unq에서 원소 하나씩 target에 할당

    idx[np.where(people.target == target)[0][:50]] = 1 # 전체 리스트 3023개에서 target과 일치하는 것의 수가를 50개 까지 True로 변경

x_people = people.data[idx] # 훈련 데이터

y_people = people.target[idx] # 테스트 데이터

# library import

from sklearn.preprocessing import MinMaxScaler

from sklearn.model_selection import train_test_split

scaler = MinMaxScaler()

x_people_scaled = scaler.fit_transform(x_people) # 훈련 데이터를 적용하여 전처리

x_train, x_test, y_train, y_test = \ 

  train_test_split(x_people_scaled, y_people, # 분할할 데이터

                   stratify=y_people, random_state=0, test_size=0.3) # 그룹화할데이터, 랜덤상태, 테스트 비율

mglearn.plots.plot_nmf_faces(x_train, x_test, images_shape)

plt.gray() # 그림 흑백

plt.show() # 그림 출력

2. 비음수 성분 15개로 시각화

# library import , model 생성 , 학습

from sklearn.decomposition import NMF

nmf = NMF(n_components=15, random_state=0)

nmf.fit(x_train)

# 모델 적용

x_train_nmf = nmf.transform(x_train)

x_test_nmf = nmf.transform(x_test)

# 시각화

fig, axes = plt.subplots(3, 5, # axes에 plots객체를 3x5 만큼 할당

                         subplot_kw={'xticks':(), 'yticks':()}) # subplot 축 없애기

for i, (comp, ax) in enumerate(zip(nmf.components_, axes.ravel())): # nmf.components_, axes.ravel()에서 하나씩 comp와 ax에 인덱스부여

    ax.imshow(comp.reshape(images_shape)) # images_shape= (87, 65)

    ax.set_title('성분 {}'.format(i)) # subplot 타이틀

plt.gray() # 그림 흑백

plt.show()

비음수 성분이 특별히 강하게 나타난 이미지 분석(1)

### argsort : 자료를 정렬한 것의 index

idx = np.argsort(x_train_nmf[:, 3])[::-1] # [start : end : stpe] , step=-1 :내림차순

fig, axes = plt.subplots(2, 5, # subplots객체 (2x5) 를 axes에 할당

                         subplot_kw={'xticks':(), 'yticks':()}) # subplots에 축 없애기

for idx, ax in zip(idx, axes.ravel()): # idx와 aexs.ravel()을 하나씩 idx, ax에 할당

    ax.imshow(x_train[idx].reshape(images_shape))

plt.gray() # 그림 흑백

plt.show() # 그림 출력

비음수 성분이 특별히 강하게 나타난 이미지 분석(2)

idx = np.argsort(x_train_nmf[:, 10])[::-1] # [start : end : stpe] , step=-1 :내림차순

fig, axes = plt.subplots(2, 5, # subplots객체 (2x5) 를 axes에 할당

                         subplot_kw={'xticks':(), 'yticks':()}) # subplots에 축 없애기

for idx, ax in zip(idx, axes.ravel()): # idx와 aexs.ravel()을 하나씩 idx, ax에 할당

    ax.imshow(x_train[idx].reshape(images_shape)) 

plt.gray() # 그림 흑백

plt.show() # 그림 출력   

인위적 데이터에 NMF 적용하기

# library import

import mglearn

import matplotlib

import matplotlib.pyplot as plt

# matplotlib 설정

plt.rcParams['axes.unicode_minus'] = False # 축- 설정

matplotlib.rc('font', family='AppleGothic') # 한글출력

# 예제 데이터

mglearn.plots.plot_nmf_illustration()

plt.show() # 그래프 출력

인위적인 데이터셋을 사용한 NMF분석

# library import

import mglearn

import matplotlib

import matplotlib.pyplot as plt

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글 출력

plt.rcParams['axes.unicode_minus'] = False # 축 - 설정

# data load

S = mglearn.datasets.make_signals() 

# visualization

plt.plot(S) # 라인그래프

plt.xlabel('time') # x 축

plt.ylabel('signal') # y 축

plt.show() # 그래프 출력

NMF와 PCA를 통한 데이터 복원

# library import

from sklearn.decomposition import NMF 

from sklearn.decomposition import PCA

import numpy as np

A = np.random.RandomState(0).uniform(size=(100, 3)) # 100x3  형태의 균일분포에서 랜덤 데이터 생성

X = np.dot(S, A.T) # S(2000x3)에 A에 전치행렬(3X100)을 행렬 곱

print('X.shape \n측정데이터 형태:{}'.format(X.shape)) # (2000, 3)

nmf = NMF(n_components=3, random_state=0) # 주성분 3개, 랜덤상태

S_ = nmf.fit_transform(X) # nmf적용

print('S_.shape \n복원한 신호 데이터 형태: {}'.format(S_.shape)) # (2000, 3)

pca = PCA(n_components=3) # PCA주성분 3

H = pca.fit_transform(X) # PCA적용

# visualization

models = [X, S, S_, H] 

names = ['측정 신호(처음 3개)', '원본 신호', 'NMF로 복원' ,'PCA로 복원']

fig, axes = plt.subplots(4, # subplot의 객체4개를 axes에 할당

                         gridspec_kw={'hspace':0.5}, # 수평간격 비율

                         subplot_kw={'xticks':(), 'yticks':()}) # subplot의 축 눈금 없애기

for model, name, ax in zip(models, names, axes.ravel()): # models와 names, axes.ravel()에서 하나씩 선택

    ax.set_title(name) # 타이틀 이름

    ax.plot(model[:,:3]) # 모든행, :3 ==> 3개의 열

plt.show() # 그래프 출력

# library import

from sklearn.datasets import fetch_lfw_people # fetch_lfw_people library

import matplotlib.pyplot as plt

import matplotlib

import numpy as np

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글출력

plt.rcParams['axes.unicode_minus'] = False # 축 - 표시

people = fetch_lfw_people(min_faces_per_person=20, resize=0.7, color=False) # 추출된 사진의 서로 다른 얼굴의 수, 사진 비율, 흑백여부

image_shape = people.images[0].shape # people객체 image의 첫번째 원소의 모양

print('people.images의 형태 \n{}'.format(people.images.shape)) # people객체의 image 형태: (3023, 87, 65)

print('class 갯수 \n{}'.format(len(people.target_names))) # people객체의 class 갯수, 62

fig, axes = plt.subplots(2, 5, # figure객체와 2x5의 plot객체를 각각 할당

                         subplot_kw={'xticks': (), 'yticks': ()}) # subplot의 축 설정; x축 눈굼없게, y축 눈금없게

# axes.ravel() : 리스트를 1차원으로

for target, image, ax in zip(people.target, people.images, axes.ravel()): # people.target, people.images, axes.ravel()에서 하나씩 원소 할당

    ax.imshow(image) # imshow로 그림 출력

    ax.set_title(people.target_names[target]) # 각 subplot의 타이틀

plt.gray() # 그림 흑백

plt.show() # 그래프 출력

1 -1 people 객체 분석

# 각 target이 나타난 횟수 계산

counts = np.bincount(people.target) # people.target의 빈도 계산

# target별 이름과 횟수 출력

### enumerate() : 각 원소에 인덱스 부여

### print('{0:25}, {1:3}').format(var1, var2):  첫번째 {}에 var1과 25자리까지, 두번째{}에 var2와 3자리를 부여

### print({0!s}.format(var1)): print문에 전달된 형식이 숫자라도 문자로 처리

print('frequency')

for i, (count, name) in enumerate(zip(counts, people.target_names)):

    print('{0:25} {1:3}'.format(name, count), end= '\t') # name에서 25자리, count에서 3자리, 끝은 탭

    if (i + 1) % 3 == 0: # 3의 배수이면, 즉 4번째 원소부터

        print() # 개행처리

# Geoge W Bush와 Colin Powell의 이미지가 많음을 확인

### 데이터셋의 편중을 막기 위해 50개의 이미지만 선택

mask = np.zeros(people.target.shape, dtype=np.bool) # 3023개의 boolean타입 False 생성

people_unique = np.unique(people.target) # 중복된 값 제외

for target in people_unique: # 중복을 제거한 target리스트에서 한개의 원소 선택

# people.target(3023개의 리스트)중 선택된 원소와 같은 것만 출력 ==> [0] 리스트의 원소로 접근 ==> False의 갯수 50개까지 출력

# 이 논리 값을 mask의 인덱스로 사용 후 True로 변환

x_people = people.data[mask] # 훈련 데이터 생성

y_people = people.target[mask] # 테스트 데이터 생성

# 전처리 메소드 import

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

x_people_scaled = scaler.fit_transform(x_people) # 전처리 메소드 적용

# 머신 러닝 library import

from sklearn.neighbors import KNeighborsClassifier

from sklearn.model_selection import train_test_split

# 전처리한 데이터를 분할

x_train, x_test, y_train, y_test = \

  train_test_split(x_people_scaled, y_people, # 분할할 데이터

                   stratify=y_people, random_state=0) # 그룹화할 데이터, 랜덤상태

# 머신 러닝 라이브러리 import

knn = KNeighborsClassifier(n_neighbors=1) # 이웃의 수

knn.fit(x_train, y_train) # 모델 학습

print('knn.score(x_test, y_test) \n최근접이웃의 일반화 세트 점수: {:.3f}'.format(

    knn.score(x_test, y_test))) # 0.248

# library import

import mglearn

mglearn.plots.plot_pca_whitening()

plt.show()

2-1. PCA  머신 러닝

# library import

from sklearn.decomposition import PCA

# PCA 모델 생성 및 적용

pca = PCA(n_components=100, whiten=True, random_state=0) # 주성분 갯수, whitening option, 랜덤상태

pca.fit(x_train) # PCA 학습

x_train_pca = pca.transform(x_train) # PCA를 데이터에 적용

x_test_pca = pca.transform(x_test)

# PCA를 적용한 데이터 형태

print('x_train_pca.shape \ntrain형태:{}'.format(x_train_pca.shape)) # (1547, 100)

print('x_test_pca.shape \ntest형태:{}'.format(x_test_pca.shape)) # (516, 100)

# 머신 러닝 모델 생성 및 학습

knn = KNeighborsClassifier(n_neighbors=1) # 이웃의 수

knn.fit(x_train_pca, y_train) # 모델 학습

print('테스트 세트 정확도: \n{:.3f}'.format(knn.score(x_test_pca, y_test))) # 0.314

모델의 정확도가 23%에서 31%로 상승

이미지 데이터일 경우엔 계산한 주성분을 쉽게 시각화 가능

주성분이 나타내는 것은 입력 데이터 공간에서의 어떤 방향임을 기억

입력 차원이 87 x 65픽셀의 흑백 이미지이고 따라서 주성분또한 87 x 65

print('pca.components_.shape \n{}'.format(pca.components_.shape)) # (100, 5655)

fig, axes = plt.subplots(3, 5, # subplot 3x5를 axes에 할당

                         subplot_kw={'xticks': (), 'yticks': ()}) # subplot 축 설정

for i, (comp, ax) in enumerate(zip(pca.components_, axes.ravel())): # pca.components_와 axes.ravel()을 하나씩 순서대로 할당한 후 인덱스 부여

    ax.imshow(comp.reshape(image_shape)) # image_shape= (87, 65)

    ax.set_title('pricipal component {}'.format(i+1)) # image title

plt.gray() # 사진 흑백

plt.show() # 사진 출력

mglearn.plots.plot_pca_faces(x_train, x_test, image_shape) # 훈련데이터, 테스트데이터, 이미지크기(87x65)

plt.gray() # 그림 흑백

plt.show() # 그림 출력

import mglearn

import matplotlib

import matplotlib.pyplot as plt

matplotlib.rc('font', family='AppleGothic') # 한글출력

plt.rcParams['axes.unicode_minus'] = False # 축 - 표시

mglearn.plots.plot_pca_illustration()

plt.show()

PCA를 이용한 데이터 변환

from sklearn.datasets import load_breast_cancer

import numpy as np

cancer = load_breast_cancer()

# 특성이 30개이므로  5X2 3set의 plot 객체 생성합니다.

# set 1

fig, axes = plt.subplots(5, 2)

malignant = cancer.data[cancer.target == 0]

benign = cancer.data[cancer.target == 1]

target_set = np.array([malignant, benign])

for i, ax in zip(np.arange(10), axes.ravel()):

    for t in target_set:

        _, bins = np.histogram(cancer.data[:, i], bins=50) # bins: histogram 간격

        ax.hist(t[:, i], bins=bins, alpha=0.5)

        ax.set_title(cancer.feature_names[i])

        ax.set_yticks(()) 

        ax.set_xlabel('feature size') 

        ax.set_ylabel('frequency')

axes[0, 0].legend(['malignant', 'benign'], loc=(0.85, 1.1), bbox_to_anchor=(0.85, 1.1), fancybox=True, shadow=True)

fig.tight_layout()

plt.show()

특성 1 ~ 10까지의 breast cancer 히스토그램

# set 2

fig, axes = plt.subplots(5, 2) 

for i, ax in zip(np.arange(10, 20), axes.ravel()):

    for t in target_set:

        _, bins = np.histogram(cancer.data[:,i], bins=50) 

        ax.hist(t[:, i], bins=bins, alpha=0.5)

        ax.hist(benign[:, i], bins=bins, alpha=0.5)

        ax.set_title(cancer.feature_names[i])

        ax.set_yticks(())

fig.tight_layout()

plt.show()

특성 11 ~ 20까지의 breast cancer의 히스토그램

# set 3

fig, axes = plt.subplots(5, 2) 

for i, ax in zip(np.arange(20, 30), axes.ravel()):

    for t in target_set:

        _, bins = np.histogram(cancer.data[:,i], bins=50)

        ax.hist(malignant[:, i], bins=bins, alpha=0.5)

        ax.hist(benign[:, i], bins=bins, alpha=0.5)

        ax.set_title(cancer.feature_names[i])

        ax.set_yticks(())

fig.tight_layout()

plt.show()

특성 21 ~ 30까지의 breast cancer의 히스토그램

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(cancer.data)

x_scaled = scaler.transform(cancer.data)

# 기본값일 때 PCA는 데이터를 회전과 이동만 시키고 모든 주성분을 유지합니다.

# 데이터의 차원을 줄이려면 PCA객체를 만들 때 얼마나 많은 성분을 유지할지 알려주어야 합니다.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)

pca.fit(x_scaled)

x_pca = pca.transform(x_scaled)

x_scaled_shape =  x_scaled.shape

print('{}'.format(x_scaled_shape))

# (569, 30)

x_pca_shape = x_pca.shape

print('{}'.format(x_pca_shape))

# (569, 2)

targets = np.unique(cancer.target)

markers = ['^', 'o']

for target, marker in zip(targets, markers):

    plt.scatter(x_pca[cancer.target==target][:, 0], x_pca[cancer.target==target][:, 1],

                s=20, alpha=0.7, marker=marker, edgecolors='k')

plt.legend(['malgnent', 'reglgent'], loc=1)

plt.gca().set_aspect('equal') # x축과 y축의 길이를 같게합니다.

plt.xlabel('first component', size=15)

plt.ylabel('second component', size=15)

plt.show()

두 개의 주성분을 사용해 그린 breast cancer 2차원 scatter plot

print('{}'.format(pca.components_.shape))

# (2, 30)

print('{}'.format(pca.components_)) # 주성분 출력

# [[ 0.21890244  0.10372458  0.22753729  0.22099499  0.14258969  0.23928535

#    0.25840048  0.26085376  0.13816696  0.06436335  0.20597878  0.01742803

#    0.21132592  0.20286964  0.01453145  0.17039345  0.15358979  0.1834174

#    0.04249842  0.10256832  0.22799663  0.10446933  0.23663968  0.22487053

#    0.12795256  0.21009588  0.22876753  0.25088597  0.12290456  0.13178394]

#  [-0.23385713 -0.05970609 -0.21518136 -0.23107671  0.18611302  0.15189161

#    0.06016536 -0.0347675   0.19034877  0.36657547 -0.10555215  0.08997968

#   -0.08945723 -0.15229263  0.20443045  0.2327159   0.19720728  0.13032156

#    0.183848    0.28009203 -0.21986638 -0.0454673  -0.19987843 -0.21935186

#    0.17230435  0.14359317  0.09796411 -0.00825724  0.14188335  0.27533947]]

from mpl_toolkits.axes_grid1 import make_axes_locatable

image = plt.matshow(pca.components_, cmap='viridis')

plt.yticks([0, 1], ['first', 'second'])

plt.xticks(range(len(cancer.feature_names)), cancer.feature_names,

           rotation=90, ha='left')

plt.xlabel('feature', size=15)

plt.ylabel('principal component', size=15)

ax = plt.gca() # GetCurrentAxis

divider = make_axes_locatable(ax)

cax = divider.append_axes('right', size='5%', pad='5%')

plt.colorbar(image, cax=cax)

plt.show()

breast cancer에서 찾은 처음 두개의 주성분 히트맵

0. 살펴보기

# library import

import mglearn

import matplotlib.pyplot as plt

mglearn.plots.plot_scaling() # 그래프 예제 출력

plt.show() # 그래프 출력

1. 전처리를 통한 breast cancer 데이터 분석(SVM, Support Vector Machine)

# library import

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

# 데이터 로드

cancer = load_breast_cancer() 

# 데이터 분할

x_train, x_test, y_train, y_test = \ 

  train_test_split( # 데이터 분할을위해

      cancer.data, cancer.target, # 분할할 데이터

      test_size=0.25, random_state=1) # 테스트 비율, 랜덤상태

# 분할한 데이터 속성

print('x_train.shape \n{}'.format(x_train.shape))

print('x_test.shape \n{}'.format(x_test.shape))

# pre-processing import

# library import

from sklearn.preprocessing import MinMaxScaler

# 메소드 호출

scaler = MinMaxScaler() 

### MinMaxScaler의 fit 메소드는 train set에 있는 특성마다 최솟값과 최댓값을 계산 ###

### fit 메소드를 호출할 때 x_train만 넘겨줌 ###

scaler.fit(x_train) # 메소드 적용

###fit 메소드로 실제 훈련 데이터의 스케일을 조정하려면 스케일 객체의 transform 메소드를 사용 ###

### transform: 새로운 데이터 표현을 만들 때 사용하는 메소드 ###

# data 변환

x_train_scaled = scaler.transform(x_train)

x_test_scaled = scaler.transform(x_test)

# 스케일이 조정된 후 데이터셋의 속성

print('size: \n{}'.format(x_train_scaled.shape))

print('스케일 전 최솟값: \n{}'.format(x_train.min(axis=0))) # axis=0 열방향, axis=1 행방향

print('스케일 전 최댓값: \n{}'.format(x_train.max(axis=0)))

print('스케일 후 최솟값: \n{}'.format(x_train_scaled.min(axis=0))) # 최솟값 :0

print('스케일 후 최댓값: \n{}'.format(x_train_scaled.max(axis=0))) # 최댓값: 1

# 스케일이 조정된 후 테스트 데이터의 속성 출력

print('조정 후 특성별 최솟값: \n{}'.format(x_test_scaled.min(axis=0))) # 0이 최솟값이 아님

print('조정 후 특성별 최댓값: \n{}'.format(x_test_scaled.max(axis=0))) # 1이 최댓값이 아님

### 모든 스케일도 train set와 test set에 같은 변환을 적용해야 함 ###

### 스케일 조정된 데이터로 학습

# library import

from sklearn.svm import SVC

# 모델 생성 및 학습

svm = SVC(C=100)  

svm.fit(x_train, y_train)

svm_scaled = SVC(C=100).fit(x_train_scaled, y_train)

# 유효성 검증

print('조정 전 테스트 정확도 \n{:.3f}'.format(svm.score(x_test, y_test))) # 0.615

print('조정 후 테스트 정확도 \n{:.3f}'.format(svm_scaled.score(x_test_scaled, y_test))) # 0.965

### 스케일 조정된 데이터로 학습 ###

### 평균0, 분산 1을 갖도록 StandardScaler 조정 ###

# library import

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

scaler.fit(x_train)

x_train_scaled = scaler.transform(x_train)

x_test_scaled = scaler.transform(x_test)

# 조정된 데이터로 SVM 학습

svm.fit(x_train_scaled, y_train) 

# 조정된 테스트 세트의 정확도

print('조정된 일반화 정확도 \n{:.3f}'.format(svm.score(x_test_scaled, y_test))) # 0.965

from mglearn.datasets import make_blobs

from sklearn.svm import LinearSVC

from mglearn.plots import plot_2d_separator

import matplotlib.pyplot as plt

import numpy as np

x, y = make_blobs(centers=4, random_state=8)

y = y % 2 # y를 binary화

linear_svm = LinearSVC().fit(x, y) 

plot_2d_separator(linear_svm, x, fill=False)

marker_set = ['o', '^']

for i, m in zip(np.unique(y), marker_set):

    plt.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m,

                label='class {}'.format(i), edgecolors='k')

plt.legend(bbox_to_anchor=(0.1, 1.1), fancybox=True)

plt.xlabel('feature 0', size=15)

plt.ylabel('feature 1', size=15)

plt.show()

선형적으로 구분되지 않는 클래스를 가진 binary data

# 선 하나로 구분되지 않는 데이터를 분석하기 위해 수학적방법으로 차수를 하나 늘려 비선형 데이터축 추가합니다.

# x[:, 1:]

# x[:, 1].reshape(-1, 1)

# x[:, 1][:,np.newaxis]

# 위의 3개는 모두 같은 결과입니다.

x_new = np.hstack([x, x[:, 1:]**2])

linear_svm_3d = LinearSVC().fit(x_new, y)

xx = np.linspace(x[:, 0].min()-2, x[:, 0].max()+2, num=50)

yy = np.linspace(x[:, 1].min()-2, x[:, 1].max()+2, num=50)

# xx, yy의 좌표를 이용하여 교차 좌표 만듬 ex) x=[1, 2], y=[3, 4]라면 (1, 3), (1, 4), (2, 3), (2, 4) 좌표 생성합니다.

XX, YY = np.meshgrid(xx, yy)

ZZ = YY ** 2 

params = np.c_[XX.ravel(), YY.ravel(), ZZ.ravel()] # np.c_ : XX, YY, ZZ의 원소를 하나씩 출력하여 한개의 행으로 묶기

dec = linear_svm_3d.decision_function(params)

plt.contourf(XX, YY, dec.reshape(XX.shape), # XX.shape = (50, 50) 

             levels=[dec.min(), 0, dec.max()],

                 alpha=0.5)

for i, m in zip(np.unique(y), marker_set):

    plt.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m, edgecolors='k')

plt.xlabel('feature 0', size=15)

plt.ylabel('feature 1', size= 15)

plt.show() 

고차원 특성을 이용해 구분한 Support vector machine decision boundary

from sklearn.svm import SVC

from mglearn.tools import make_handcrafted_dataset

from mglearn.plots import plot_2d_separator

x, y = make_handcrafted_dataset()

svm = SVC(kernel='rbf', C=10, gamma=0.1) # kernel, 규제정도, 커널폭의 역수

svm.fit(x, y)

plot_2d_separator(svm, x, eps=0.5)  # epsilon

marker_set = ['o', '^']

color_set = ['skyblue', 'orange']

class_set = np.unique(y)

for i, m, color in zip(class_set, marker_set, color_set):

    plt.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m, 

label='class {}'.format(i), edgecolors='k', c=color)

sv = svm.support_vectors_

print('{}'.format(sv))

# [[ 8.1062269   4.28695977]

#  [ 9.50169345  1.93824624]

#  [11.563957    1.3389402 ]

#  [10.24028948  2.45544401]

#  [ 7.99815287  4.8525051 ]]

# dual_coef_의 부호에 의해 서포트 벡터의 클래스 레이블이 결정됩니다.

sv_labels = svm.dual_coef_.ravel() > 0 # 중요도가 0보다 높은  것, 클래스 구분

idx_set = [~sv_labels, sv_labels]

for idx,m, color in zip(idx_set, marker_set, color_set):

    plt.scatter(sv[idx][:, 0], sv[idx][:, 1],  s=100, 

marker=m, edgecolors='k', linewidths=2, c=color)

plt.xlabel('feature 0', size=15)

plt.ylabel('feature 1', size=15) 

plt.show() 

RBF Kernel을 사용한 SVM으로 만든 decision boundary와 support vector

fig, axes = plt.subplots(3, 3) 

C_args = np.array([-1, 0, 3])

C_set = 10**C_args.astype(float)

gamma_args = np.arange(-1, 2)

gamma_set = 10**gamma_args.astype(float)

marker_set = ['o', '^']

for axe, C in zip(axes, C_set):

    for ax, gamma in zip(axe, gamma_set):

        params = {'C':C, 'gamma':gamma}

        svm = SVC(**params).fit(x, y)

        plot_2d_separator(svm, x, eps=0.5, ax=ax)

        ax.set_title('C={}, gamma={}'.format(C, gamma))

        color_set = ['skyblue', 'orange']

        for i, m, color in zip(np.unique(y), marker_set, color_set):

            ax.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m,

                       label='class {}'.format(i), c=color, edgecolors='k')

        sv = svm.support_vectors_

        idx = svm.dual_coef_.ravel() < 0

        idx_set = np.array([idx, ~idx])

        for i, idx, color, m in zip(np.unique(y), idx_set, color_set, marker_set):

            ax.scatter(sv[idx][:, 0], sv[idx][:, 1], marker=m,

                       c=color, label='class {} support vector'.format(i), s=100,

                       edgecolors='k', linewidths=2)

axes[0, 1].legend(loc='upper center', bbox_to_anchor=(0.5, 1.4), fancybox=True, shadow=True, ncol=4)

plt.show()

C와 gamma 에 따른 decision boundary와 support vector

from sklearn.model_selection import train_test_split

from sklearn.datasets import load_wine

from sklearn.svm import SVC

wine = load_wine()

x_train, x_test, y_train, y_test = train_test_split(

      wine.data, wine.target, stratify=wine.target,

      random_state=0, test_size=0.25)

svc = SVC(random_state=0) # default: C=1, kernel='rbf', gamme='auto'

svc.fit(x_train, y_train) 

train_score = svc.score(x_train, y_train)

test_score = svc.score(x_test, y_test)

print('{:.3f}'.format(train_score))

# 1.000

print('{:.3f}'.format(test_score))

# 0.422

plt.boxplot(x_train, manage_xticks=False) # manage_xticks: x축 눈금 작은 눈금 표시

plt.yscale('symlog') # y축 로그 스케일

plt.xlabel('feature list', size =15) 

plt.ylabel('feature size', size =15)

plt.show()

wine 데이터셋의 특성 값 범위(y축은 logscale)

train_min = x_train.min(axis=0) 

train_range = (x_train - train_min).max(axis=0)

x_train_scaled = (x_train - train_min) / train_range

x_test_scaled = (x_test - train_min) / train_range

x_min_ori = x_train_scaled.min(axis=0)

print('{}'.format(x_min_ori))

# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

x_max_ori = x_train_scaled.max(axis=0)

print('{}'.format(x_max_ori))

# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

from sklearn.preprocessing import MinMaxScaler

mms_scaler = MinMaxScaler()

mms_scaler.fit(x_train)

x_train_scaled_mms = mms_scaler.transform(x_train)

x_test_scaled_mms = mms_scaler.transform(x_test)

x_min = x_train_scaled.min(axis=0)

print('{}'.format(x_min))

# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

x_max = x_train_scaled.max(axis=0)

print('{}'.format(x_max))

# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

svc = SVC(random_state=0)

svc.fit(x_train_scaled_mms, y_train)

train_score = svc.score(x_train_scaled_mms, y_train)

test_score = svc.score(x_test_scaled_mms, y_test)

print('{:.3f}'.format(train_score))

# 0.970

print('{:.3f}'.format(test_score))

# 0.978

svc = SVC(C=1000) 

svc.fit(x_train_scaled, y_train) 

train_score = svc.score(x_train_scaled_mms, y_train) 

test_score = svc.score(x_test_scaled_mms, y_test)

print('{:.3f}'.format(train_score))

# 1.000

print('{:.3f}'.format(test_score))

# 1.000

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.model_selection import train_test_split

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

gbc = GradientBoostingClassifier(random_state=0) # 기본값: max_depth=3, learning_rate=0.1

gbc.fit(x_train, y_train)

score_train = gbc.score(x_train, y_train) # train set 정확도

print('{:.3f}'.format(score_train))

# 1.000

score_test = gbc.score(x_test, y_test) # 일반화 정확도

print('{:.3f}'.format(score_test))

# 0.958

gbc = GradientBoostingClassifier(random_state=0, max_depth=1)

gbc.fit(x_train, y_train)

score_train_pre = gbc.score(x_train, y_train) # train set 정확도

print('{:.3f}'.format(score_train_pre))

# 0.995

score_test_pre = gbc.score(x_test, y_test) # 일반화 정확도

print('{:.3f}'.format(score_test_pre))

# 0.965

gbc = GradientBoostingClassifier(random_state=0, max_depth=3, learning_rate=0.01) # 기본값 0.1

gbc.fit(x_train, y_train)

score_train_lr = gbc.score(x_train, y_train)

print('{:.3f}'.format(score_train_lr))

# 0.995

score_test_lr = gbc.score(x_test, y_test) 

print('{:.3f}'.format(score_test_lr))

# 0.944

import matplotlib

import matplotlib.pyplot as plt

import numpy as np

score_set = np.round([score_train, score_test], 3)

max_depth_score_set = np.round([score_train_pre, score_test_pre], 3)

learning_rete_score_set = np.round([score_train_lr, score_test_lr], 3)

index = np.arange(len(score_set))

bar_width = 0.35

bottom = 0.8

list_set = [max_depth_score_set, learning_rete_score_set]

line_set = ['--', ':']

names = ['train', 'test']

for i, line_set, name in zip(index, line_set, names):

    plt.hlines(score_set[i], xmin=0-bar_width,

               xmax=index[-1]+2*bar_width,

               linestyle=line_set, label='default {}'.format(name))

    plt.text(0-bar_width, score_set[i]+0.005, str(score_set[i]))

plt.bar(index, max_depth_score_set, width=bar_width, label='adj max_depth')

plt.bar(index+bar_width, learning_rete_score_set, width=bar_width, label='adj learning rate')

for i, ts, te in zip(index, max_depth_score_set, learning_rete_score_set):

    plt.text(i, (bottom+ts)/2, str(ts), horizontalalignment='center')

    plt.text(i+bar_width, (bottom+te)/2, str(te), horizontalalignment='center')

plt.ylim(bottom, 1.05)

plt.xticks(index+bar_width/2, names)

plt.ylabel('score', size=15)

plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.1), ncol=4, fancybox=True, shadow=False)

plt.show()

max_depth와 learning rate를 조절한 random forest의 score

gbc = GradientBoostingClassifier(max_depth=1, random_state=0)

gbc.fit(x_train, y_train)

n_feature = cancer.data.shape[1]

index=np.arange(n_feature)

plt.barh(index, gbc.feature_importances_, align='center')

plt.yticks(index, cancer.feature_names)

plt.xlabel('feature importances', size=15)

plt.ylabel('feature', size=15)

plt.show() 

breast cancer data로 만든 GradientBoostingClassifier의 feature importances

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import make_moons

from sklearn.model_selection import train_test_split

x, y = make_moons(n_samples=100, noise=0.25, random_state=3) # noise: Standard deviation of Gaussian noise added to the data.

x_train, x_test, y_train, y_test = train_test_split(x, y,

                                                    stratify=y, random_state=42)

forest = RandomForestClassifier(n_estimators=5, n_jobs=-1, random_state=42) # n_estimators: 사용할 tree수

forest.fit(x_train, y_train)

import matplotlib.pyplot as plt

import numpy as np

from mglearn.plots import plot_2d_classification

_, axes = plt.subplots(2, 3)

marker_set = ['o', '^']

for i, (axe, tree) in enumerate(zip(axes.ravel(), forest.estimators_)):

    axe.set_title('tree {}'.format(i))

    plot_2d_classification(tree, x, fill=True, ax=axe, alpha=0.4)

    for i, m in zip(np.unique(y), marker_set):

        axe.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m,

                    label='class {}'.format(i), edgecolors='k')

        axe.set_xlabel('feature 0')

        axe.set_ylabel('feature 1')

axes[-1, -1].set_title('random forest')

axes[-1, -1].set_xlabel('feature 0')

axes[-1, -1].set_ylabel('feature 1')

plot_2d_classification(forest, x, fill=True, ax=axes[-1, -1], alpha=0.4)

for i, m in zip(np.unique(y), marker_set):

    plt.scatter(x[y==i][:, 0], x[y==i][:, 1], marker=m,

                label='class {}'.format(i), edgecolors='k')

plt.show()

5개의 random dicision tree의 decision boundary와 예측한 확률을 평균내어 만든 random forest

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

n_feature = cancer.data.shape[1]

score_n_tr_est = []

score_n_te_est = []

score_m_tr_mft = []

score_m_te_mft = []

for i in np.arange(1, n_feature+1): # n_estimators와 mat_features는 모두 0보다 큰 정수여야 하므로 1부터 시작합니다.

    params_n = {'n_estimators':i, 'max_features':'auto', 'n_jobs':-1} # **kwargs parameter

    params_m = {'n_estimators':10, 'max_features':i, 'n_jobs':-1}

    forest_n = RandomForestClassifier(**params_n).fit(x_train, y_train)

    forest_m = RandomForestClassifier(**params_m).fit(x_train, y_train)

    score_n_tr = forest_n.score(x_train, y_train)

    score_n_te = forest_n.score(x_test, y_test)

    score_m_tr = forest_m.score(x_train, y_train)

    score_m_te = forest_m.score(x_test, y_test)

    score_n_tr_est.append(score_n_tr)

    score_n_te_est.append(score_n_te)

    score_m_tr_mft.append(score_m_tr)

    score_m_te_mft.append(score_m_te)

index = np.arange(len(score_n_tr_est))

plt.plot(index, score_n_tr_est, label='n_estimators train score', color='lightblue', ls='--') # ls: linestyle

plt.plot(index, score_m_tr_mft, label='max_features train score', color='orange', ls='--')

plt.plot(index, score_n_te_est, label='n_estimators test score', color='lightblue')

plt.plot(index, score_m_te_mft, label='max_features test score', color='orange')

plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.1),

           ncol=2, fancybox=True, shadow=False) # fancybox: 박스모양, shadow: 그림자

plt.xlabel('number of parameter', size=15)

plt.ylabel('score', size=15)

plt.show()

parameter 갯수에 따른 train score와 test score

n_feature = cancer.data.shape[1]

index = np.arange(n_feature)

forest = RandomForestClassifier(n_estimators=100, n_jobs=-1)

forest.fit(x_train, y_train)

plt.barh(index, forest.feature_importances_, align='center')

plt.yticks(index, cancer.feature_names)

plt.ylim(-1, n_feature)

plt.xlabel('feature importance', size=15)

plt.ylabel('feature', size=15)

plt.show()

breast cancer로 만든 random forest의 feature importances