1๏ธโฃ K-means clustering
๐ ๊ฐ์
๐ก k-means clustering
โ ๊ตฐ์งํ์์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ
โ Centroid = ๊ตฐ์ง ์ค์ฌ์ ์ด๋ผ๋ ํน์ ํ ์ง์ ์ ์ ํํด ํด๋น ์ค์ฌ์ ๊ฐ์ฅ ๊ฐ๊น์ด ํฌ์ธํธ๋ค์ ์ ํํ๋ ๊ตฐ์งํ ๊ธฐ๋ฒ์ด๋ค.
1. k ๊ฐ์ ๊ตฐ์ง ์ค์ฌ์ ์ ์ค์
2. ๊ฐ ๋ฐ์ดํฐ๋ ๊ฐ์ฅ ๊ฐ๊น์ด ์ค์ฌ์ ์ ์์
3. ์ค์ฌ์ ์ ํ ๋น๋ ๋ฐ์ดํฐ๋ค์ ๋์์ผ๋ก ํ๊ท ๊ฐ์ ๊ตฌํ๊ณ ๊ทธ๊ฒ์ ์๋ก์ด ์ค์ฌ์ ์ผ๋ก ์ค์
4. ๊ฐ ๋ฐ์ดํฐ๋ ์๋ก์ด ์ค์ฌ์ ์ ๊ธฐ์ค์ผ๋ก ๋ค์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ค์ฌ์ ์ ์์๋จ
๐ ์ค์ฌ์ ์ ์ด๋์ด ๋์ด์ ์์ ๋๊น์ง ๋ฐ๋ณต
๐ก ์ฅ๋จ์
๐จ ์ฅ์
โ ์ผ๋ฐ์ ์ธ ๊ตฐ์งํ์์ ๊ฐ์ฅ ๋ง์ด ํ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ
โ ์๊ณ ๋ฆฌ์ฆ์ด ์ฝ๊ณ ๊ฐ๊ฒฐํจ
๐จ ๋จ์
โ ๊ฑฐ๋ฆฌ๊ธฐ๋ฐ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์์ฑ์ ๊ฐ์๊ฐ ๋ง์ผ๋ฉด ๊ตฐ์งํ ์ ํ๋๊ฐ ๋จ์ด์ง๋ค. ๋ฐ๋ผ์ PCA ์ฐจ์์ถ์๋ฅผ ์ ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
โ ๋ฐ๋ณต ํ์๊ฐ ๋ง์ ๊ฒฝ์ฐ ์ํ ํ์๊ฐ ๋๋ ค์ง๋ค.
โ ๊ตฐ์ง ๊ฐ์ k ๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ด๋ ต๋ค (trial)
๐ก ์ฌ์ดํท๋ฐ k-means
๐จ ํ๋ผ๋ฏธํฐ
from sklearn.cluster import KMeans |
Kmeans(n_clusters=k, init='k-means++', max_iter = n, random_state=0) |
→ n_clusters = ๊ตฐ์งํํ ๊ฐ์
→ init = ์ด๊ธฐ ๊ตฐ์ง ์ค์ฌ์ ์ขํ๋ฅผ ์ค์ ํ ๋ฐฉ์์ ๋งํ๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก 'k-means++' ๋ก ์ค์ ํจ
→ max_iter = ์ต๋ ๋ฐ๋ณต ํ์๋ก ์ด ํ์ ์ด์ ์ ๋ชจ๋ ๋ฐ์ดํฐ์ ์ค์ฌ์ ์ด๋์ด ์์ผ๋ฉด ์ข ๋ฃํ๋ค.
๐จ ์ฃผ์ ์์ฑ ์ ๋ณด
→ .labels_ : ๊ฐ ๋ฐ์ดํฐ ํฌ์ธํธ๊ฐ ์ํ ๊ตฐ์ง ์ค์ฌ์ ๋ ์ด๋ธ
→ .cluster_centers_ : ๊ฐ ๊ตฐ์ง ์ค์ฌ์ ์ขํ ์ด๋ฅผ ์ด์ฉํด ๊ตฐ์ง ์ค์ฌ์ ์ขํ๋ฅผ ์๊ฐํํ ์ ์๋ค.
โญ K-means clutering ์ ๊ฐ๋ณ ๊ตฐ์ง ๋ด์ ๋ฐ์ดํฐ๊ฐ ์ํ์ผ๋ก ํฉ์ด์ ธ ์๋ ๊ฒฝ์ฐ ๋งค์ฐ ํจ๊ณผ์ ์ผ๋ก ๊ตฐ์งํ๊ฐ ์ํ๋ ์ ์๋ค.
๐ ์ค์ต iris data
๐โ๏ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํฌํธ + ๋ฐ์ดํฐ ๋ก๋
from sklearn.preprocessing import scale
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
%matplotlib inline
iris = load_iris()
irisdf = pd.DataFrame(data=iris.data, columns = ['sepal_length','sepal_width','petal_length','petal_width'])
irisdf.head(3)
๐โ๏ธ ํด๋ฌ์คํฐ๋ง fit
kmeans = KMeans(n_clusters=3, init='k-means++', max_iter = 300, random_state = 0)
kmeans.fit(irisdf)
print(kmeans.labels_)
๐โ๏ธ ์๋ ์ ๋ต target label ๊ณผ ๋น๊ต
# ๊ฒฐ๊ณผ ๋น๊ตํด๋ณด๊ธฐ
irisdf['target'] = iris.target
irisdf['cluster'] = kmeans.labels_
iris_result = irisdf.groupby(['target', 'cluster'])['sepal_length'].count()
# sepal_length ์ด์ ๊ธฐ์ค์ผ๋ก ๋ฐ์ดํฐ๋ฅผ target ๊ธฐ์ค ๊ทธ๋ฃนํ ์ดํ ์ธ๋ถ์ ์ผ๋ก cluster ๋ก ๊ทธ๋ฃนํ๋ฅผ ์งํ
print(iris_result)
๐โ๏ธ PCA ๋ฅผ ์ฌ์ฉํด 2์ฐจ์ ๋ฐ์ดํฐ๋ก ์๊ฐํ (๊ตฐ์งํ ๊ฒฐ๊ณผ ์๊ฐํ)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca_transformed = pca.fit_transform(iris.data)
irisdf['pca_x'] = pca_transformed[:,0]
irisdf['pca_y'] = pca_transformed[:,1]
# cluster ๊ฐ์ด 0, 1, 2 ์ธ ๊ฒฝ์ฐ๋ง๋ค ๋ณ๋์ Index๋ก ์ถ์ถ
marker0_ind = irisdf[irisdf['cluster']==0].index
marker1_ind = irisdf[irisdf['cluster']==1].index
marker2_ind = irisdf[irisdf['cluster']==2].index
# cluster๊ฐ 0, 1, 2์ ํด๋นํ๋ Index๋ก ๊ฐ cluster ๋ ๋ฒจ์ pca_x, pca_y ๊ฐ ์ถ์ถ. o, s, ^ ๋ก marker ํ์
plt.scatter(x=irisdf.loc[marker0_ind,'pca_x'], y=irisdf.loc[marker0_ind,'pca_y'], marker='o')
plt.scatter(x=irisdf.loc[marker1_ind,'pca_x'], y=irisdf.loc[marker1_ind,'pca_y'], marker='s')
plt.scatter(x=irisdf.loc[marker2_ind,'pca_x'], y=irisdf.loc[marker2_ind,'pca_y'], marker='^')
plt.xlabel('PCA 1')
plt.ylabel('PCA 2')
plt.title('3 Clusters Visualization by 2 PCA Components')
plt.show()
2๏ธโฃ ๊ตฐ์ง ํ๊ฐ
๐ ๊ฐ์
๐ก ๊ตฐ์งํ๊ฐ
โ ๋๋ถ๋ถ์ ๊ตฐ์งํ ๋ฐ์ดํฐ ์ธํธ๋ target ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ๊ฐ ํจ์ฌ ๋ง๋ค.
โ ๋ฐ์ดํฐ ๋ด์ ์จ์ด์๋ ๋ณ๋์ ๊ทธ๋ฃน์ ์ฐพ์๋ด ์๋ฏธ๋ฅผ ๋ถ์ฌํ๊ฑฐ๋, ๋์ผํ ๋ถ๋ฅ๊ฐ์ด๋๋ผ๋ ๊ทธ ์์์ ๋ ์ธ๋ถํ๋ ๊ตฐ์งํ๋ฅผ ์ถ๊ตฌํ๊ฑฐ๋, ์๋ก ๋ค๋ฅธ ๋ถ๋ฅ๊ฐ์ ๋ฐ์ดํฐ๋ผ๋ ๋ ๋์ ๊ตฐ์งํ ๋ ๋ฒจํ ๋ฑ์ ์์ญ์ ๊ฐ์ง๊ณ ์๋ค.
โ ๋น์ง๋ํ์ต์ด๋ผ๋ ํน์ฑ์ ์ ํํ๊ฒ ์ฑ๋ฅ์ ํ๊ฐํ๊ธฐ๋ ์ด๋ ค์ฐ๋, ๋ํ์ ์ผ๋ก ์ค๋ฃจ์ฃ ๋ถ์์ ์ฌ์ฉํ๋ค.
๐ก ์ค๋ฃจ์ฃ ๋ถ์
๐จ ์ค๋ฃจ์ฃ ๋ถ์์ด๋
โ ๊ฐ ๊ตฐ์ง ๊ฐ์ ๊ฑฐ๋ฆฌ๊ฐ ์ผ๋ง๋ ํจ์จ์ ์ผ๋ก ๋ถ๋ฆฌ๋์ด ์๋๊ฐ๋ฅผ ๋ํ๋ด๋ ๊ฒ
- ๋ค๋ฅธ ๊ตฐ์ง๊ณผ์ ๊ฑฐ๋ฆฌ๋ ๋จ์ด์ ธ ์๊ณ , ๋์ผ ๊ตฐ์ง๋ผ๋ฆฌ์ ๋ฐ์ดํฐ๋ ์๋ก ๊ฐ๊น๊ฒ ์ ๋ญ์ณ ์๋ค๋ ์๋ฏธ
- ๊ตฐ์งํ๊ฐ ์ ๋ ์๋ก ๊ฐ๋ณ ๊ตฐ์ง์ ๋น์ทํ ์ ๋์ ์ฌ์ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ๋จ์ด์ ธ ์์ ๊ฒ
๐ก ์ค๋ฃจ์ฃ ๊ณ์
โ "๊ฐ๋ณ ๋ฐ์ดํฐ" ๊ฐ ๊ฐ๋ ๊ตฐ์งํ ์งํ
- ํด๋น ๋ฐ์ดํฐ๊ฐ ๊ฐ์ ๊ตฐ์ง ๋ด์ ๋ฐ์ดํฐ์๋ ์ผ๋ง๋ ๊ฐ๊น๊ฒ ๊ตฐ์งํ ๋์ด์๊ณ , ๋ค๋ฅธ ๊ตฐ์ง์ ์๋ ๋ฐ์ดํฐ์๋ ์ผ๋ง๋ ๋ฉ๋ฆฌ ๋ถ๋ฆฌ๋์ด ์๋์ง๋ฅผ ํ๋๋ด๋ ์งํ์ด๋ค.
- a(i) : ํด๋น ๋ฐ์ดํฐ ํฌ์ธํธ์ '๊ฐ์' ๊ตฐ์ง ๋ด์ ์๋ ๋ค๋ฅธ ๋ฐ์ดํฐ ํฌ์ธํธ์์ ๊ฑฐ๋ฆฌ๋ฅผ ํ๊ท ํ ๊ฐ
- b(i) : ํด๋น ๋ฐ์ดํฐ ํฌ์ธํธ๊ฐ '์ํ์ง ์์' ๊ตฐ์ง ์ค '๊ฐ์ฅ ๊ฐ๊น์ด' ๊ตฐ์ง๊ณผ์ ํ๊ท ๊ฑฐ๋ฆฌ
- b(i) - a(i) : ๋ ๊ตฐ์ง๊ฐ์ ๊ฑฐ๋ฆฌ ๐ ๊ฐ์ ์ ๊ทํํด์ฃผ๊ธฐ ์ํด MAX(a(i), b(i)) ๋ก ๋๋
- s(i) : i๋ฒ์งธ ๋ฐ์ดํฐ ํฌ์ธํธ์ ์ค๋ฃจ์ฃ ๊ณ์
โ ๊ฐ์ ํด์
- -1~1 ์ฌ์ด์ ๊ฐ์ ๊ฐ์ง
- 1์ ๊ฐ๊น์ธ์๋ก ๊ทผ์ฒ์ ๊ตฐ์ง๊ณผ ๋ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๋ค๋ ๊ฒ ๐ good
- 0์ ๊ฐ๊น์ธ์๋ก ๊ทผ์ฒ์ ๊ตฐ์ง๊ณผ ๊ฐ๊น์ ์ง๋ ๊ฒ
- ์์์ ํด๋นํ๋ ๊ฐ์ ์์ ๋ค๋ฅธ ๊ตฐ์ง์ ๋ฐ์ดํฐ ํฌ์ธํธ๊ฐ ํ ๋น ๋์๋ค๋ ๋ป
โ ์ฌ์ดํท๋ฐ ๋ฉ์๋
sklearn.metrics.silhouette_samples( X, labels, metric = 'euclidean' ) |
- labels : ๊ตฐ์งํ๋ ๋ ์ด๋ธ ๊ฐ
- ๊ฐ ๋ฐ์ดํฐ ํฌ์ธํธ์ ์ค๋ฃจ์ฃ ๊ณ์๋ฅผ ๊ณ์ฐํด ๋ฐํํ๋ค.
sklearn.metrics.silhouette_score( X, labels, metric = 'euclidean' , sample_size=None) |
- ์ ์ฒด ๋ฐ์ดํฐ์ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ์ 'ํ๊ท ํด' ๋ฐํํ๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ด ๋์์๋ก ๊ตฐ์งํ๊ฐ ์ด๋์ ๋ ์ ๋์๋ค๊ณ ํ๋จํ ์ ์๋ค. ๊ทธ๋ฌ๋ ๋ฌด์กฐ๊ฑด ๊ฐ์ด ๋๋ค๊ณ ํด์ ๊ตฐ์งํ๊ฐ ์ณ๊ฒ ๋์๋ค๊ณ ๋ ํ๋จํ๊ธฐ ์ด๋ ต๋ค.
๐ก ์ข์ ๊ตฐ์งํ๊ฐ ๋ ์กฐ๊ฑด
๐จ silhouette_score ๊ฐ์ด 0~1 ์ฌ์ด์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, 1์ ๊ฐ๊น์ธ์๋ก ์ข๋ค.
๐จ ์ ์ฒด ์ค๋ฃจ์ฃ ๊ณ์์ ํ๊ท ๊ฐ๊ณผ ๋๋ถ์ด ๊ฐ๋ณ ๊ตฐ์ง์ ํ๊ท ๊ฐ์ ํธ์ฐจ๊ฐ ํฌ์ง ์์์ผ ํ๋ค. ์ฆ, ๊ฐ๋ณ ๊ตฐ์ง์ ์ค๋ฃจ์ฃ ๊ณ์ ํ๊ท ๊ฐ์ด ์ ์ฒด ์ค๋ฃจ์ฃ ๊ณ์์ ํ๊ท ๊ฐ์์ ํฌ๊ฒ ๋ฒ์ด๋์ง ์๋ ๊ฒ์ด ์ค์ํ๋ค.
๐ก ๊ตฐ์ง๋ณ ํ๊ท ์ค๋ฃจ์ฃ ๊ณ์์ ์๊ฐํ๋ฅผ ํตํ ์ต์ ์ K ์ฐพ๊ธฐ
๐จ ์ ์ฒด ๋ฐ์ดํฐ์ ํ๊ท ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ์ด ๋๋ค๊ณ ํ์ฌ ๋ฐ๋์ ์ต์ ์ ๊ตฐ์ง ๊ฐ์๋ก ๊ตฐ์งํ๊ฐ ์ ๋์๋ค๊ณ ๋ณผ ์ ์๋ค.
๐จ ํน์ ๊ตฐ์ง ๋ด ์ค๋ฃจ์ฃ ๊ณ์๋ง ๋๋ฌด ๋๊ณ , ๋ค๋ฅธ ๊ตฐ์ง์ ๋ด๋ถ ๋ฐ์ดํฐ๋ผ๋ฆฌ์ ๊ฑฐ๋ฆฌ๊ฐ ๋๋ฌด ๋จ์ด์ ธ ์์ด ์ค๋ฃจ์ฃ ๊ณ์๊ฐ ๋ฎ์์ ธ๋, ํ๊ท ์ ์ผ๋ก ๋์ ๊ฐ์ ๊ฐ์ง ์ ์๋ค.
๐จ ๊ฐ๋ณ ๊ตฐ์ง๋ณ๋ก ์ ๋นํ ๋ถ๋ฆฌ๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์งํ๋ฉด์ ๊ตฐ์ง ๋ด ๋ฐ์ดํฐ๊ฐ ์๋ก ๋ญ์ณ ์๋ ๊ฒฝ์ฐ์ ์ ์ ํ ๊ตฐ์ง๊ฐ์ K ๊ฐ ์ค์ ๋์๋ค๊ณ ๋ณผ ์ ์๋ค.
โ k=2 ์ธ ๊ฒฝ์ฐ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฒฐ๊ณผ ํด์
- ๋นจ๊ฐ์ ์ ์ ๐ '์ ์ฒด' ํ๊ท ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ
- 1๋ฒ ๊ตฐ์ง์ ๋ชจ๋ ๋ฐ์ดํฐ๋ ํ๊ท ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ ์ด์์ด์ง๋ง, 2๋ฒ ๊ตฐ์ง์ ๊ฒฝ์ฐ๋ ํ๊ท ๋ณด๋ค ์ ์ ๋ฐ์ดํฐ ๊ฐ์ด ๋งค์ฐ ๋ง๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์๊ฐํํด๋ณธ ๊ฒฐ๊ณผ์์๋, 1๋ฒ ๊ตฐ์ง์ ๊ฒฝ์ฐ์๋ 0๋ฒ ๊ตฐ์ง๊ณผ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๊ณ ๋ด๋ถ ๋ฐ์ดํฐ๋ผ๋ฆฌ๋ ์ ๋ญ์ณ์ ธ ์์ผ๋, 0๋ฒ ๊ตฐ์ง์ ๊ฒฝ์ฐ์๋ ๋ด๋ถ ๋ฐ์ดํฐ๋ผ๋ฆฌ ๋ง์ด ๋จ์ด์ ธ ์์์ ํ์ธํ ์ ์๋ค.
โ k=3 ์ธ ๊ฒฝ์ฐ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฒฐ๊ณผ ํด์
โ k=4 ์ธ ๊ฒฝ์ฐ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฒฐ๊ณผ ํด์
๐ก ์ด๋์ ์ ์๋ณด์ฐ
๐จ ์ต์ ์ ๊ตฐ์ง ๊ฐ์ k ์ฐพ๊ธฐ (K-means clustering)
โ mode.inertia_ ๋ฅผ ํตํด ์๊ฐํ
๐ก AIC ์ BIC
๐จ k-means ์์ ์ฌ์ฉํ๋ ์ด๋์ , ์ค๋ฃจ์ฃ ๋ฑ์ ๋ฐฉ์์ ํด๋ฌ์คํฐ๊ฐ ํ์ํ์ด๊ฑฐ๋ ํฌ๊ธฐ๊ฐ ๋ค๋ฅด๋ฉด ์์ ์ ์ด์ง ์์ผ๋ฉฐ ๊ฐ์ฐ์์ ํผํฉ ๋ชจ๋ธ์์๋ ์ฌ์ฉํ ์ ์๋ค.
๐จ
AIC, BIC ๊ฐ์ ์ต์ํํ๋ ๊ตฐ์ง๊ฐ์ k ๋ฅผ ์ ํํ๋ค. ๐จ GMM ๋ชจ๋ธ์๋ ์ ์ฉ์ด ๊ฐ๋ฅํ๋ค. ์ต์ ์ n_components ๋์ถํ๊ธฐ
โ model.bic , model.aic ๋ก AIC, BIC ๊ฐ์ ๋ถ๋ฌ์ ์๊ฐํ ํ๊ธฐ
๐ก ๊ฐ๋ฅ๋ํจ์
โ P(X|θ) = ํ๋ผ๋ฏธํฐ θ ๋ฅผ ์๊ณ ์์ ๋, ๊ทธ ๋ชจ๋ธ์ด x๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ด ์ผ๋ง๋ ๊ทธ๋ด ๋ฏ ํ๊ฐ = x์ ํจ์
โ L(θ|X) = ๊ด์ธก๋ ๋ฐ์ดํฐ x๋ฅผ ์๊ณ ์์ ๋, ํน์ ํ๋ผ๋ฏธํฐ θ ๊ฐ ์ผ๋ง๋ ๊ทธ๋ด ๋ฏ ํ๊ฐ = θ ์ ํจ์
โ ๊ฐ๋ฅ๋๊ฐ ์ต๋๊ฐ ๋๋ ํ๋ผ๋ฏธํฐ θ ๊ฐ ๋๋ ๊ฒฝ์ฐ์ ํด๋ฌ์คํฐ ๊ฐ์๋ฅผ ์ฐพ๋ ๊ฒ
๐ ์ค์ต iris data
๐โ๏ธ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ ๊ณ์ฐํ๊ธฐ
from sklearn.preprocessing import scale
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
# โญ ์ค๋ฃจ์ฃ ๋ถ์ metric
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
%matplotlib inline
iris = load_iris()
feature_name = ['sepal_length','sepal_width','petal_length','petal_width']
irisdf = pd.DataFrame(data=iris.data, columns = feature_name)
kmeans = KMeans(n_clusters=3, init = 'k-means++', max_iter=300, random_state=0).fit(irisdf)
irisdf['cluster'] = kmeans.labels_
# ๋ชจ๋ ๊ฐ๋ณ ๋ฐ์ดํฐ์ ๋ํด ์ค๋ฃจ์ฃ ๊ณ์๊ฐ ๊ตฌํ๊ธฐ
score_samples = silhouette_samples(iris.data, irisdf['cluster']) # X, labels
print('์ค๋ฃจ์ฃ ๊ณ์ return ๊ฐ์ shape', score_samples.shape)
irisdf['์ค๋ฃจ์ฃ๊ณ์'] = score_samples
# ๋ชจ๋ ๋ฐ์ดํฐ์ ํ๊ท ์ค๋ฃจ์ฃ ๊ณ์๊ฐ ๊ตฌํ๊ธฐ
average_score = silhouette_score(iris.data, irisdf['cluster'])
print('๋ถ๊ฝ ๋ฐ์ดํฐ์
์ค๋ฃจ์ฃ๊ณ์ ์ ์ : {0:.3f}'.format(average_score))
irisdf.head(3)
#๐ cluster 1 ์ ํด๋นํ๋ ๋ฐ์ดํฐ์ ์ค๋ฃจ์ฃ ๊ณ์๊ฐ์ 0.8๋ก ๋์ง๋ง, ๋ค๋ฅธ ๊ตฐ์ง์ ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ์ด ํ๊ท ๋ณด๋ค ๋ฎ์
# ์ ์ฒด ๋ฐ์ดํฐ์ ์ค๋ฃจ์ฃ ๊ณ์ ์ต์ข
ํ๊ท ๊ฐ์ 0.553
#๐ ๊ตฐ์ง๋ณ๋ก ์ค๋ฃจ์ฃ ๊ณ์ ๊ฐ์ ์ดํด๋ณผ ํ์๊ฐ ์๋ค.
irisdf.groupby('cluster')['์ค๋ฃจ์ฃ๊ณ์'].mean()
#๐ ๊ตฐ์ง๋ณ๋ก ํ๊ท ์ ์ฐจ์ด๊ฐ ํฌ๊ฒ ๋ฐ์ํ๊ณ ์๋ค.
๐โ๏ธ ์ค๋ฃจ์ฃ ๊ณ์ ์๊ฐํ
def viz_silhouette(cluster_lists, X_features) :
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import math
n_cols = len(cluster_lists)
fig,axs = plt.subplots(figsize=(4*n_cols, 4), nrows=1, ncols=n_cols)
for ind, n_cluster in enumerate(cluster_lists) :
clusterer = KMeans(n_clusters = n_cluster, max_iter = 500, random_state=0)
cluster_labels = clusterer.fit_predict(X_features)
sil_avg = silhouette_score(X_features, cluster_labels)
sil_values = silhouette_samples(X_features, cluster_labels)
y_lower = 10
axs[ind].set_title('Number of Cluster : '+ str(n_cluster)+'\n' \
'Silhouette Score :' + str(round(sil_avg,3)) )
axs[ind].set_xlabel("The silhouette coefficient values")
axs[ind].set_ylabel("Cluster label")
axs[ind].set_xlim([-0.1, 1])
axs[ind].set_ylim([0, len(X_features) + (n_cluster + 1) * 10])
axs[ind].set_yticks([]) # Clear the yaxis labels / ticks
axs[ind].set_xticks([0, 0.2, 0.4, 0.6, 0.8, 1])
for i in range(n_cluster) :
ith_cluster_sil_values = sil_values[cluster_labels==i]
ith_cluster_sil_values.sort()
size_cluster_i = ith_cluster_sil_values.shape[0]
y_upper = y_lower + size_cluster_i
color = cm.nipy_spectral(float(i) / n_cluster)
axs[ind].fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_sil_values, \
facecolor=color, edgecolor=color, alpha=0.7)
axs[ind].text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
y_lower = y_upper + 10
axs[ind].axvline(x=sil_avg, color="red", linestyle="--")
from sklearn.datasets import load_iris
iris=load_iris()
viz_silhouette([ 2, 3, 4,5 ], iris.data)
๐ ๋ฐ์ดํฐ ์์ด ๋์ด๋๋ฉด ์ํ ์๊ฐ์ด ํฌ๊ฒ ๋์ด๋๋ค๋ ๋จ์ ์กด์ฌ
3๏ธโฃ ํ๊ท ์ด๋
๐ ๊ฐ์
๐ก ํ๊ท ์ด๋
โ K-means clustering ๊ณผ ์ ์ฌํ๊ฒ ๊ตฐ์ง์ ์ค์ฌ์ผ๋ก ์ค์ฌ์ ์ง์์ ์ผ๋ก ์์ง์ด๋ฉฐ ๊ตฐ์งํ๋ฅผ ์ํํ๋ค.
โ ์ด๋ ๋ฐ์ดํฐ๊ฐ ๋ชจ์ฌ์๋ ๋ฐ๋๊ฐ ๊ฐ์ฅ ๋์ ๊ณณ์ผ๋ก ์ค์ฌ์ ์ด๋์ํจ๋ค ๐ ๋ฐ์ดํฐ์ ๋ถํฌ๋ (ํ๋ฅ ๋ฐ๋ํจ์) ๋ฅผ ์ด์ฉํด ๊ตฐ์ง ์ค์ฌ์ ์ ์ฐพ๋๋ค
โ ๊ตฐ์ง ์ค์ฌ = ํ๋ฅ ๋ฐ๋ํจ์๊ฐ ํผํฌ์ธ ์ง์ = ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋ชจ์ฌ์๋ ์ง์
โ ํ๋ฅ ๋ฐ๋ํจ์๋ฅผ ์ฐพ๊ธฐ ์ํด KDE ๋ฅผ ์ด์ฉํ๋ค : ํน์ ๋ฐ์ดํฐ์ ์ฃผ๋ณ ๋ฐ์ดํฐ์์ ๊ฑฐ๋ฆฌ ๊ฐ์ KDE ํจ์ ๊ฐ์ผ๋ก ์ ๋ ฅํ ๋ค ๋ฐํ๊ฐ์ ํ์ฌ ์์น์์ ์ ๋ฐ์ดํธํ๋ฉฐ ์ด๋ํ๋ ๋ฐฉ์
from sklearn.cluster import MeanShift |
- .cluster_centers_ ์์ฑ์ผ๋ก ๊ตฐ์ง ๊ฒฐ๊ณผ ์๊ฐํ ์ ๊ตฐ์ง ์ค์ฌ์ ์ขํ๋ฅผ ํ์ํ ์ ์๋ค.
meanshift = MeanShift(bandwidth=0.8)
cluster_labels = meanshift.fit_predict(X)
print('cluster labels ์ ํ :' , np.unique(cluster_labels))
๐คธโ๏ธ KDE ๊ฐ๋ ์ดํด ์ฐธ๊ณ ์๋ฃ : https://darkpgmr.tistory.com/147
→ ๊ด์ธก๋ ๋ฐ์ดํฐ ๊ฐ๊ฐ์ ์ปค๋ํจ์๋ฅผ ์ ์ฉํ ๊ฐ์ ๋ชจ๋ ๋ํ๊ณ ๋ฐ์ดํฐ ๊ฑด์๋ก ๋๋ ํ๋ฅ ๋ฐ๋ํจ์๋ฅผ ์ถ์ ํ๋ค.
→ Non-parametic ํ ๋ฐ๋์ถ์ ๋ฐฉ๋ฒ์ผ๋ก ํ์คํ ๊ทธ๋จ ๋ฐฉ๋ฒ์ ๋ฌธ์ ์ ์ ๊ฐ์
→ ๋ํ์ ์ธ ์ปค๋ ํจ์ : ๊ฐ์ฐ์์ ๋ถํฌ ํจ์
๐คธโ๏ธ ์ปค๋ํจ์๋
๐ก ๋์ญํญ h
โ KDE ํํ๋ฅผ ๋ถ๋๋ฌ์ด ๋๋ ๋พฐ์กฑํ ํํ๋ก ํํํ ํ๋๋ฐ ์ ์ฉ๋๋ค.
โ h ๊ฐ์ ๋ฐ๋ผ ํ๋ฅ ๋ฐ๋ ์ถ์ ์ฑ๋ฅ์ ํฌ๊ฒ ์ข์ฐํ ์ ์๋ค. ์์ h (1.0) ๊ฐ์ ์ข๊ณ ๋พฐ์กฑํ KDE ๋ฅผ ๊ฐ์ง๋ฉฐ ๊ณผ์ ํฉ ๋๊ธฐ ์ฝ๋ค. ๋ฐ๋ฉด ๋งค์ฐ ํฐ h (10) ๊ฐ์ ๊ณผ๋ํ๊ฒ ํํํ smoothing ๋์ด ์ง๋์น๊ฒ ๋จ์ํ๋ ๋ฐฉ์์ผ๋ก ํ๋ฅ ๋ฐ๋ํจ์๋ฅผ ์ถ์ ํ๋ฏ๋ก ๊ณผ์์ ํฉ ๋๊ธฐ ์ฝ๋ค.
โ ์ ์ ํ ๋์ญํญ h ๋ฅผ ๋์ถํด๋ด๋ ๊ฒ์ด KDE ๊ธฐ๋ฐ์ ํ๊ท ์ด๋ ๊ตฐ์งํ์์ ๋งค์ฐ ์ค์ํ๋ค.
- ๋์ญํญ h ๊ฐ ํด์๋ก ํํํ๋ KDE ๋ก ์ธํด ์ ์ ์์ ๊ตฐ์ง ์ค์ฌ์ ์ ๊ฐ์ง๋ค.
- ํ๊ท ์ด๋ ๊ตฐ์งํ๋ ๋ฏธ๋ฆฌ ๊ตฐ์ง์ ๊ฐ์๋ฅผ ์ง์ ํ์ง ์์ผ๋ฉฐ, ์ค์ง ๋์ญํญ์ ํฌ๊ธฐ์ ๋ฐ๋ผ ๊ตฐ์งํ๋ฅผ ์ํ ๐ ์ต์ ์ h ๋ฅผ ์ค์ ํด์ฃผ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ ๐ estimate_bandwidth
from sklearn.cluster import estimate_bandwidth |
bandwidth = estimate_bandwidth(X)
print('์ต์ ์ bandwidth ๊ฐ : ' , bandwidth)
๐ก ์ฅ๋จ์
๐จ ์ฅ์
โ ๋ฐ์ดํฐ ์ธํธ์ ํํ๋ฅผ ํน์ ํ ํํ๋ก ๊ฐ์ ํ์ง ์๊ธฐ ๋๋ฌธ์ ์ ์ฐํ ๊ตฐ์งํ๊ฐ ๊ฐ๋ฅํ๋ค.
โ ์ด์์น์ ์ํฅ๋ ฅ์ด ํฌ์ง ์๋ค.
โ ๋ฏธ๋ฆฌ ๊ตฐ์ง์ ๊ฐ์๋ ์ ํ ํ์๊ฐ ์๋ค.
๐จ ๋จ์
โ ์๊ณ ๋ฆฌ์ฆ ์ํ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฐ๋ค.
โ h ์ ๋ฐ๋ฅธ ๊ตฐ์งํ ์ํฅ๋๊ฐ ๋งค์ฐ ํฌ๋ค.
๐ ํ๊ท ์ด๋ ๊ตฐ์งํ ๊ธฐ๋ฒ์ ๋ถ์ ์ ๋ฌด ๊ธฐ๋ฐ์ ๋ฐ์ดํฐ ์ธํธ๋ณด๋จ ์ปดํจํฐ ๋น์ ์์ญ (object detection, motion detection) ์์ ๋ฐ์ด๋ ์ญํ ์ ์ํํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๐ ์ค์ต iris data
๐โ๏ธ ์ต์ ์ bandwidth h ๊ฐ ๋์ถ
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.cluster import MeanShift
from sklearn.cluster import estimate_bandwidth
iris = load_iris()
feature_name = ['sepal_length','sepal_width','petal_length','petal_width']
irisdf = pd.DataFrame(data=iris.data, columns = feature_name)
bandwidth = estimate_bandwidth(iris.data)
print('๋์ญํญ ๊ฐ : ', bandwidth)
## ๋์ญํญ ๊ฐ : 1.2020768127998687
๐โ๏ธ ์ต์ ์ bandwidth ๋ก ํ๊ท ์ด๋ ๊ตฐ์งํ
irisdf['target'] = iris.target
meanshift = MeanShift(bandwidth = bandwidth)
cluster_labels = meanshift.fit_predict(iris.data)
print('cluster labels ์ ํ : ', np.unique(cluster_labels))
## cluster labels ์ ํ : [0 1] ๐ 2๊ฐ์ ๊ตฐ์ง
๐โ๏ธ ์๊ฐํ
๐โ๏ธ target ๋ถํฌ์ ๋น๊ต
print(irisdf.groupby('target')['meanshift_label'].value_counts())
4๏ธโฃ GMM
๐ ๊ฐ์
๐ก Gaussian Mixture Model
โ ๊ตฐ์งํ๋ฅผ ์ ์ฉํ๊ณ ์ ํ๋ ๋ฐ์ดํฐ๊ฐ ์ฌ๋ฌ๊ฐ์ธ ๊ฐ์ฐ์์๋ถํฌ๋ฅผ ๊ฐ์ง ๋ฐ์ดํฐ ์งํฉ๋ค์ด ์์ฌ์ ์์ฑ๋ ๊ฒ์ด๋ผ๋ ๊ฐ์ ํ์ ๊ตฐ์งํ๋ฅผ ์ํํ๋ ๋ฐฉ์ ๐ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ฐ์์ ๋ถํฌ๊ฐ ์์ธ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๋ค.
โ ๊ฐ์ฐ์์๋ถํฌ (์ ๊ท๋ถํฌ) ๐ ์ข์ฐ๋์นญ์ ์ข ํํ๋ฅผ ๊ฐ์ง ์ฐ์ ํ๋ฅ ํจ์
โ ์ ์ฒด ๋ฐ์ดํฐ ์ธํธ๋ ์๋ก ๋ค๋ฅธ ์ ๊ท๋ถํฌ ํํ๋ฅผ ๊ฐ์ง ์ฌ๋ฌ ๊ฐ์ง ํ๋ฅ ๋ถํฌ ๊ณก์ ์ผ๋ก ๊ตฌ์ฑ๋๋ฉฐ, ์ด๋ ๊ฒ ์๋ก ๋ค๋ฅธ ์ ๊ท๋ถํฌ์ ๊ธฐ๋ฐํด ๊ตฐ์งํ๋ฅผ ์ํํจ ๐ ๋ฐ์ดํฐ ์ธํธ๋ก ๋ถํฐ ์ฌ๋ฌ ๊ฐ์ ์ ๊ท๋ถํฌ๊ณก์ ์ ์ถ์ถํ๊ณ ๊ฐ๋ณ ๋ฐ์ดํฐ๊ฐ ์ด ์ค ์ด๋ค ์ ๊ท๋ถํฌ์ ์ํ๋์ง ๊ฒฐ์ ํ๋ค.
๐จ ๋ชจ์์ถ์
โ ๊ฐ๋ณ ์ ๊ท ๋ถํฌ์ ํ๊ท ๊ณผ ๋ถ์ฐ
โก ๊ฐ ๋ฐ์ดํฐ๊ฐ ์ด๋ค ์ ๊ท๋ถํฌ์ ํด๋น๋๋์ง์ ํ๋ฅ
๐จ EM ์๊ณ ๋ฆฌ์ฆ (Iterative ํ ์๊ณ ๋ฆฌ์ฆ) ์ผ๋ก ๋ชจ์ ์ถ์ ์ ์งํ : ์ฌ์ดํท๋ฐ์ GaussianMixture ํด๋์ค ์ง์
โ GMM, EM ์๊ณ ๋ฆฌ์ฆ ์ฐธ๊ณ ์๋ฃ : https://angeloyeo.github.io/2021/02/08/GMM_and_EM.html
→ ์ ๊ท๋ถํฌ๋ฅผ ๊ฐ์ ํ ์ฑ, ๋๋คํ๊ฒ ๋ชจ์๋ฅผ ์ฃผ์ด์ค ๋ค ๋ผ๋ฒจ์ ์ป๊ณ , ๊ทธ ๋ผ๋ฒจ๋ค์ ์ด์ฉํด ๋ค์ ๋ถํฌ๋ฅผ ์ป๋ ๋ฐฉ์์ผ๋ก clustering์ ์ํ
from sklearn.mixture import GaussianMixture |
โญ n_components : ๊ฐ์ฐ์์ ๋ชจ๋ธ์ ์ด ๊ฐ์ (K-means clustering ์ K ์ ํด๋นํ๋ ๋ถ๋ถ)
๐จ kmeans vs GMM
๐จ ์ด์์น ํ์ง์์์ ํ์ฉ : ๋ฐ๋ ์๊ณ๊ฐ์ ์ ํด ๋ฐ๋๊ฐ ๋ฎ์ ์ง์ญ์ ์๋ ๋ชจ๋ ์ํ์ ์ด์์น๋ก ํ๋จํ๋ค.
๐ก Bayesian Gaussian Mixture Model
โ ๋ถํ์ํ ํด๋ฌ์คํฐ์ ๊ฐ์ค์น๋ฅผ 0 ๋๋ 0์ ๊ฐ๊น๊ฒ ๋ง๋๋ ๋ฐฉ์
โ ์ต์ ์ ํด๋ฌ์คํฐ ๊ฐ์๋ฅผ ์๋์ผ๋ก ์ฐพ์ ํ์๊ฐ ์๋ค.
โ ์ฌ์ดํท๋ฐ์ BayesianGaussianMixture ํด๋์ค๋ฅผ ์ฌ์ฉ
โ n_components ๋ฅผ ์ต์ ์ ํด๋ฌ์คํฐ ๊ฐ์๋ณด๋ค ํฌ๊ฒ ์ง์ ํ์ฌ๋ ์๋์ผ๋ก ๋ถํ์ํ ํด๋ฌ์คํฐ๋ฅผ ์ ๊ฑฐํ์ฌ ์ค๋ค.
from sklearn.mixture import BayesianGaussianMixture
bgm = BayesianGaussianMixture(n_components = 10, n_init = 10, random_state=0)
bgm.fit(X)
bgm_label = bgm.fit_predict(X)
clusterdf['bgm_label] = bgm_label
# ์๊ฐํ
np.round(bgm.weights_, 2)
## array([0.34, 0.34, 0.33, 0. , 0., 0., 0., 0., 0., 0.])
→ .weights_ ๋ก ๊ฐ์ค์น๋ฅผ ํ์ธํด๋ณด๋ฉด ์ง์ ํ 10๊ฐ์ ํด๋ฌ์คํฐ ์ค 3๊ฐ๊ฐ ํ์ํจ์ ์ ์ ์๋ค. ๋๋จธ์ง ํด๋ฌ์คํฐ์ ๊ฐ์ค์น๋ ๋ชจ๋ 0์ด ๋จ
๐ ์ค์ต iris data
๐โ๏ธ GMM clustering
from sklearn.mixture import GaussianMixture
gmm = GaussianMixture(n_components=3, random_state=0).fit(iris.data)
gmm_cluster_labels = gmm.predict(iris.data)
irisdf['gmm_cluster'] = gmm_cluster_labels
irisdf['target'] = iris.target
iris_result = irisdf.groupby(['target'])['gmm_cluster'].value_counts()
print(iris_result)
๐โ๏ธ ์๊ฐํ
๐ K-means ๊ฒฐ๊ณผ๋ณด๋ค ๋ ํจ๊ณผ์ ์ธ ๋ถ๋ฅ ๊ฒฐ๊ณผ๊ฐ ๋์ถ๋จ์ ํ์ ํ ์ ์๋๋ฐ, ์ด๋ ์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ด ๋ ๋ฐ์ด๋๋ค๋ ์๋ฏธ๊ฐ ์๋, ๋ถ๊ฝ ๋ฐ์ดํฐ ์ธํธ๊ฐ GMM ๊ตฐ์งํ์ ๋ ํจ๊ณผ์ ์ผ๋ก ์์ฉํ๋ ๊ฒ์ด๋ค.
โญ GMM ์ ๊ฒฝ์ฐ๋ Kmeasn (→ ์ํ ๋ชจ์ ์ธ์, ์๋ฅผ๋ค์ด ํ์ ๋ชจ์ ๋ถํฌ ๋ฐ์ดํฐ ์ ์๋ ์ ์๋ํ์ง ์์) ๋ณด๋ค ์ ์ฐํ๊ฒ ๋ค์ํ ๋ฐ์ดํฐ ์ธํธ์ ์ ์ ์ฉ๋ ์ ์๋ค. ๊ทธ๋ฌ๋ ์ํ ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฐ๋ค.
5๏ธโฃ DBSCAN
๐ ๊ฐ์
์ ์ค๋ก ์ฃผ๋ณ ์์ญ์ ์ต์ ๋ฐ์ดํฐ ๊ฐ์๋ฅผ ํฌํจํ๋ ๋ฐ๋ ๊ธฐ์ค์ ์ถฉ์กฑํ๋ core point๋ฅผ ์ฐ๊ฒฐํ๋ฉฐ ๊ตฐ์งํ
๐ก DBSCAN
โ ๋ฐ๋ ๊ธฐ๋ฐ ๊ตฐ์งํ์ ๋ํ์ ์ธ ์๊ณ ๋ฆฌ์ฆ
โ ํน์ ๊ณต๊ฐ ๋ด์ ๋ฐ์ดํฐ ๋ฐ๋ ์ฐจ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์ ๋ถํฌ๊ฐ ๊ธฐํํ์ ์ผ๋ก ๋ณต์กํ ๋ฐ์ดํฐ ์ธํธ์๋ ํจ๊ณผ์ ์ธ ๊ตฐ์งํ๊ฐ ๊ฐ๋ฅ
๐ก ํ๋ผ๋ฏธํฐ
from sklearn.cluster import DBSCAN |
โ epsilon : ๊ฐ๋ณ ๋ฐ์ดํฐ๋ฅผ ์ค์ฌ์ผ๋ก ์ ์ค๋ก ๋ฐ๊ฒฝ์ ๊ฐ์ง๋ ์ํ์ ์์ญ ๐ eps
→ ๋ณดํต 1 ์ดํ์ ๊ฐ์ ์ค์ ํ๋ค.
→ ๊ฐ์ ํฌ๊ฒํ๋ฉด ๋ฐ๊ฒฝ์ด ์ปค์ ธ ํฌํจํ๋ ๋ฐ์ดํฐ๊ฐ ๋ง์์ง๋ฏ๋ก ๋ ธ์ด์ฆ ๋ฐ์ดํฐ ๊ฐ์๊ฐ ์์์ง
โ min points : core point ๊ฐ ๋๊ธฐ ์ํด ์ ์ค๋ก ์ฃผ๋ณ ์์ญ ๋ด ํฌํจ๋์ด์ผ ํ ๋ฐ์ดํฐ์ ์ต์๊ฐ์ ๐ min_samples
→ ๊ฐ์ ํฌ๊ฒ ํ๋ฉด ๋ฐ๊ฒฝ ๋ด์ ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ํฌํจ์์ผ์ผ ํ๋ฏ๋ก ๋ ธ์ด์ฆ ๋ฐ์ดํฐ ๊ฐ์๊ฐ ์ปค์ง
๐ก ์ฃผ์ ๊ฐ๋
โฝ Core point : ์ฃผ๋ณ ์์ญ ๋ด ์ต์ ๋ฐ์ดํฐ๊ฐ์ ์ด์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒฝ์ฐ (์ A)
๐ ํน์ core point ์์ ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํ ๋ค๋ฅธ core point ๋ฅผ ์๋ก ์ฐ๊ฒฐํ๋ฉด์ ๊ตฐ์งํ๋ฅผ ๊ตฌ์ฑํ๋ค.
โฝ Neighbor point : ์ฃผ๋ณ ์์ญ ๋ด์ ์์นํ ๋ค๋ฅธ ๋ฐ์ดํฐ
โฝ Border point : ์ฃผ๋ณ ์์ญ ๋ด ์ต์ ๋ฐ์ดํฐ ๊ฐ์ ์ด์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ง ์์ผ๋, core point ๋ฅผ ์ด์ ํฌ์ธํธ๊ณ ๋ผ์ง๊ณ ์๋ ๋ฐ์ดํฐ (์ B)
๐ ๊ตฐ์ง์ ์ธ๊ณฝ์ ํ์ฑํ๋ค.
โฝ Noise point : ์ต์ ๋ฐ์ดํฐ ๊ฐ์ ์ด์์ ์ด์ ๋ฐ์ดํฐ๊ฐ์๊ฐ ์์ผ๋ฉฐ core point ๋ ์ด์ ํฌ์ธํธ๋ก ๊ฐ์ง๊ณ ์์ง ์๋ ๋ฐ์ดํฐ (์ C)
๐ ์ค์ต
๐โ๏ธ DBSCAN ๊ตฐ์งํ
from sklearn.cluster import DBSCAN
dbscan = DBSCAN(eps=0.6, min_samples = 8, metric = 'euclidean')
dbscan_label = dbscan.fit_predict(iris.data)
irisdf['dbscan_clutser'] = dbscan_label
iris_result = irisdf.groupby(['target'])['dbscan_clutser'].value_counts()
print(iris_result)
#๐ 0๊ณผ 1 2๊ฐ์ ๊ตฐ์ง์ผ๋ก ๋ถ๋ฅ๋ฅผ ์ํ
#๐ -1 : ๋
ธ์ด์ฆ์ ์ํ๋ ๊ตฐ์ง์ ์๋ฏธํ๋ค.
#๐ DBSCAN ์ ๊ตฐ์ง์ ๊ฐ์๋ฅผ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ผ ์๋์ผ๋ก ์ง์ ํด์ค
๐โ๏ธ ์๊ฐํ
๐ ์ธ๋ชจ๊ฐ์ ๋ ธ์ด์ฆ์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ก, ์ด์์น๋ฅผ ํ๋์ ํ์ ํ ์ ์๋ค.
๐ eps ๋ฅผ 0.8๋ก ์ฆ๊ฐ์ํค๋ฉด ๋ ธ์ด์ฆ ๊ฐ์๊ฐ ์ค์ด๋ ๋ค.
6๏ธโฃ ๋ณํฉ ๊ตฐ์ง
๐ ๊ฐ์
๐ก ๋ณํฉ๊ตฐ์ง Agglomerative clustering
โ ๊ฐ๊ฐ์ ๋ฐ์ดํฐ ํฌ์ธํธ๋ฅผ ํ๋์ ํด๋ฌ์คํฐ๋ก ์ง์ ํ๊ณ , ์ง์ ๋ ๊ฐ์์ ํด๋ฌ์คํฐ๊ฐ ๋จ์ ๋๊น์ง ๊ฐ์ฅ ๋น์ทํ ๋ ํด๋ฌ์คํฐ๋ฅผ ํฉ์ณ ๋๊ฐ๋ ์๊ณ ๋ฆฌ์ฆ
โ ๋ ํด๋ฌ์คํฐ๋ฅผ ํฉ์ณ ๋๊ฐ๋ ๋ฐฉ์
a. Ward : ๋ชจ๋ ํด๋ฌ์คํฐ ๋ด์ ๋ถ์ฐ์ ๊ฐ์ฅ ์๊ฒ ์ฆ๊ฐ์ํค๋ ๋ ํด๋ฌ์คํฐ๋ฅผ ํฉ์น๋ ๋ฐฉ์์ผ๋ก ํฌ๊ธฐ๊ฐ ๋น๊ต์ ๋น์ทํ ํด๋ฌ์คํฐ๊ฐ ๋ง๋ค์ด์ง๋ค.
b. Average : ํด๋ฌ์คํฐ ํฌ์ธํธ ์ฌ์ด์ ํ๊ท ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋ ํด๋ฌ์คํฐ๋ฅผ ํฉ์น๋ ๋ฐฉ์
c. Complete : ํด๋ฌ์คํฐ ํฌ์ธํธ ์ฌ์ด์ ์ต๋ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋ ํด๋ฌ์คํฐ๋ฅผ ํฉ์น๋ ๋ฐฉ์
๐จ ํด๋ฌ์คํฐ์ ์ํ ํฌ์ธํธ ์๊ฐ ๋ง์ด ๋ค๋ฅผ ๋ (ํ๋์ ํด๋ฌ์คํฐ๊ฐ ๋ค๋ฅธ ๊ฒ๋ณด๋ค ๋งค์ฐ ํด๋) average ๋ complete ๋ฐฉ๋ฒ์ด ๋ ์ข๋ค.
โ ๋ณํฉ๊ตฐ์ง์ ๊ณ์ธต์ ๊ตฐ์ง์ ๋ง๋ ๋ค. ์ฆ, ์์ ํด๋ฌ์คํฐ๋ค์ด ๋ชจ์ฌ ํฐ ํด๋ฌ์คํฐ๋ฅผ ์ด๋ฃจ๋ ๊ณ์ธต์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ๊ฒ์ด๋ค.
๐ก ๊ณ์ธต์ ๊ตฐ์ง
โ ๊ณ์ธต์ ํธ๋ฆฌ ๋ชจํ์ ์ด์ฉํด ๊ฐ๋ณ ๋ฐ์ดํฐ ํฌ์ธํธ๋ค์ ์์ฐจ์ , ๊ณ์ธต์ ์ผ๋ก ์ ์ฌํ ํด๋ฌ์คํฐ๋ก ํตํฉํ์ฌ ๊ตฐ์งํ๋ฅผ ์ํํ๋ ์๊ณ ๋ฆฌ์ฆ
โ ์ฌ์ ์ ํด๋ฌ์คํฐ ๊ฐ์๋ฅผ ์ ํ์ง ์์๋ ํ์ต ์ํ์ด ๊ฐ๋ฅํ๋ค.
โ ๋ด๋๋ก๊ทธ๋จ : ๊ณ์ธต ๊ตฐ์ง์ ์๊ฐํ ํ๋ ๋๊ตฌ๋ก ๋ค์ฐจ์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋ค.
- ๋ด๋๋ก๊ทธ๋จ์ ๊ฐ๋ก์ ์ผ๋ก ๋ถํ ํ๋ฉด ํด๋ฌ์คํฐ๋ฅผ ์์๋ก ๋๋ ์ ์๋ค. ์ฆ ๊ตฐ์งํ ํ๊ธฐ ์ ํด๋ฌ์คํฐ ๊ฐ์๋ฅผ ์ ํด์ฃผ์ด์ผ ํ๋ k-means ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฌ๋ฆฌ ๋ณํฉ ๊ตฐ์ง ๊ฐ์ ๊ณ์ธต์ ๊ตฐ์ง ์๊ณ ๋ฆฌ์ฆ์ ๊ตฐ์งํ๋ฅผ ์๋ฃํ ํ์ ์ฌ์ฉ์๊ฐ ์๊ฐํ๋ ๋ด๋๋ก๊ทธ๋จ์ ๋ณด๊ณ ํด๋ฌ์คํฐ๋ฅผ ๋๋ ์ ์๋ ๊ฒ์ด๋ค.
- ๊ทธ๋ฌ๋ kmeans ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ๊ฐ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ๋ณต์กํ ํ์์ ๋ฐ์ดํฐ ์ธํธ๋ ๊ตฌ๋ถํ์ง ๋ชปํ๋ค.
'1๏ธโฃ AIโขDS > ๐ ๋จธ์ ๋ฌ๋' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐ์ดํฐ๋ง์ด๋ Preprocessing โก (0) | 2023.03.15 |
---|---|
๋ฐ์ดํฐ๋ง์ด๋ Preprocessing โ (1) | 2023.03.15 |
[06. ์ฐจ์์ถ์] PCA, LDA, SVD, NMF (0) | 2022.04.24 |
[05. ํ๊ท] ์ ํํ๊ท, ๋คํญํ๊ท, ๊ท์ ํ๊ท, ๋ก์ง์คํฑํ๊ท, ํ๊ทํธ๋ฆฌ (0) | 2022.03.25 |
[04. ๋ถ๋ฅ] LightGBM, ์คํํน ์์๋ธ, Catboost (0) | 2022.03.20 |
๋๊ธ