K-Means 알고리즘 구현 | Kmean 클러스터링 알고리즘 및 파이썬 실습 상위 15개 베스트 답변

당신은 주제를 찾고 있습니까 “k-means 알고리즘 구현 – kmean 클러스터링 알고리즘 및 파이썬 실습“? 다음 카테고리의 웹사이트 https://chewathai27.com/you 에서 귀하의 모든 질문에 답변해 드립니다: Chewathai27.com/you/blog. 바로 아래에서 답을 찾을 수 있습니다. 작성자 Minsuk Heo 허민석 이(가) 작성한 기사에는 조회수 21,140회 및 좋아요 296개 개의 좋아요가 있습니다.

k-means 알고리즘 구현 주제에 대한 동영상 보기

여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!

d여기에서 kmean 클러스터링 알고리즘 및 파이썬 실습 – k-means 알고리즘 구현 주제에 대한 세부정보를 참조하세요

아래에서 코드 다운로드 받으시고 실습하세요.
https://github.com/minsuk-heo/python_tutorial/tree/master/data_science/kmean
머신러닝의 대표적인 클러스터링 알고리즘인 k-mean 알고리즘의 작동 원리를 예제와 함께 설명 드리고, 파이썬으로 실습합니다.
k-mean++ 방법도 설명 드립니다.
제가 만든 모든 머신러닝 관련 영상은 아래 재생목록에서 쉽게 찾으실 수 있습니다.
https://www.youtube.com/playlist?list=PLVNY1HnUlO241gILgQloWAs0xrrkqQfKe

k-means 알고리즘 구현 주제에 대한 자세한 내용은 여기를 참조하세요.

KMeans 알고리즘 구현하기 – 홍러닝

KMeans는 대표적인 군집화 알고리즘으로 간단한 특성으로 인해 온사이트 인터뷰나 코딩 테스트에서 스크래치부터 구현해보라는 문제가 가끔씩 출제 …

+ 여기에 자세히 보기

Source: hongl.tistory.com

Date Published: 4/19/2022

View: 2471

K-Means Clustering(K 평균 군집화) 개념 정리

이번 포스팅에서는 K-Means 알고리즘을 Python으로 직접 구현하여 원리를 이해한 후 sklearn 라이브러리를 활용하여 구현하는 방법에 대해 알아보도록 …

+ 여기에 표시

Source: blog.eunsukim.me

Date Published: 3/21/2022

View: 9823

11. K-Means 클러스터링(Clustering, 군집화)에 대해서 알아 …

4. K-Means 클러스터링(Clustering, 군집화) 파이썬 구현 … K-Means 클러스터링은 비지도 학습 알고리즘으로 사전에 클러스터 개수 k k 와 초기값을 …

+ 더 읽기

Source: zephyrus1111.tistory.com

Date Published: 8/2/2021

View: 110

Python을 활용한 K-means Clustering – 춤추는 개발자

클러스터링을 활용하면 추천 엔진, 검색 엔진, 시장 세분화 등을 구현할 수 있습니다. K-means Clustering이란? “K”는 주어진 데이터를 그룹화할 수 즉, …

+ 여기에 자세히 보기

Source: frtt0608.tistory.com

Date Published: 5/29/2022

View: 4656

[Matlab] K-Means Clustering (K-평균 군집화) 알고리즘 구현하기

[Matlab] K-Means Clustering (K-평균 군집화) 알고리즘 구현하기. Jongwon Kim 2020. 11. 24. 14:42. 1967년 처음 제안된 K-Means 클러스터링 (K-평균 군집화)은 …

+ 여기에 자세히 보기

Source: deep-eye.tistory.com

Date Published: 7/3/2022

View: 3297

K-means clustering Python으로 구현하기 – 자비스가 필요해

그럼 이제 sklearn 라이브러리에서 제공하는 kmeans 클러스터링을 실습해보도록 한다. K-means 클러스터링 예제. 라이브러리. import numpy as np import …

+ 여기를 클릭

Source: needjarvis.tistory.com

Date Published: 11/2/2022

View: 7786

[Sklearn] K-means 클러스터링 (K-평균 알고리즘) 파이썬 구현 + …

이번 글에서는 비지도 학습의 대표적 알고리즘인 K-means Clustering을 파이썬 사이킷런에서 구현해보는 예제를 다루어보겠습니다.

+ 더 읽기

Source: jimmy-ai.tistory.com

Date Published: 1/22/2021

View: 9817

[머신러닝] K-평균(K-Means) 알고리즘 – velog

둘은 모두 K개의 점을 지정하여 거리를 기반으로 구현되는 거리기반 분석 알고리즘이다. 하지만 둘의 차이점은 지도학습에 속하는 K-NN 알고리즘과 달리 K …

+ 더 읽기

Source: velog.io

Date Published: 6/2/2021

View: 3276

주제와 관련된 이미지 k-means 알고리즘 구현

주제와 관련된 더 많은 사진을 참조하십시오 kmean 클러스터링 알고리즘 및 파이썬 실습. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.

---

주제에 대한 기사 평가 k-means 알고리즘 구현

• Author: Minsuk Heo 허민석
• Views: 조회수 21,140회
• Likes: 좋아요 296개
• Date Published: 2017. 11. 19.
• Video Url link: https://www.youtube.com/watch?v=9TR54u08IGU

KMeans 알고리즘 구현하기

반응형

KMeans는 대표적인 군집화 알고리즘으로 간단한 특성으로 인해 온사이트 인터뷰나 코딩 테스트에서 스크래치부터 구현해보라는 문제가 가끔씩 출제됩니다. 이번 포스트에서는 scikit-learn, numpy 같은 외부 라이브러리 없이 파이썬의 내장 함수와 라이브러리만으로 KMeans 알고리즘을 구현해보도록 하겠습니다. 군집화할 데이터는 10000개의 16차원 벡터라 가정하면 16개의 실수 요소를 가진 리스트 10000개를 요소로 가진 리스트가 됩니다.

Utility functions

Euclidean distance

Distance metric으로 Euclidean distance를 계산하는 함수를 구현합니다. 입력으로 같은 길이의 리스트 2개를 받고 각 요소 별 차이의 제곱을 모두 더한 후 math 라이브러리의 sqrt 함수를 이용해 루트를 적용합니다.

import math def calc_dist(A, B): ”’ Calculate Euclidean distance ”’ assert len(A) == len(B) sum = 0 for a, b in zip(A, B): sum += (a – b)**2 return math.sqrt(sum) test_a = [1,2,3,4] test_b = [4,3,2,1] calc_dist(test_a, test_b)

Cluster centroid

KMeans는 매 스텝마다 업데이트된 클러스터를 기반으로 각 클러스터의 중심을 새롭게 구합니다. 입력으로는 각 클러스터에 할당된 벡터의 리스트가 되고 벡터 요소 별로 모두 더한뒤 개수만큼 나누어주어 각 차원 별 평균을 구해줍니다.

def calc_vector_mean(array): summation = [0] * len(array[0]) for row in array: for d in range(len(row)): summation[d] += row[d] for s in range(len(summation)): summation[s] = summation[s] / len(array) return summation test_array = [[1,2,3,4,5], [2,3,4,5,6], [3,4,5,6,7]] calc_vector_mean(test_array)

Update tolerance

이 함수는 KMeans 알고리즘 동작 시 각 클러스터 중심이 미리 정의한 임계치보다 작게 업데이트 된다면 알고리즘 수행을 멈추게 되는데, 전 스텝의 클러스터 중심과 현 스텝의 클러스터 중심의 Euclidean distance로 정의합니다. 따라서 위에서 정의한 “calc_dist” 함수를 사용합니다.

def calc_diff(A, B): ”’ Calculate Euclidean distance between two arrays (A, B) Arguments: – A, B: Arrays with same shape Returns: – Euclidean scalar value ”’ tol = 0 for a, b in zip(A, B): tol += calc_dist(a, b) return tol prev_centroids = [[1,2,3,4,5], [10,9,8,7,6]] pres_centroids = [[1.1, 2.1, 2.9, 3.9, 5.1], [10,9.1,8.9,6.9,5.1]] calc_diff(prev_centroids, pres_centroids)

KMeans

KMeans 알고리즘을 구현합니다. Scikit-learn 스타일로 생성자 함수에서 클러스터 개수, 최대 스텝 횟수, 알고리즘을 계속 수행하기 위한 클러스터 중심 업데이트 임계치를 정의합니다.

class Clustering(object): def __init__(self, k, max_iter=10, tol=1e-4): ”’ Arguments: – k: Number of clusters – max_iter: Maximum number of iteration – tol: Update tolerance, if centroids update is smaller than this value, fitting will stop ”’ self.k = k self.max_iter = max_iter self.tol = tol

클러스터 중심이 tol 인자의 숫자보다 작게 업데이트되면 최대 스텝 횟수에 동작하지 않더라도 알고리즘을 종료합니다.

Initialization

군집의 초기 중심을 선언합니다. 원래의 KMeans는 랜덤하게 초기 중심점을 잡지만 이럴 경우 초기화 상황에 따라 수렴이 매우 느려질 수 있으므로 각 군집 중심을 최대한 멀리 잡는 KMeans++를 사용합니다. 입력으로는 전체 데이터를 받습니다.

def random_init(self, array): ”’ K-Means++ init ”’ M = [] # Indices of initial points indices = [] i = random.randint(0, len(array)) M.append(array[i]) indices.append(i) while len(M) < self.k: max_dist = -float('inf') max_index = -1 for i in range(len(array)): avg_dist = 0 if i in indices: continue for j in range(len(M)): dist = calc_dist(array[i], array[j]) avg_dist += dist avg_dist /= len(M) if max_dist < avg_dist: max_dist = avg_dist max_index = i ## Add init point which has largest average distance in M #print(max_index) #print(max_dist) M.append(array[max_index]) indices.append(max_index) return M 전체 데이터 중에서 랜덤하게 임의의 초기값을 하나 잡고 군집 중심 리스트 (M)에 담습니다. 이후에는 전체 데이터에 대해 각각 M에 속한 중심값과의 평균 거리를 계산하고 평균 거리가 가장 큰 데이터를 M에 추가합니다. 전체 데이터에 반복 시 M에 속한 데이터에 대해서는 거리계산을 할 필요가 없으므로 continue 키워드를 사용하여 다음 반복문을 수행합니다. Fit KMeans 훈련 코드를 작성합니다. 지정한 최대 스텝 횟수에 맞게 1) 군집 재할당, 2) 군집 중심 계산을 반복합니다. 지정한 임계치보다 군집 중심이 작게 업데이트되면 훈련을 종료합니다. def fit(self, X): ''' Arguments: - X: Array of [10000, 16] Returns: - Cluster assignment of each vector, Centroids of cluster ''' self.centroids = self.random_init(X) for iter in range(self.max_iter): print(f'{iter+1} iteration...') ## Assign cluster self._assign_cluster(X) ## Update centroids self._update_centroids(X) if calc_diff(self.prev_centroids, self.centroids) < self.tol: break return self.assignments, self.centroids 데이터 별로 군집 번호를 할당하는 "_assign_cluster" 함수를 구현합니다. 데이터 별로 거리가 가장 짧은 군집 중심에 대해 군집을 할당합니다. def _assign_cluster(self, X): self.assignments = [] for d in X: min_dist = float('inf') min_index = -1 for i, centroid in enumerate(self.centroids): dist = calc_dist(d, centroid) if dist < min_dist: min_dist = dist min_index = i self.assignments.append(min_index) 다음으로 할당된 군집에 대해 군집 중심을 업데이트하는 "_update_centroids" 함수를 작성합니다. 주의할 점은 데이터의 분포나 군집 수에 따라서 우리가 지정한 군집 수보다 적은 군집이 할당되는 경우가 생길 수 있다는 점입니다. 즉, 특정 군집에 대해 할당된 데이터가 아예 없는 경우가 생길 수 있다는 것이죠. 다음 그림과 같은 상황에서, Step 1 알고리즘을 진행하면 4번 데이터는 빨간색 군집, 5번 데이터는 초록색 군집에 가깝기 때문에 다음 그림과 같이 파란색 군집에는 데이터가 아예 할당되지 않습니다. Step 2 이러한 경우에는 가장 간단하게는 전체 데이터에서 랜덤하게 데이터를 하나 샘플링해서 군집에 데이터를 하나 강제로 할당해 주거나 SSE (Sum of Squared Error)가 가장 큰 군집에서 데이터를 하나 뽑아주는 방법이 있습니다. 물론 가장 좋은 방법은 군집 개수를 줄이는 것이겠죠. 코드는 다음과 같습니다. def _update_centroids(self, X): self.prev_centroids = copy.deepcopy(self.centroids) for i in range(self.k): ## Filter data with 'i' cluster data_indices = list(filter(lambda x: self.assignments[x] == i, range(len(self.assignments)))) ## If there isn't any data points to cluster ## Assign random point from data if len(data_indices) == 0: r = random.randint(0, len(X)) self.centroids[i] = X[r] continue cluster_data = [] for index in data_indices: cluster_data.append(X[index]) self.centroids[i] = calc_vector_mean(cluster_data) 참조 반응형

K-Means Clustering(K 평균 군집화) 개념 정리

현실 세계에서 만나게 되는 데이터에 항상 label이 주어지는 것은 아닙니다. 이러한 unlabeled 데이터에 숨겨진 패턴을 찾아내고 구조화하는 머신러닝 기법을 비지도학습(Unsupervised Learning)이라고 합니다. Clustering(클러스터링) 은 가장 널리 알려진 비지도학습 중 한 가지 기법으로, 비슷한 유형의 데이터를 그룹화함으로써 unlabeled 데이터에 숨겨진 구조를 파악합니다. 클러스터링을 응용하여 다음과 같은 것들을 구현할 수 있습니다.

Recommendation Engines(추천 엔진) : 개인화된 사용자 경험을 제공하기위해 상품들을 그룹화 합니다

: 개인화된 사용자 경험을 제공하기위해 상품들을 그룹화 합니다 Search Engines(검색 엔진) : 뉴스 토픽들과 검색 결과를 그룹화 합니다

: 뉴스 토픽들과 검색 결과를 그룹화 합니다 Market Segmentation(시장 세분화): 지역, 인구, 행동 등을 바탕으로 고객을 그룹화 합니다

K-Means Clustering

K-Means 알고리즘은 가장 유명한 클러스터링 알고리즘입니다. “K”는 주어진 데이터로부터 그룹화 할 그룹, 즉 클러스터의 수를 말합니다. “Means”는 각 클러스터의 중심과 데이터들의 평균 거리를 의미합니다. 이 때 클러스터의 중심을 centroids 라고 합니다.

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

데이터셋에서 K 개의 centroids를 임의로 지정합니다. 각 데이터들을 가장 가까운 centroids가 속한 그룹에 할당합니다. 2번 과정에서 할당된 결과를 바탕으로 centroids를 새롭게 지정합니다. 2 ~ 3번 과정을 centroids가 더 이상 변하지 않을 때 까지 반복합니다.

위 과정이 완료되면 unlabeled 데이터를 빠른 속도로 적절한 클러스터에 할당할 수 있습니다. 이번 포스팅에서는 K-Means 알고리즘을 Python으로 직접 구현하여 원리를 이해한 후 sklearn 라이브러리를 활용하여 구현하는 방법에 대해 알아보도록 하겠습니다.

Iris Dataset

K-Means 알고리즘을 구현하기 전에 이번 포스팅에서는 sklearn 에서 제공하는 데이터셋인 Iris(붓꽃) Dataset 을 활용하도록 하겠습니다. 위 데이터셋은 붓꽃의 서로 다른 3가지 종( setosa , versicolor , virginica )의 sepal(꽃받침), petal(꽃잎) feature를 포함하고 있습니다.

위 데이터는 sklearn 에서 제공하고 있습니다. sklearn 라이브러리에 포함된 datasets 모듈에서 해당 데이터를 불러올 수 있습니다.

from sklearn import datasets iris = datasets . load_iris ( ) samples = iris . data print ( samples )

데이터셋은 다음과 같은 내용을 포함하고 있습니다.

array ( [ [ 5.1 , 3.5 , 1.4 , 0.2 ] , [ 4.9 , 3. , 1.4 , 0.2 ] , . . . [ 5.9 , 3. , 5.1 , 1.8 ] ] )

여기서 각 row는 하나의 데이터 sample 을 나타냅니다. 각 column은 feature를 나타내며 순서대로 sepal length(꽃받침의 길이) , sepal width(꽃받침의 넓이) , petal length(꽃잎의 길이) , petal width(꽃잎의 넓이) 를 의미합니다. 이렇게 load한 데이터는 Bunch 라는 객체로 생성됩니다. 이 객체의 속성으로 .data 이외에 데이터의 label인 .target 과 데이터에 대한 설명인 .DESCR 등이 있으며, 자세한 설명은 공식 Document를 참조하시기 바랍니다.

이번 포스팅에서는 sepal length와 width 두 가지 feature만을 고려하도록 하겠습니다. 데이터로부터 두 feature만을 뽑아내어 산점도를 그려보도록 하곘습니다. x축이 length를, y축이 width를 나타냅니다.

from matplotlib import pyplot as plt x = samples [ : , 0 ] y = samples [ : , 1 ] plt . scatter ( x , y , alpha = 0.5 ) plt . xlabel ( ‘sepal length (cm)’ ) plt . ylabel ( ‘sepal width (cm)’ ) plt . show ( )

Iris Dataset은 원래 label이 제공되지만, label이 없다고 가정하고 K-Mean 알고리즘으로 위 데이터를 그룹화 시켜보도록 하겠습니다.

Implementing K-Means

지금부터 K-Means 클러스터링 알고리즘으로 비슷한 붓꽃 끼리 그룹화하는 것을 구현해보도록 하겠습니다.

STEP 1: Place K Random Centroids

제일 먼저 K 개의 centroids를 임의로 지정하도록 하겠습니다. 이 때 3가지 종이 존재하므로 K 는 3 으로 설정하겠습니다.

import numpy as np k = 3 centroids_x = np . random . uniform ( min ( x ) , max ( x ) , k ) centroids_y = np . random . uniform ( min ( y ) , max ( y ) , k ) centroids = list ( zip ( centroids_x , centroids_y ) )

그리하여 centroids 는 임의로 생성한 (x, y) 좌표 3개를 갖게 됩니다. centroids 가 데이터상에서 어디에 위치하고 있는지 확인해보면 다음과 같습니다.

plt . scatter ( x , y , alpha = 0.5 ) plt . scatter ( centroids_x , centroids_y ) plt . show ( )

STEP 2: Assign Datas to Nearest Centroid

Centroids를 지정했다면 이제 해당 centroids에 가까운 데이터들을 할당해줍니다. 이 때 ‘가깝다’ 라는 것을 정량적으로 계산하기 위해 각 데이터를 벡터로 간주하여 유클리드 거리를 계산하도록 하겠습니다. 먼저 두 데이터 포인트 사이의 거리를 계산하는 distance() 함수를 작성합니다.

d i s t a n c e = ( a 1 − b 1 ) 2 + ( a 2 − b 2 ) 2 + ⋯ + ( a n − b n ) 2 distance = \sqrt{(a_1 – b_1)^2 + (a_2 – b_2)^2 + \cdots + (a_n – b_n)^2} distance=(a1​−b1​)2+(a2​−b2​)2+⋯+(an​−bn​)2 ​

def distance ( a , b ) : return sum ( [ ( el_a – el_b ) ** 2 for el_a , el_b in list ( zip ( a , b ) ) ] ) ** 0.5

이제 각 데이터들 별로 3개의 centroids와의 거리를 측정합니다. 이 때 labels 란 배열을 생성하고, 가장 가까운 centroids의 index를 저장하도록 합니다.

labels = np . zeros ( len ( samples ) ) sepal_length_width = np . array ( list ( zip ( x , y ) ) ) for i in range ( len ( samples ) ) : distances = np . zeros ( k ) for j in range ( k ) : distances [ j ] = distance ( sepal_length_width [ i ] , centroids [ j ] ) cluster = np . argmin ( distances ) labels [ i ] = cluster

이렇게 생성한 labels 에는 0 , 1 또는 2 가 저장되어 각 데이터가 어느 centroid그룹에 속해있는지를 나타내게 됩니다. 각 데이터가 어느 그룹에 속하게 되었는지 눈으로 확인하기 위해 시각화 해봅시다.

plt . scatter ( x , y , c = labels , alpha = 0.5 ) plt . scatter ( centroids_x , centroids_y , c = ‘red’ ) plt . show ( )

데이터들이 가까운 centroid에 잘 할당되어있지만, 처음 centroid를 선택할 때 랜덤으로 선택한 탓에 데이터를 잘 그룹화한 것 같지는 않은 듯 합니다.

이제 centroids를 새롭게 지정함으로써 데이터를 더 잘 그룹화 할 수 있도록 만들어봅시다. 우선 기존에 지정한 centroids를 복사해두어 centroids_old 에 저장하도록 합시다. 이 때 deep copy(깊은 복사)를 하기위해 python 라이브러리인 copy 를 임포트하여 활용합니다.

from copy import deepcopy centroids_old = deepcopy ( centroids )

이제 각 그룹별로 데이터의 평균을 계산합니다. 즉, 각 데이터들의 평균 x좌표와 평균 y좌표를 계산하여 하나의 좌표를 계산합니다. 이렇게 계산된 좌표는 새로운 centroid로 지정됩니다.

for i in range ( k ) : points = [ sepal_length_width [ j ] for j in range ( len ( sepal_length_width ) ) if labels [ j ] == i ] centroids [ i ] = np . mean ( points , axis = 0 )

새롭게 지정된 centroids는 어디에 위치하는지 확인해봅시다. 기존의 centroid는 파란색, 새롭게 지정된 centroids는 빨간색으로 나타냅니다.

plt . scatter ( x , y , c = labels , alpha = 0.5 ) plt . scatter ( centroids_old [ : , 0 ] , centroids_old [ : , 1 ] , c = ‘blue’ ) plt . scatter ( centroids [ : , 0 ] , centroids [ : , 1 ] , c = ‘red’ ) plt . show ( )

Centroids가 전체적으로 중앙으로 이동하여 데이터의 중심 지점에 위치한 것을 확인할 수 있습니다.

STEP 4: Repeat Step 2 ~ 3 Until Convergence

이제 필요한 모든 building blocks를 구현하였습니다. 남은건 2 ~ 3단계를 반복하여 최적의 centroids를 찾는 것입니다. 그런데 언제까지 찾아야 할까요?

STEP 4를 수행하기 전에 error 라는 배열을 하나 만들어줍니다. error 의 각 index는 centroids_old 와 새롭게 지정된 centroids 의 거리를 저장합니다. 이 거리가 모두 0 이 되면 최적해에 수렴(convergence)한 것으로 판단하여 반복을 종료합니다.

centroids_old = np . zeros ( centroids . shape ) labels = np . zeros ( len ( samples ) ) error = np . zeros ( k ) for i in range ( k ) : error [ i ] = distance ( centroids_old [ i ] , centroids [ i ] ) while ( error . all ( ) != 0 ) : for i in range ( len ( samples ) ) : distances = np . zeros ( k ) for j in range ( k ) : distances [ j ] = distance ( sepal_length_width [ i ] , centroids [ j ] ) cluster = np . argmin ( distances ) labels [ i ] = cluster centroids_old = deepcopy ( centroids ) for i in range ( k ) : points = [ sepal_length_width [ j ] for j in range ( len ( sepal_length_width ) ) if labels [ j ] == i ] centroids [ i ] = np . mean ( points , axis = 0 ) for i in range ( k ) : error [ i ] = distance ( centroids_old [ i ] , centroids [ i ] )

자, 이제 최적의 centroids를 찾았으니 이를 시각화하여 확인해봅시다. 직관적으로 알아보기위해 색을 r , g , b 로 설정해줍니다. 또 centroids는 다이아몬드 형태로 마킹해줍시다.

colors = [ ‘r’ , ‘g’ , ‘b’ ] for i in range ( k ) : points = np . array ( [ sepal_length_width [ j ] for j in range ( len ( sepal_length_width ) ) if labels [ j ] == i ] ) plt . scatter ( points [ : , 0 ] , points [ : , 1 ] , c = colors [ i ] , alpha = 0.5 ) plt . scatter ( centroids [ : , 0 ] , centroids [ : , 1 ] , marker = ‘D’ , s = 150 ) plt . xlabel ( ‘sepal length (cm)’ ) plt . ylabel ( ‘sepal width (cm)’ ) plt . show ( )

이렇게 하여 클러스터링이 잘 이뤄진 것을 확인할 수 있습니다.

지금까지 K-Means 알고리즘을 순수 Python으로 구현하였습니다. 코드의 양이 상당히 많고 복잡한데, 이를 간편하게 구현하는 방법은 scikit-learn 라이브러리를 활용하는 것입니다. sklearn 라이브러리의 cluster 모듈에는 K-Means를 구현할 수 있는 KMeans 를 제공합니다.

from sklearn . cluster import KMeans

KMeans로 모델을 생성할 때, 클러스터링 하려는 그룹의 수 k 를 지정해줘야 합니다. 이는 n_clusters 옵션으로 지정할 수 있습니다.

model = KMenas ( n_clusters = k )

다음으로 .fit() 메서드를 통해 K-Mean 클러스터링을 수행할 수 있습니다.

model . fit ( X )

K-Means를 수행한 다음, .predict() 메서드를 통해 unlabeled 데이터를 그룹에 할당할 수 있습니다.

model . predict ( X )

그리하여 scikit-learn을 통해 다음과 같이 4가지 feature를 모두 사용하여 iris 데이터를 클러스터링 할 수 있습니다.

import matplotlib . pyplot as plt from sklearn import datasets from sklearn . cluster import KMeans iris = datasets . load_iris ( ) samples = iris . data model = KMeans ( n_clusters = 3 ) model . fit ( samples ) labels = model . predict ( samples ) x = samples [ : , 0 ] y = samples [ : , 1 ] plt . scatter ( x , y , c = labels , alpha = 0.5 ) plt . xlabel ( ‘sepal length (cm)’ ) plt . ylabel ( ‘sepal width (cm)’ ) plt . show ( )

Evaluation

지금까지 Iris 데이터를 3가지 서로 다른 그룹으로 클러스터링 하는 것을 Python과 sklearn 을 활용하여 구현하였습니다. 그런데 과연 실제로 얼마나 많은 데이터를 올바르게 분류한 것일까요? 이를 확인해보도록 합시다.

Cross Tabulation

Iris 데이터셋은 label이 포함되어 있습니다. 이는 target 이라는 내장 속성을 통해 접근할 수 있습니다.

target = iris . target

target 은 다음과 같이 생겼습니다.

[ 0 0 0 0 0 . . . 2 2 2 ]

여기서 0 은 setosa , 1 은 versicolor , 그리고 2 는 virginica 를 나타냅니다. 이처럼 숫자로 나타낸 값들을 문자열로 변경해 주도록 합시다.

species = np . chararray ( target . shape , itemsize = 150 ) for i in range ( len ( samples ) ) : if target [ i ] == 0 : species [ i ] = ‘setosa’ elif target [ i ] == 1 : species [ i ] = ‘versicolor’ elif target [ i ] == 2 : species [ i ] = ‘virginica’

다음으로 cross-tabulation 을 통해 결과를 분석해 보도록 하겠습니다. Pandas 라이브러리를 활용하면 이를 쉽게 구현할 수 있습니다.

import pandas as pd df = pd . DataFrame ( { ‘labels’ : labels , ‘species’ : species } ) ct = pd . crosstab ( df [ ‘labels’ ] , df [ ‘species’ ] ) print ( ct )

species b’setosa’ b’versicolor’ b’virginica’ labels 0 0 48 14 1 50 0 0 2 0 2 36

위 표를 분석한 결과는 다음과 같습니다.

Setosa 는 100%의 정확도로 분류되었습니다.

Versicolor 는 96%의 정확도로 분류되었습니다.

Virginica 는 그다지 잘 분류되지 않았습니다.

Number of Clusters

이번 포스팅에서 Iris 데이터를 3 개의 그룹으로 클러스터링 하였지만, 만약 데이터셋에서 종의 갯수가 주어지지 않는다면 어떻게 해야 할까요? 그런 경우 몇 개의 그룹으로 클러스터링 해야 하는지 어떻게 결정할 수 있을까요?

위 질문에 답변하기 전에 먼저 무엇이 ‘좋은’ 그룹인지 정의해야 합니다. 일단 그룹에 포함된 각 데이터 포인트들이 뭉쳐져 있을 경우 ‘좋은’ 그룹이라고 말할 수 있을 것입니다. 그룹에 포함된 데이터들이 퍼져있는 정도를 inertia 라고 하는데, Inertia는 각 클러스터의 중심인 centroid와 각 데이터들 사이의 거리를 나타냅니다. 즉, Inertia가 낮은 그룹을 ‘좋은’ 그룹이라 할 수 있고, 이러한 그룹을 적게 만들수록 좋은 모델이라고 할 수 있습니다.

KMeans 객체는 내부적으로 .inertia_ 속성을 가지고 있습니다. KMeans 모델을 생성할 때 num_clusters 옵션을 다르게 부여하면서 inertia를 비교하는 방법은 다음과 같습니다.

num_clusters = list ( range ( 1 , 9 ) ) inertias = [ ] for i in num_clusters : model = KMeans ( n_clusters = i ) model . fit ( samples ) inertias . append ( model . inertia_ ) plt . plot ( num_clusters , inertias , ‘-o’ ) plt . xlabel ( ‘Number of Clusters (k)’ ) plt . ylabel ( ‘Inertia’ ) plt . show ( )

일반적으로 클러스터의 수가 증가할 수록 inertia는 감소하게 됩니다. 궁극적으로 클러스터의 수와 inertia간의 trade-off가 발생하게 됩니다. 우리의 목표는 inertia를 최소화 시키면서 동시에 클러스터의 수를 최소화 시키는 것입니다. 이 때 최적의 클러스터 수를 결정하는 한 가지 방법은 ‘elbow’ 메소드 입니다.

Elbow 메소드란 위 그래프를 사람의 팔로 간주하고, 팔꿈치 부분에 해당하는 클러스터 갯수를 선택하는 것을 말합니다. 즉 inertia가 감소하는 정도가 낮아지는 지점을 찾으면 됩니다. 위 그래프에서는 3 이 가장 최적의 클러스터의 수 라고 말할 수 있습니다.

Review

지금까지 K-Means 클러스터링 알고리즘에 대해서 알아보았습니다. 또한 이 알고리즘을 순수 Python으로 구현하여 내용을 이해한 다음 Scikit-Learn을 사용하여 간결한 코드로 구현해보았습니다. 마지막으로 모델의 성능을 평가하기 위해 cross-tabulation을 만들어 분석하고 최적의 클러스터 수를 결정하는 방법에 대해서도 알아보았습니다. 이번 포스팅에서 배운 내용을 바탕으로 다음의 데이터셋도 활용해보는 시간을 가지면 좋을 것 같습니다.

References

11. K-Means 클러스터링(Clustering, 군집화)에 대해서 알아보자 with Python

이번 포스팅에서는 클러스터링(Clustering, 군집화)의 대표적인 알고리즘 중에 하나로 K-Means 클러스터링에 대해서 알아보려고 한다. 여기서 다루는 내용은 다음과 같다.

1. K-Means 클러스터링(Clustering, 군집화)이란?

2. K-Means 클러스터링(Clustering, 군집화) 알고리즘

3. K-Means 클러스터링(Clustering, 군집화) 장단점

4. K-Means 클러스터링(Clustering, 군집화) 파이썬 구현

본 포스팅에서는 수식을 포함하고 있습니다.

티스토리 피드에서는 수식이 제대로 표시되지 않을 수 있으니

PC 웹 브라우저 또는 모바일 웹 브라우저에서 보시기 바랍니다.

1. K-Means 클러스터링(Clustering, 군집화)이란?

– 정의 –

K-Means 클러스터링은 비지도 학습 알고리즘으로 사전에 클러스터 개수 $k$와 초기값을 입력하면 각 데이터의 그룹을 할당해 나가는 Hard Clustering 알고리즘이다.

이 말의 뜻을 하나씩 살펴보자.

a. K-Means 클러스터링은 비지도 학습이다.

K-Means 클러스터링 알고리즘은 데이터에 라벨(Label)이 없고 데이터의 유사도를 바탕으로 개별 데이터를 그룹에 할당하는(라벨을 만들어내는) 비지도 학습이다.

b. K-Means 클러스터링 알고리즘은 사전에 클러스터 개수와 초기값을 지정해야 한다.

K-Means 클러스터링 알고리즘이 데이터를 보고 자동으로 클러스터 개수를 파악하여 그룹화해주는 것은 아니다. 반드시 클러스터 개수를 지정해줘야 한다.

클러스터 개수를 지정했으면 그 개수만큼의 값을 초기값으로 선정해야 한다. 아래 그림과 같이 클러스터 개수를 3으로 정했다면 초기값도 적절하게 3개값을 정한다. 이때 초기값은 직접 지정해도 되고 랜덤 샘플링을 통하여 지정할 수도 있다.

c. K-Means 클러스터링은 그룹을 할당해 나가는 알고리즘이다.

앞에서 얘기한 초기값은 각 그룹의 초기 중심점이라는 의미이다. 이때 각 중심점은 그룹을 결정하며 개별 데이터는 자기와 가까운 중심점과 같은 그룹으로 할당된다. 이때 한 번에 종료되는 것은 아니고(물론 데이터 형태에 따라 또는 운이 좋으면 한번에 끝날 수 있다) 그룹의 중심점을 업데이트하고 다시 개별 데이터의 그룹을 할당하는 과정을 반복하게 된다.

d. K-Means 클러스터링은 Hard Clustering 알고리즘이다.

Hard Clustering이란 데이터 포인트들의 그룹이 중심에 가까운 점에 무조건적으로 할당하는 군집화라는 뜻이다. 어찌보면 그럴듯하지만 논란이 있다. 왜 그럴까?

아래 2 그림에서 검은점을 빨간 그룹과 파란 그룹 중에서 어느 그룹에 할당해야할지를 생각해보자.

왼쪽의 경우 검은점은 빨간 그룹이라고 아주 강하게 말할 수 있을 것이다. 따라서 검은점을 빨간 그룹에 할당시키는 것이 당연할 것이다. 하지만 오른쪽의 경우는 어떤가? 빨간쪽에 가깝다고 하지만 파란쪽 중심으로 부터 생성된 데이터가 아니라고 하기엔 무리가 있다. 이때에는 검은점이 빨간쪽에서 60%, 파란쪽에서 40%정도의 가능성을 갖고 나왔다고 얘기하는 것이 더 합리적일 것이다. 하지만 K-Means 클러스터링은 이러한 가능성은 생각하지 않고 무조건 가까운 쪽으로 그룹을 할당하는 Hard Clustering 알고리즘이다.

– 궁금 사항 –

여기서 궁금한 사항이 생길 수 있다.

클러스터 개수는 어떻게 정하면 좋을까?

클러스터링이 얼마나 잘되었는지를 정량화한 지표를 이용한다. 그러고 나서 클러스터 개수 후보를 정하고 각 클러스터 개수에 대하여 클러스터링을 수행한 뒤 지표를 계산한다.

이때 지표값을 최적화하는 클러스터링 개수를 최적 클러스터 개수로 선정한다.

자주 활용되는 지표로 Dunn Index, 실루엣(Silhouette) Index 등이 있는데 이에 대해선 다음 포스팅에서 소개하겠다.

반응형

2. K-Means 클러스터링 (Clustering, 군집화) 알고리즘

이번엔 K-Means 클러스터링(군집화) 알고리즘은 다음과 같다.

K-Means 클러스터링 알고리즘

(1) 클러스터 개수 $K$, $\epsilon > 0$ 그리고 최대 반복수 $L$을 설정한다.

(2) 초기값(초기 중심값) $\mu_j^{(0)}, j=1, \ldots, K$을 계산한다. 초기값은 직접 설정해주거나 데이터 포인트에서 클러스터 개수만큼 비 복원 추출할 수도 있다.

(3) $t$번째 스텝에서의 중심값을 $\mu_j^{(t)}, j=1, \ldots, K$라 하자. 이제 개별 데이터에 그룹을 할당한다. 이때 개별 데이터와 각 중심값과의 거리를 계산하고 최소 거리를 갖는 중심값을 그룹으로 정한다. 이때 거리는 유클리디안 거리(Euclidean Distance)를 사용한다. 즉,

$$ \DeclareMathOperator*{\argminA}{argmin} k = \argminA_{j=1, \ldots, K}\|x_n-\mu_j^{(t)} \|$$라 한다면 개별 데이터 $x_n$의 그룹은 $k$가 되는 것이다.

(4) 중심값을 업데이트한다. $r_{nk}$를 $x_n$의 그룹이 $k$라면 1, 아닌 경우 0의 값을 갖는다고 하자. 이때 $t+1$번째 중심값은 다음과 같이 업데이트된다.

$$\mu_k^{(t+1)} = \frac{\sum_{i=1}^nr_{ik}x_i}{\sum_{i=1}^nr_{ik}}$$

위식은 결국 각 그룹에서의 평균값을 다음 스텝의 중심값으로 업데이트됨을 의미한다.

(5) 만약 $t>L$ 또는 $\|\mu_k^{(t+1)}-\mu_k^{(t)} \|<\epsilon$이면 알고리즘을 종료하고 아닌 경우에는 (3)으로 돌아간다. 3. K-Means 클러스터링 (Clustering, 군집화) 알고리즘의 장단점 - 장점 - (1) 직관적이고 구현이 쉽다. 알고리즘이 돌아가는 과정이 직관적이고 이해가 쉽다. (2) 구현이 굉장히 쉽다. 알고리즘이 단순하여 구현하기가 쉽다. (3) 대용량 데이터에 적용 가능하다. 복잡한 계산이 필요하지 않아 대용량 데이터에도 적용 가능하다. (4) 수렴성이 보장된다. K-Means 알고리즘은 수렴성이 보장된다. - 단점 - (1) 초기값에 민감하다. 초기값에 따라서 결과가 매우 달라질 수 있다. (2) 이상치에 영향을 받는다. 거리를 Euclidean Distance를 기반으로 하기 때문에 중심값을 업데이트하는 과정에서 이상치에 영향을 받을 수 있다. (3) 그룹 내 분산 구조를 반영할 수 없다. 거리를 Euclidean Distance를 기반으로 하기 때문에 그룹 내 분산 구조를 제대로 반영할 수 없다. 아래 왼쪽 그림은 세개의 분산 구조를 갖는 클러스터를 나타낸 것이다. 우리가 원하는 것은 이러한 분산 구조를 반영한 타원 형태의 클러스터링(군집화) 결과이다. 하지만 K-Means를 실제로 돌려보면 Euclidean Distance의 영향으로 타원 구조가 아닌 원형 구조의 클러스터링 결과를 얻게 된다. (4) 차원의 저주에 걸릴 수 있다. 고차원으로 갈수록 개별 데이터 간 거리가 가까워져 클러스터링 효과가 없을 수 있다. 이는 군집간에는 거리를 최대한 떨어뜨려놔야 클러스터링을 하는 의미가 있는데 고차원으로 갈 수록 개별 데이터간 거리가 가까워져 이러한 효과를 볼 수 없다는 뜻이다. (5) 클러스터의 개수를 정해야 한다. K-Means 클러스터링은 클러스터 개수를 자동으로 잡아주지 않고 사전에 정해줘야 한다. 하지만 Dunn Index, 실루엣(Silhouette) Index과 같은 지표를 이용하여 최적 클러스터 개수를 정할 수 있다. (6) 범주형 변수가 있다면 K-Means 클러스터링을 할 수 없다. K-Means 클러스터링(군집화) 알고리즘은 Euclidean Distance를 사용하기 때문에 범주형 변수가 있다면 적용할 수 없다. 이때에는 K-Means 클러스터링(군집화) 알고리즘을 확장한 K-Modes Clustering 알고리즘을 이용하면 클러스터링(군집화)가 가능하다고 한다. 이와 관련된 내용도 추후에 포스팅 해봐야겠다. 반응형 4. K-Means 클러스터링(Clustering, 군집 분석) 파이썬 구현 먼저 샘플용 데이터를 만들어보자. import numpy as np import random import matplotlib.pyplot as plt np.random.seed(100) num_data = 50 x11 = np.linspace(0.3,0.7,20) x12 = np.linspace(1.3,1.8,15) x13 = np.linspace(2.4,3,15) x1 = np.concatenate((x11,x12,x13),axis=None) error = np.random.normal(1,0.5,num_data) x2 = 1.5*x1+2+error fig = plt.figure(figsize=(7,7)) fig.set_facecolor('white') plt.scatter(x1, x2, color='k') plt.show() 샘플 데이터 딱 봐도 그룹이 3개로 나뉘는 데이터이다. 1) 직접 구현 클러스터링(군집화) 알고리즘을 직접 구현해보자. 아래 코드가 K-Means 클러스터링을 수행하는 함수이다. 이 함수는 데이터(X), 클러스터 개수(n_clusters), 초기 중심값(init_center), 최대 반복수(max_iter). 오차한계(epsilon) 마지막으로 random_state를 인자로 받는다. 이 함수는 초기 중심값을 세팅하고 각 스텝마다 라벨과 중심값을 업데이트한다. 최대 반복수만큼 반복되었거나 이전 스텝의 중심값과 다음 스텝 중심값의 차이가 오차 한계보다 작다면 알고리즘은 종료되며 최종 라벨(labels), 반복 스텝 수(iteration), 라벨 업데이트 과정(labels_history), 중심값 업데이트 과정(center_history)을 출력한다. def kmeans_clustering(X, n_clusters, init_center=None, max_iter=10, epsilon=1e-4, random_state=100): # inititalize centeroids if init_center is None: random.seed(random_state) idx = random.sample(range(X.shape[0]), n_clusters) center = X[idx,:] else: center = init_center iteration = 1 labels_history = [] # label history center_history = [] # centeroid history while(iteration<=max_iter): ## assign label labels = [] for i in range(X.shape[0]): data = X[i, :] labels.append(np.argmin([np.linalg.norm(data-x) for x in center])) labels = np.array(labels) ## update centeroids next_center = [] for i in range(n_clusters): target_idx = np.where(labels==i)[0] center_val = np.mean(X[target_idx,:], axis=0) next_center.append(center_val) next_center = np.array(next_center) if epsilon: if np.linalg.norm(next_center-center) <= epsilon: break center = next_center labels_history.append(labels) center_history.append(center) iteration += 1 return (labels, iteration, labels_history, center_history) 이제 이 함수를 이용하여 K-Means 클러스터링을 수행해보자. 클러스터 개수를 3개로 설정하고 초기 중심값을 지정해주었다. X = np.stack([x1, x2], axis=1) init_center= np.array([[2,4],[1,5],[2.5,6]]) max_iter=50 epsilon=1e-10 random_state=101 n_clusters=3 results = kmeans_clustering(X, n_clusters, init_center, max_iter, epsilon=1e-4, random_state=100) labels = results[0] 이제 군집화가 잘되었는지 확인해보자. fig = plt.figure(figsize=(7,7)) fig.set_facecolor('white') for i, label in enumerate(labels): if label == 0: color = 'blue' elif label ==1: color = 'red' else: color = 'green' plt.scatter(X[i,0],X[i,1], color=color) plt.xlabel('x1') plt.ylabel('x2') plt.show() K-Means 클러스터링 결과 클러스터링(군집화)이 아주 잘되었다. 이번엔 업데이트 진행과정을 살펴보자. labels_history = results[2] for j, labels in enumerate(labels_history): fig = plt.figure(figsize=(7,7)) fig.set_facecolor('white') for i, label in enumerate(labels): if label == 0: color = 'blue' elif label ==1: color = 'red' else: color = 'green' plt.scatter(X[i,0],X[i,1], color=color) plt.title(f'Iteration : {j+1}') plt.xlabel('x1') plt.ylabel('x2') plt.show() K-Means 클러스터링 업데이트 과정 알고리즘 4 스텝만에 클러스터링이 완료된 것을 알 수 있다. 2) Scikit-Learn 이용 이번에는 Scikit-Learn 패키지를 이용하여 K-Means 클러스터링을 해보자. Scikit-Learn에서는 KMeans 클래스를 이용하여 클러스터링(군집화)을 수행한다. 이때 n_clusters는 3, init에는 초기 중심값 init_center를 넣고 KMeans 인스턴스를 생성한다. 그러고 나서 fit 함수에 클러스터링(군집화)하려고 하는 데이터(X)를 넣어주면 클러스터링(군집화)이 수행된다. 그리고 최종 라벨은 labels_ 필드를 이용하여 얻을 수 있다. import warnings warnings.filterwarnings('ignore') from sklearn.cluster import KMeans kmeans = KMeans(n_clusters=3, init=init_center) kmeans.fit(X) labels = kmeans.labels_ 클러스터링(군집화)를 시각화해보자. fig = plt.figure(figsize=(7,7)) fig.set_facecolor('white') for i, label in enumerate(labels): if label == 0: color = 'blue' elif label ==1: color = 'red' else: color = 'green' plt.scatter(X[i,0],X[i,1], color=color) plt.xlabel('x1') plt.ylabel('x2') plt.show() Scikit-Learn을 이용한 K-Means 클러스터링 결과 이번 포스팅에서는 클러스터링(군집화)의 대표적인 알고리즘 K-Means 클러스터링을 알아보았다. 다음 포스팅에서는 클러스터링이 잘되었는지를 정량적으로 알아볼 수 있는 여러가지 지표들에 대해서 알아보려고 한다. 참고자료 문일철 - 인공지능 및 기계학습 개론2

Python을 활용한 K-means Clustering

728×90

반응형

클러스터링은 비지도 학습기법으로 유사한 유형의 데이터를 그룹화함으로써 숨겨진 구조를 파악합니다.

클러스터링을 활용하면 추천 엔진, 검색 엔진, 시장 세분화 등을 구현할 수 있습니다.

K-means Clustering이란?

“K”는 주어진 데이터를 그룹화할 수 즉, 클러스터 개수를 말합니다. “Means”는 각 클러스터의 중심과 데이터들의 평균 거리를 의미합니다. 이 때, 클러스터의 중심을 centroids라고 합니다.

K-means 알고리즘은 다음과 같은 과정을 수행합니다.

1. 데이터셋에서 K개의 centroids를 임의로 지정.

2. 각 데이터들을 가장 가까운 centroids와 같은 그룹으로 할당.

3. 2번 과정에서 할당된 결과로 centroids를 다시 지정.

4. 2~3번 과정을 반복하면서 centroids가 더 이상 변하지 않을 때까지 반복.

출처: https://i.imgur.com/WL1tIZ4.gif

위와 같은 과정을 통해 데이터의 군집화가 이뤄집니다. 이번에는 Python으로 직접 알고리즘을 구현한 후, sklearn을 활용해 구현해보겠습니다. (프로젝트에서 진행했던 영화 장르 데이터를 기준으로 했습니다.)

직접 구현하는 K-Means Clustering

1. Centroids 지정하기

영화별 장르 데이터

영화의 장르만을 기준으로 군집을 형성해주기 위해 장르 도메인과 영화명을 컬럼으로 잡았습니다. 이제 numpy를 활용한 centroids를 임의로 지정합니다.

import numpy as np k = 3 # 랜덤으로 x, y 좌표 3개를 생성합니다 # np.random.uniform은 주어진 최소, 최대값 사이에서 k 개 만큼 실수 난수를 생성합니다. centroids = np.random.uniform(1, maxMovieCnt, k)

2. 데이터들을 가장 가까운 centroid로 할당하기

각 데이터를 벡터로 간주하여 유클리드 거리를 계산해 가까운지를 판단합니다.

# 영화별 모든 장르 고려 def distance(centroid_movie, movie): return sum([(genre1 – genre2)**2 for genre1, genre2 in list(zip(centroid_movie, movie))]) ** 0.5

이제 각 데이터들 별로 3개의 centroids와의 거리를 측정합니다. 이때 labels이란 배열을 생성해, 가장 가까운 centrodis의 index를 저장합니다.

# 각 데이터 포인트를 그룹화 할 labels을 생성합니다 (0, 1, 또는 2) labels = np.zeros(len(movies)) # 각 데이터를 순회하면서 centroids와의 거리를 측정합니다 for i in range(len(movies)): distances = np.zeros(k) # 초기 거리는 모두 0으로 초기화 해줍니다 for j in range(k): distances[j] = distance(centroids[j][0:17], movies[i][0:17]) cluster = np.argmin(distances) # np.argmin은 가장 작은 값의 index를 반환합니다 labels[i] = cluster

이렇게 생성한 labels에는 0~2가 저장되어 각 데이터가 어느 centroid에 속하는지 나타나게 됩니다.

3. Update Centroids

이제 centroids를 새로 지정해서 데이터의 그룹화를 개선시킵니다. 기존에 지정한 centroids를 deep copy를 활용해centroids_old에 저장합니다.

from copy import deepcopy centroids_old = deepcopy(centroids)

2번 결과에서 각 군집별로 centrorids를 다시 계산합니다.

for i in range(k): # 각 그룹에 속한 데이터들만 골라 points에 저장합니다 points = [movies[j][0:17] for j in range(len(movies)) if labels[j] == i] # points의 각 feature, 즉 각 좌표의 평균 지점을 centroid로 지정합니다 centroids[i] = np.mean(points, axis=0)

4. Repeat step 2~3 until Convergence

이제 앞서 말한 것처럼 centroids가 더 이상 변하지 않을 때까지 반복합니다. 이를 error라는 배열을 생성해 centroids_old와 새롭게 지정된 centroids의 거리를 저장합니다. 만약, 이 거리가 모두 0이되면 최적해에 수렴한 것으로 판단하고 반복을 종료합니다.

# 제일 처음 centroids_old는 0으로 초기화 해줍니다. centroids_old = np.zeros(centroids.shape) labels = np.zeros(len(movies)) # error 도 초기화 해줍니다 error = np.zeros(k) for i in range(k): error[i] = distance(centroids_old[i], centroids[i]) # STEP 4: error가 0에 수렴할 때 까지 2 ~ 3 단계를 반복합니다 while(error.all() != 0): for i in range(len(movies)): distances = np.zeros(k) for j in range(k): distances[j] = distance(centroids[j][0:17], movies[j][0:17]) cluster = np.argmin(distances) labels[i] = cluster centroids_old = deepcopy(centroids) for i in range(k): points = [ movies[j][0:17] for j in range(len(movies)) if labels[j] == i ] centroids[i] = np.mean(points, axis=0) # 새롭게 centroids를 업데이트 했으니 error를 다시 계산합니다 for i in range(k): error[i] = centroids_old[i] – centroids[i]

Scikit-Learn으로 구현하는 K-Means Clustering

앞에서는 직접 알고리즘을 구현하느라 코드 양이 상당히 많고 복잡했습니다. 하지만 scikit-learn 라이브러리를 활용하면 간편하게 구현할 수 있습니다.

from sklearn.cluster import KMeans k = 3 model = KMeans(n_cluster=k) # K-Means 클러스터링 수행 model.fit(movies) # K-Means 수행 후, 데이터를 군집에 할당 labels = model.predict(movies)

실제 프로젝트에선 아래와 같은 방법을 사용했습니다.

from sklearn.cluster import KMeans # group = pd.read_csv(“./api/fixtures/user_clu.csv”, header=0) # group = group[[“Action”,”Adventure”,”Animation”,”Children’s”, # “Comedy”,”Crime”,”Documentary”,”Drama”,”Fantasy”, # “Film-Noir”,”Horror”,”Musical”,”Mystery”,”Romance”, # “Sci-Fi”,”Thriller”,”War”,”Western”]] group.head() model1 = kmeans(3, group) users_Kmeans = model1.train_cluster()[1]

여기까지 K-Means Clustering 알고리즘에 대한 포스팅을 마치겠습니다. 이외에도 Hierarchical Clustering, EM Clustering, Number of Clusters가 있으나 나중에 다뤄보도록 하겠습니다.

728×90

반응형

[Matlab] K-Means Clustering (K-평균 군집화) 알고리즘 구현하기

반응형

1967년 처음 제안된 K-Means 클러스터링 (K-평균 군집화)은 군집화 알고리즘의 시작을 알린 데이터 마이닝 기법입니다. 파티션을 분리하는 기법 (Partitioning) 으로 분류되는 K-means 는 사전에 부여된 클러스터의 개수와 개체 간의 거리를 기반으로 전체 클러스터의 중심과의 거리를 최소화 하며 군집을 수행합니다. 이번 포스팅에서는 간단하게 K-Means 알고리즘을 살펴본 뒤, 매트랩에서 직접 알고리즘을 구현해보도록 하겠습니다.

1. K-Means 알고리즘의 목표

$n$ 개의 데이터를 가지는 $d$ 차원 데이터 집합 $X=(x_1,x_2,…,x_n)$가 있습니다. 쉽게 예를 들기 위해, $d=2$를 가지는 2차원 공간 데이터로 가정하게되면 그림 1과 같이 표현이 가능합니다.

그림 1. K-Means 알고리즘 예시

데이터 집합 $X$가 주어졌을때, K-Means는 사전에 지정된 클러스터 개수 $k$ 만큼 집합을 만들고 각 집합에 포함된 데이터들끼리의 응집도를 최대로 하는 방식으로 군집을 수행합니다. 여기서 클러스터 개수는 전체 데이터의 개수 $n$ 보다 작게 설정되어야 하며, 전체 클러스터의 집합 $C=(c_1,c_2,…,c_k)$로 표현됩니다.

1. $n$개로 구성된 $d$ 차원의 데이터 집합 $X=(x_1,x_2,…,x_n)$

2. $k(<=n)$개의 지정된 클러스터 개수 3. $C=(c_1,c_2,...,c_k)$로 표현되는 전체 클러스터 집합 이때, 집합 $C$ 군집을 대표하는 중심(Centroid)축을 $u_k$로 정의합니다. 중심축 $u_k$가 K-Measn의 군집 방식 '응집도를 최대로' 하는 방향으로 학습하며 최적화됩니다. 이는 식 1과 같습니다. $$\underset{s}{\operatorname{argmin}} \sum_{i=1}^{k}\sum_{x\in{C_i}}||x-u_i||^2$$ 응집도의 최대화하는 것은 공간적으로 같은 군집끼리의 거리를 최소화하는것이 됩니다. 즉, K-Means 알고리즘의 핵심은 전체 군집 개수 $k$까지 집합 $C_i$에 포함된 데이터 $x$와 $C_i$를 대표하는 중심축 $u_i$의 거리를 최소화하는 문제입니다. 2. K-Means 알고리즘 1. $u_k$ 초기화 : 초기 Centroid 값을 선정하기 위해 집합 $X$ 에서 임의로 값을 선정합니다. 2. 응집도 연산 : 모든 데이터에 대하여 초기화된 $u_k$와 거리를 구합니다. 이후, 가장 인접한 Centroid 값을 가지는 클러스터 집합 $C$의 원소로 입력합니다. 3. 군집 업데이트 : 모든 데이터가 $C$의 원소로 선택되었다면, 이를 바탕으로 $C$의 중심축 $u_k$를 수정합니다. 일반적인 K-Means는 이 과정에서 집합 내 원소의 평균값으로 갱신됩니다. 4. 원하는 학습 횟수 또는 목적 함수가 최적화될때까지 2~3의 과정을 반복합니다. 3. Matlab 코드 0. 샘플 코드 다운로드 git clone https://github.com/DEEPI-LAB/k-means-implementation-in-matlab.git 매트랩 코드와 2차원 데이터 샘플을 포함하고 있는 예제입니다. 아래 경로를 통해서도 직접 다운로드가 가능합니다. github.com/DEEPI-LAB/k-means-implementation-in-matlab 1. 학습 파라미터 초기화 load corner.mat # 2차원 공간 데이터 X = X; # 클러스터 개수 k = 4; # 클러스터 위치 초기화 인덱스 선정 rand = randperm(length(X),k); # 초기 Centroid 값 u = X(rand ,:); # 학습 횟수 z = 10; 가장 기본적인 클러스터 데이터 중 하나인 2차원 공간 데이터를 함께 첨부하였습니다. K-Means 알고리즘 초기화 단계입니다. $u_k$를 초기화하기 위해 임의로 입력 데이터 $X$의 원소를 선정합니다. 2. 응집도 연산 # 학습 시작 for z=1:10 # 최대값 저장메모리 할당 C = cell(k,1); for j=1:length(X) # 거리 구하기 for i =1:k dist(i,1) = norm(X(j,:)-u(i,:)); end # 중심점과 가장 유사도가 높은 데이터를 중심점 클러스터로 할당 arg = find(dist==min(dist)); C{arg}(end+1,:) = X(j,:); end 학습이 반복될때마다 클러스터 집합 $C$가 갱신될 수 있도록 초기화해줍니다. 이후, 모든 데이터 $X$를 스캔하면서 $c_k$와의 거리를 구한 뒤, 가장 인접함 Centorid 값을 가지는 집합 $C$의 원소로 설정합니다. 3. 업데이트 for i = 1:k # 군집된 클러스터 원소 cluster = C{i}; # 전체 평균값 cluster = sum(cluster) ./ sum(cluster~=0,1); try u(i,:) = cluster; end end end 한번 반복이 완료되면, 를 바탕으로 $C$의 중심축 $u_k$를 원소의 평균을 통해 수정하게 됩니다. 4. 최종코드 # ********************************************* # Unsupervised Learning - K-Means algorithm # Deep.I Inc. # ********************************************* load corner.mat # 2차원 공간 데이터 X = X; # 클러스터 개수 k = 4; # 클러스터 위치 초기화 인덱스 선정 rand = randperm(length(X),k); # 초기 Centroid 값 u = X(rand ,:); # 학습 횟수 z = 10; # 학습 시작 for z=1:10 # 최대값 저장메모리 할당 C = cell(k,1); for j=1:length(X) # 거리 구하기 for i =1:k dist(i,1) = norm(X(j,:)-u(i,:)); end # 중심점과 가장 유사도가 높은 데이터를 중심점 클러스터로 할당 arg = find(dist==min(dist)); C{arg}(end+1,:) = X(j,:); end for i = 1:k cluster = C{i}; cluster = sum(cluster) ./ sum(cluster~=0,1); try u(i,:) = cluster; end end # 실시간으로 군집 결과 확인하기 cla; hold on; for i = 1: k cluster = C{i}; try scatter(cluster(:,1),cluster(:,2),'.') scatter(u(:,1),u(:,2),'*r','LineWidth',5) end end pause(2) end 4. 결론 그림 2. 알고리즘 구현 화면 사실 K-Means는 비선형 데이터 군집이나, 군집의 개수를 알지 못하는 경우에는 적용할 수가 없다는 치명적인 단점이 존재합니다. 이밖에도 군집 밀도나 겹침 등의 문제에도 낮은 강인성을 보이고 있죠. 첨부된 군집 데이터 모두 K-Means로는 쉽게 군집되지 않습니다. 이를 해결하기 위해 현대의 클러스터링 기법은 밀도를 이용하거나 그래프 모델, 신경망 등의 다양한 알고리즘으로 군집 문제를 접근하고 있습니다. # 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅 # 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작 # email : [email protected] # site : www.deep-i.net 반응형

K-means clustering Python으로 구현하기

K-means 자체에 대해서 아직 이해가 부족하신 분은 예전 포스팅에 자세히 적은 것이 있기 때문에 이전 포스팅을 먼저 보면 될 것 같으며 아래 링크를 확인하면 된다.

K-means를 알고 계신 분들에게 다시 한번 간단히 상기시키면 다음과 같은 순서로 클러스터링이 작동된다.

중심점인 K를 지정한 후, 이 값은 무작위의 좌표값으로 시작된다. 데이터 요소들과 무작위의 중심점(centroid)간의 거리를 계산한다. 다른 거리 측정 알고리즘을 사용해도 상관 없지만 일반적으로는 유클리드 거리를 사용하며 계산한다. 데이터 요소들을 가장 가까운 중심점에 속하게 만든다. 중심점은 자신들이 속한 데이터 요소들의 중심으로 이동한다. 2~4의 작업을 반복하며, 더이상 K 중심점들이 이동하지 않을 경우 알고리즘을 종료한다.

K-means는 이렇듯 쉬우면서도 강력한 클러스터링 효과를 보여주기 때문에 비지도학습인 클러스터링 알고리즘 중 상징적인 알고리즘으로 자리잡고 있다.

그럼 이제 sklearn 라이브러리에서 제공하는 kmeans 클러스터링을 실습해보도록 한다.

K-means 클러스터링 예제

라이브러리

import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import make_blobs

샘플 생성

sklearn에서 제공하는 make_blobs으로 샘플을 생성하고, 이 값을 matplotlib의 pyplot에 담는다.

# 랜덤값 고정 np.random.seed(8) X, y = make_blobs(n_samples=1000, centers=4, cluster_std=0.9) plt.scatter(X[:, 0], X[:, 1], marker=’.’)

위 내용의 값을 확인하고 싶으면, plt.show()를 넣어보면 되며, pyplot을 중간에 실행하면 다음과 같은 차트가 보여진다. np.random.seed로 값을 부여한 것은 실습때 동일한 결과를 얻기 위함이며, 랜덤 시드 부분은 삭제해도 무방하다.

make_blobs로 실행한 샘플 데이터들

학습 진행

KMeans을 생성한다. K는 n_clusters이며, 여기서는 4개를 세팅하였다. n_init은 다른 중심 시드로 실행되는 횟수로 12회로 세팅되었다. 추가적인 파라미터가 궁금하면 최하단의 [1] 링크를 확인하면 된다.

k_means = KMeans(init=”k-means++”, n_clusters=4, n_init=12) k_means.fit(X)

학습 결과 확인

fit이 완료되었으면, labels_라는 레이블 결과와 cluster_centers_라는 중심점 값이 만들어진다.

k_means_labels = k_means.labels_ print(‘k_means_labels : ‘, k_means_labels) k_means_cluster_centers = k_means.cluster_centers_ print(‘k_means_cluster_centers : ‘, k_means_cluster_centers)

위 코드의 print 결과

k_means_labels : [0 1 3 2 0 0 3 2 3 2 2 0 0 3 1 3 1 1 0 1 0 0 0 2 3 3 2 0 2 1 3 1 0 1 0 0 0

0 2 2 2 0 0 3 0 2 3 2 3 1 1 3 0 0 2 1 3 2 3 2 3 3 3 3 3 1 2 1 1 1 1 0 1 2

3 3 3 3 1 3 0 0 3 2 1 3 3 1 2 0 0 1 0 1 1 2 3 2 0 3 2 3 1 1 0 2 1 1 2 1 2

2 1 0 1 3 0 3 3 1 3 2 0 2 3 3 0 2 0 1 1 0 3 2 3 1 3 1 2 0 0 0 2 2 3 3 0 0

3 1 1 3 3 2 2 3 0 2 2 1 2 3 0 0 3 3 1 0 1 2 3 3 0 2 0 2 0 1 3 1 3 2 0 3 3

3 0 3 1 2 1 3 2 0 3 2 3 2 3 1 1 2 3 1 1 1 3 3 2 2 3 2 2 1 0 2 0 1 1 2 1 1

0 1 3 2 0 1 0 2 2 2 3 3 0 3 0 2 1 0 3 1 2 2 0 3 3 2 2 1 1 3 1 3 2 2 0 2 3

1 1 3 1 2 3 3 3 3 0 2 0 0 1 3 3 2 1 1 2 3 2 2 1 3 2 2 2 1 2 1 0 2 1 0 3 0

2 1 0 1 1 3 0 2 3 0 2 3 3 2 0 2 3 0 1 2 3 1 3 0 0 3 3 0 0 0 3 1 0 0 2 0 1

1 3 1 3 2 1 2 3 3 0 3 0 0 3 0 2 3 2 1 1 2 3 0 3 1 2 0 0 1 1 3 2 3 3 3 0 3

1 3 0 1 0 1 2 0 3 3 1 1 0 1 2 2 1 0 2 1 1 3 0 0 2 2 3 3 1 3 2 1 0 0 3 3 1

3 2 2 3 0 1 2 0 1 2 3 0 0 1 1 0 1 0 1 2 2 0 0 3 0 2 0 0 2 0 3 3 1 1 3 3 1

2 0 1 2 0 0 1 2 3 1 2 3 2 1 2 1 0 0 1 3 2 0 0 1 1 1 0 2 0 1 1 2 0 3 3 0 3

0 2 1 3 3 3 3 3 2 1 2 3 0 2 2 1 2 0 1 2 3 2 0 3 2 2 3 3 3 1 2 2 2 0 1 2 0

1 0 0 0 3 2 1 1 2 0 3 1 1 0 1 0 0 3 0 2 0 0 0 0 2 3 1 2 2 0 3 1 1 2 3 0 3

0 3 3 0 2 3 0 1 3 0 0 2 1 1 2 3 0 0 0 3 0 0 0 1 1 1 2 1 1 2 2 2 2 2 1 1 2

2 0 3 1 3 0 3 2 2 3 2 1 1 2 3 0 0 3 2 0 0 1 3 2 1 2 2 2 1 0 2 1 0 0 2 1 1

3 2 1 1 2 1 3 1 0 3 0 1 1 3 0 1 1 2 3 1 2 2 3 0 1 1 2 3 0 3 0 2 1 3 2 0 1

0 0 1 2 3 1 2 3 2 3 3 2 1 1 1 2 1 0 0 0 3 1 2 1 0 0 0 0 3 2 0 1 2 0 0 0 0

0 1 0 3 0 3 0 1 2 0 1 2 1 0 0 1 2 1 2 0 1 3 0 0 2 0 3 3 0 1 1 0 3 0 2 2 2

0 2 1 3 3 2 1 3 3 1 3 1 3 1 0 1 0 3 1 1 3 3 2 2 2 3 3 2 3 1 1 0 1 0 2 2 0

0 0 1 3 0 3 0 1 3 2 3 3 2 0 2 0 3 1 1 1 1 0 0 0 2 1 0 2 3 1 3 2 1 2 2 0 2

3 2 2 3 2 3 1 3 3 2 2 2 3 2 3 2 2 1 3 3 2 2 3 2 3 0 2 2 0 1 1 1 3 1 3 2 3

0 1 1 0 0 0 2 1 3 0 2 1 2 3 1 2 2 1 2 1 1 0 0 2 3 3 2 2 1 3 3 0 1 3 1 3 1

2 0 2 0 3 3 1 0 2 0 2 0 0 3 1 2 1 2 1 3 3 3 2 3 0 0 1 3 1 0 0 2 1 2 3 2 1

2 1 0 0 2 1 2 0 1 1 2 0 1 3 0 3 0 1 2 0 0 0 2 3 1 3 1 0 3 3 2 2 2 3 2 3 0

0 3 0 2 0 0 3 1 1 0 3 2 0 0 3 1 2 1 1 1 1 3 2 1 0 2 1 2 3 3 1 3 0 1 1 2 1

2]

k_means_cluster_centers : [[ 7.43677253 0.6966818 ] [ 7.44207714 9.40391707] [-5.35905231 -9.6306923 ] [-1.32469127 -1.9919531 ]]

값을 만들어 냈으면, 이제 시각적으로 확인해 보도록 한다.

K-means Clustering 시각화

# 지정된 크기로 초기화 fig = plt.figure(figsize=(6, 4)) # 레이블 수에 따라 색상 배열 생성, 고유한 색상을 얻기 위해 set(k_means_labels) 설정 colors = plt.cm.Spectral(np.linspace(0, 1, len(set(k_means_labels)))) # plot 생성 ax = fig.add_subplot(1, 1, 1) for k, col in zip(range(4), colors): my_members = (k_means_labels == k) # 중심 정의 cluster_center = k_means_cluster_centers[k] # 중심 그리기 ax.plot(X[my_members, 0], X[my_members, 1], ‘w’, markerfacecolor=col, marker=’.’) ax.plot(cluster_center[0], cluster_center[1], ‘o’, markerfacecolor=col, markeredgecolor=’k’, markersize=6) ax.set_title(‘K-Means’) ax.set_xticks(()) ax.set_yticks(()) plt.show()

최종결과

K-means 시각화 결과

위 내용을 실행하면, make_blob으로 만들어진 pyplot과 레이블로 색깔이 칠해진, 결과 2개의 pyplot이 띄워질 것이며 위 내용은 2번째 레이블이 된 pyplot 결과이다. 이처럼, K-means가 잘 작동 된 것을 확인할 수 있다.

최종 소스

import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import make_blobs # 랜덤값 고정 np.random.seed(8) X, y = make_blobs(n_samples=1000, centers=4, cluster_std=0.9) plt.scatter(X[:, 0], X[:, 1], marker=’.’) k_means = KMeans(init=”k-means++”, n_clusters=4, n_init=12) k_means.fit(X) k_means_labels = k_means.labels_ print(‘k_means_labels : ‘, k_means_labels) k_means_cluster_centers = k_means.cluster_centers_ print(‘k_means_cluster_centers : ‘, k_means_cluster_centers) # 지정된 크기로 초기화 fig = plt.figure(figsize=(6, 4)) # 레이블 수에 따라 색상 배열 생성, 고유한 색상을 얻기 위해 set(k_means_labels) 설정 colors = plt.cm.Spectral(np.linspace(0, 1, len(set(k_means_labels)))) # plot 생성 ax = fig.add_subplot(1, 1, 1) for k, col in zip(range(4), colors): my_members = (k_means_labels == k) # 중심 정의 cluster_center = k_means_cluster_centers[k] # 중심 그리기 ax.plot(X[my_members, 0], X[my_members, 1], ‘w’, markerfacecolor=col, marker=’.’) ax.plot(cluster_center[0], cluster_center[1], ‘o’, markerfacecolor=col, markeredgecolor=’k’, markersize=6) ax.set_title(‘K-Means’) ax.set_xticks(()) ax.set_yticks(()) plt.show()

References

[1] scikit-learn.org -KMeans, https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html

[2] coursera – Machine Learning with Python

연관포스팅

DBSCAN cluster 이해하기

클러스터링(Clustering)을 통한 데이터 분류기법, K-평균(K-Means) 알고리즘

결정 트리(Decision Tree) 설명 및 분류기 구현

KNN(k최근접) 알고리즘 설명 및 구현하기

[Sklearn] K-means 클러스터링 (K-평균 알고리즘) 파이썬 구현 + 시각화, Elbow Method

반응형

이번 글에서는 비지도 학습의 대표적 알고리즘인 K-means Clustering을

파이썬 사이킷런에서 구현해보는 예제를 다루어보겠습니다.

클러스터링 데이터 불러오기

먼저, 데이터를 불러오도록 하겠습니다.

이번 글에서는 kaggle의 Mall Customers Clustering Analysis 데이터 셋을 사용했습니다.

데이터프레임의 생김새는 아래와 같습니다.

저희는 이 중에서 Annual Income 정보와 Spending Score 정보 두 가지만을

이용하여 고객들을 클러스터링 해보도록 하겠습니다.

K-평균 군집화 알고리즘 전처리

먼저, 필요한 column만 골라낸 뒤에

k-means 클러스터링에 필수적인 정규화를 진행해보도록 하겠습니다.

여기서는 각 column의 최소값을 0, 최대값을 1에 매핑한 MinMaxScaler

를 사용하였습니다. (다른 스케일러도 상관 없습니다.)

from sklearn.preprocessing import MinMaxScaler # 두 가지 feature를 대상 data = df[[‘Annual Income (k$)’, ‘Spending Score (1-100)’]] # 정규화 진행 scaler = MinMaxScaler() data_scale = scaler.fit_transform(data)

파이썬 사이킷런 K-means 클러스터링 알고리즘 학습

이제, 파이썬 사이킷런으로 k-means 알고리즘을 학습시켜보도록 하겠습니다.

알고리즘 종류, 최대 iteration 횟수 등을 지정할 수 있는 기능도 Kmeans에서 지원하지만,

여기서는 몇 개의 그룹으로 군집화할지를 고르는 n_cluster(k 지정) 인자와,

K-평균 군집화는 초기 그룹 설정마다 최종 결과가 달라질 수 있어,

실행 시 마다 결과를 같게 만드는 random_state 인자만을 설정하고 학습시켜보겠습니다.

from sklearn.cluster import KMeans k = 3 # 그룹 수, random_state 설정 model = KMeans(n_clusters = k, random_state = 10) # 정규화된 데이터에 학습 model.fit(data_scale) # 클러스터링 결과 각 데이터가 몇 번째 그룹에 속하는지 저장 df[‘cluster’] = model.fit_predict(data_scale)

파이썬 K-means 군집화 결과 시각화

이제 matplotlib 라이브러리를 통하여 군집화 결과를 확인해보도록 하겠습니다.

실제 데이터 분포와 비교해보며, 군집화가 언제 잘 되었는지 확인해보세요.

여기서는 k = 3, 4, 5, 10 인 경우들을 예시로 보여드리겠습니다.

반응형

import matplotlib.pyplot as plt plt.figure(figsize = (8, 8)) for i in range(k): plt.scatter(df.loc[df[‘cluster’] == i, ‘Annual Income (k$)’], df.loc[df[‘cluster’] == i, ‘Spending Score (1-100)’], label = ‘cluster ‘ + str(i)) plt.legend() plt.title(‘K = %d results’%k , size = 15) plt.xlabel(‘Annual Income’, size = 12) plt.ylabel(‘Spending Score’, size = 12) plt.show()

데이터의 분포를 고려하였을 때, k = 5인 경우가 가장 클러스터링이

잘 된 경우라고 볼 수 있을 것 같습니다.

K-means 클러스터링 k 결정(Elbow Method)

위에서는 시각화 결과로 k = 5일 때, 가장 군집화가 깔끔하게 되었다 생각했는데,

더 객관적인 k 결정 방법인 Elbow Method를 구현해보겠습니다.

k를 결정하기 쉽게 도와주는 함수인

from yellowbrick.cluster import KElbowVisualizer

를 불러와서 실행하는 예제를 보여드리겠습니다.

from yellowbrick.cluster import KElbowVisualizer model = KMeans() visualizer = KElbowVisualizer(model, k=(1,10)) visualizer.fit(data_scale)

k = 1 ~ 10까지 테스트한 경우이고,

데이터는 위에서 사용했던 정규화된 data_scale 변수를 넣으시면 됩니다.

결과는 다음과 같이 나왔는데, 파란색이 각 데이터들의 군집 중심과의 평균 거리

초록색은 학습 시간을 나타낸다고 합니다.

검정색 점선의 위치를 보았을 떄, 여기서는 k = 4인 경우를 추천해주는 듯 합니다.

절대적인 정답이 있는 것은 아니니, 하나의 평가 지표로 활용하시면 좋을 듯 합니다.

반응형

키워드에 대한 정보 k-means 알고리즘 구현

다음은 Bing에서 k-means 알고리즘 구현 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.

이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!

사람들이 주제에 대해 자주 검색하는 키워드 kmean 클러스터링 알고리즘 및 파이썬 실습

• kmean
• k-mean
• 클러스터링
• 케이민
• 케이민++
• 비지도학습
• 비지도 학습
• unsupervised learning
• 머신러닝
• 데이터 과학
• 데이터과학
• kmean 클러스터링
• k-mean 클러스터링
• 언수퍼바이즈드 러닝

kmean #클러스터링 #알고리즘 #및 #파이썬 #실습

---

YouTube에서 k-means 알고리즘 구현 주제의 다른 동영상 보기

주제에 대한 기사를 시청해 주셔서 감사합니다 kmean 클러스터링 알고리즘 및 파이썬 실습 | k-means 알고리즘 구현, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.