개요
K- 평균 군집 데이터 인스턴스 간의 유사성을 기반으로 데이터 클러스터를 형성하는 가장 널리 사용되는 비지도 머신 러닝 알고리즘 중 하나입니다.
이 가이드에서는 Scikit-Learn을 사용하여 구현하기 전에 K-Means 알고리즘이 어떻게 작동하는지 이해하기 위해 먼저 간단한 예를 살펴보겠습니다. 그런 다음 K-Means에서 클러스터(K)의 수를 결정하는 방법과 거리 메트릭, 분산 및 K-Means 장단점을 다룹니다.
자극
다음 상황을 상상해보십시오. 어느 날 동네를 걷다 10개의 편의점이 있는 것을 보고 어떤 가게가 비슷한지 궁금해지기 시작했습니다. 그 질문에 답할 방법을 찾는 동안 지도 상의 좌표를 기반으로 상점을 그룹으로 나누는 흥미로운 접근 방식을 발견했습니다.
예를 들어 한 상점이 서쪽으로 5km, 북쪽으로 3km에 있는 경우 (5, 3) 좌표를 지정하고 그래프로 나타냅니다. 무슨 일이 일어나고 있는지 시각화하기 위해 이 첫 번째 지점을 플로팅해 보겠습니다.
import matplotlib.pyplot as plt
plt.title("Store With Coordinates (5, 3)")
plt.scatter(x=5, y=3)
이것은 첫 번째 요점일 뿐이므로 상점을 표현하는 방법에 대한 아이디어를 얻을 수 있습니다. 수집된 10개 상점에 대한 10개의 좌표가 이미 있다고 가정합니다. 그것들을 정리한 후 numpy 배열의 위치를 플로팅할 수도 있습니다.
import numpy as np
points = np.array([[5, 3], [10, 15], [15, 12], [24, 10], [30, 45], [85, 70], [71, 80], [60, 78], [55, 52],[80, 91]])
xs = points[:,0]
ys = points[:,1]
plt.title("10 Stores Coordinates")
plt.scatter(x=xs, y=ys)
K-평균 알고리즘을 수동으로 구현하는 방법
이제 우리는 그래프에서 10개의 상점을 볼 수 있습니다. 주요 문제는 그들이 근접성을 기반으로 다른 그룹으로 나눌 수 있는 방법이 있는지 찾는 것입니다. 그래프를 간단히 살펴보면 다음과 같이 알 수 있습니다. 두 그룹의 상점 – 하나는 왼쪽 하단의 아래쪽 포인트이고 다른 하나는 오른쪽 상단 포인트입니다. 아마도 우리는 중간에 있는 두 점을 별도의 그룹으로 구분할 수도 있습니다. 세 개의 다른 그룹.
이 섹션에서는 수동으로 포인트를 클러스터링하는 프로세스를 살펴보겠습니다. 포인트를 주어진 수의 그룹으로 나누는 것입니다. 그렇게 하면 기본적으로 모든 단계를 주의 깊게 살펴보고 K-평균 클러스터링 알고리즘. 이 섹션이 끝나면 K-평균 클러스터링 중에 수행되는 모든 단계에 대해 직관적이고 실용적인 이해를 얻을 수 있습니다. 그 후에 우리는 그것을 Scikit-Learn에 위임할 것입니다.
점 그룹이 두 개인지 세 개인지 판단하는 가장 좋은 방법은 무엇입니까? 한 가지 간단한 방법은 하나의 그룹 수(예: 두 개)를 선택한 다음 해당 선택에 따라 포인트를 그룹화하는 것입니다.
우리가 거기에 결정했다고 가정 해 봅시다. 두 그룹 우리 가게의 (포인트). 이제 어떤 점이 어떤 그룹에 속하는지 이해하는 방법을 찾아야 합니다. 이것은 나타낼 하나의 점을 선택하여 수행할 수 있습니다. 1 그룹 그리고 대표할 하나 2 그룹. 그 포인트는 다른 모든 포인트에서 각 그룹까지의 거리를 측정할 때 참조로 사용됩니다.
그런 식으로 요점을 말하십시오. (5, 3) 그룹 1에 속하고 포인트 (79, 60) 그룹 2에 새로운 포인트를 할당하려고 할 때 (6, 3) 그룹에 대해서는 두 점까지의 거리를 측정해야 합니다. 점의 경우 (6, 3) is 자세히 ~로 (5, 3), 따라서 해당 점으로 표시되는 그룹에 속합니다. 1 그룹. 이런 식으로 모든 점을 해당 그룹으로 쉽게 그룹화할 수 있습니다.
이 예에서는 그룹 수를 결정하는 것 외에도(클러스터) – 우리는 또한 일부 포인트를 선택하고 있습니다. 참고 각 그룹의 새 점에 대한 거리.
그것이 우리 매장 간의 유사점을 이해하는 일반적인 아이디어입니다. 실제로 적용해 보겠습니다. 먼저 다음 위치에서 두 개의 기준점을 선택할 수 있습니다. 닥치는대로의. 의 기준점 1 그룹 될거야 (5, 3) 그리고 기준점 2 그룹 될거야 (10, 15). 우리는 우리의 두 지점을 모두 선택할 수 있습니다 numpy 배열 [0] 및 [1] 색인을 생성하고 저장합니다. g1 (그룹 1) 및 g2 (그룹 2) 변수:
g1 = points[0]
g2 = points[1]
이 작업을 수행한 후 다른 모든 점에서 해당 기준점까지의 거리를 계산해야 합니다. 이것은 중요한 질문을 제기합니다. 그 거리를 측정하는 방법입니다. 기본적으로 모든 거리 측정을 사용할 수 있지만 이 가이드의 목적을 위해 Euclidean Distance_를 사용하겠습니다.
유클리드 거리 측정이 피타고라스의 정리를 기반으로 한다는 것을 아는 것이 유용할 수 있습니다.
$$
c^2 = a^2 + b^2
$$
평면의 점에 적응할 때 – (a1, b1) 및 (a2, b2), 이전 공식은 다음과 같습니다.
$$
c^2 = (a2-a1)^2 + (b2-b1)^2
$$
거리는 제곱근이 됩니다. c, 그래서 우리는 다음과 같이 공식을 쓸 수도 있습니다:
$$
유클리드_{거리} = 제곱근[2][(a2 – a1)^2 + (b2 – b1) ^2)]
$$
참고 : 다차원 점에 대한 유클리드 거리 공식을 일반화할 수도 있습니다. 예를 들어, XNUMX차원 공간에서 점에는 세 개의 좌표가 있습니다. 이 공식은 다음과 같은 방식으로 이를 반영합니다.
$$
유클리드_{거리} = 제곱근[2][(a2 – a1)^2 + (b2 – b1) ^2 + (c2 – c1) ^2)]
$$
우리가 운영하는 공간의 차원 수에 관계없이 동일한 원칙을 따릅니다.
지금까지 그룹을 나타내는 점을 선택했으며 거리를 계산하는 방법을 알고 있습니다. 이제 수집된 각 상점 포인트를 그룹에 할당하여 거리와 그룹을 함께 보겠습니다.
더 잘 시각화하기 위해 세 개의 목록을 선언합니다. 첫 번째 그룹의 포인트를 저장하는 첫 번째 그룹 - points_in_g1. 그룹 2의 포인트를 저장하는 두 번째 항목 – points_in_g2, 그리고 마지막 - group에 상표 포인트 1 (그룹 1에 속함) 또는 2 (그룹 2에 속함):
points_in_g1 = []
points_in_g2 = []
group = []
이제 포인트를 반복하고 포인트와 각 그룹 참조 간의 유클리드 거리를 계산할 수 있습니다. 각 포인트는 자세히 두 그룹 중 하나에 – 가장 가까운 그룹을 기반으로 각 포인트를 해당 목록에 할당하고 1 or 2 ~로 group 명부:
for p in points:
x1, y1 = p[0], p[1]
euclidean_distance_g1 = np.sqrt((g1[0] - x1)**2 + (g1[1] - y1)**2)
euclidean_distance_g2 = np.sqrt((g2[0] - x1)**2 + (g2[1] - y1)**2)
if euclidean_distance_g1 < euclidean_distance_g2:
points_in_g1.append(p)
group.append('1')
else:
points_in_g2.append(p)
group.append('2')
이 반복의 결과를 보고 무슨 일이 일어났는지 살펴봅시다.
print(f'points_in_g1:{points_in_g1}n
npoints_in_g2:{points_in_g2}n
ngroup:{group}')
결과 :
points_in_g1:[array([5, 3])]
points_in_g2:[array([10, 15]), array([15, 12]),
array([24, 10]), array([30, 45]),
array([85, 70]), array([71, 80]),
array([60, 78]), array([55, 52]),
array([80, 91])]
group:[1, 2, 2, 2, 2, 2, 2, 2, 2, 2]
Seaborn을 사용하여 할당된 그룹에 따라 다른 색상으로 클러스터링 결과를 플롯할 수도 있습니다. scatterplot() 와 더불어 group 등 hue 논의:
import seaborn as sns
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)
첫 번째 포인트만 그룹 1에 할당되고 다른 모든 포인트는 그룹 2에 할당되었음을 분명히 알 수 있습니다. 그 결과는 처음에 상상했던 것과 다릅니다. 결과와 초기 기대치의 차이를 고려할 때 이를 변경할 수 있는 방법이 있습니까? 있는 것 같습니다!
한 가지 접근 방식은 프로세스를 반복하고 그룹의 참조가 될 다른 지점을 선택하는 것입니다. 이것은 우리가 처음에 구상한 바에 따라 결과를 변경시킬 것입니다. 두 번째로 이전에 했던 것처럼 무작위가 아니라 평균 이미 그룹화된 모든 포인트 중 그렇게 하면 해당 그룹의 중간에 새 포인트를 배치할 수 있습니다.
예를 들어 두 번째 그룹에 포인트만 있는 경우 (10, 15), (30, 45). 새로운 중심적인 포인트는 (10 + 30)/2 및 (15+45)/2 - 와 같음 (20, 30).
결과를 목록에 넣었으므로 먼저 다음으로 변환할 수 있습니다. numpy 배열의 xs, ys를 선택한 다음 평균:
g1_center = [np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()]
g2_center = [np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()]
g1_center, g2_center
조언: 사용하려고 시도하십시오. numpy 및 NumPy 배열을 최대한 많이 사용합니다. 더 나은 성능을 위해 최적화되었으며 많은 선형 대수 연산을 단순화합니다. 선형 대수 문제를 풀려고 할 때마다 반드시 다음을 살펴보아야 합니다. numpy 있는지 확인하는 문서 numpy 당신의 문제를 해결하기 위해 고안된 방법. 기회가 있다는 것입니다!
새로운 중심점으로 프로세스를 반복하는 데 도움이 되도록 이전 코드를 함수로 변환하고 실행하여 점이 그룹화되는 방식에 변경 사항이 있는지 확인합니다.
def assigns_points_to_two_groups(g1_center, g2_center):
points_in_g1 = []
points_in_g2 = []
group = []
for p in points:
x1, y1 = p[0], p[1]
euclidean_distance_g1 = np.sqrt((g1_center[0] - x1)**2 + (g1_center[1] - y1)**2)
euclidean_distance_g2 = np.sqrt((g2_center[0] - x1)**2 + (g2_center[1] - y1)**2)
if euclidean_distance_g1 < euclidean_distance_g2:
points_in_g1.append(p)
group.append(1)
else:
points_in_g2.append(p)
group.append(2)
return points_in_g1, points_in_g2, group
참고 : 동일한 코드를 계속해서 반복하는 것을 발견하면 해당 코드를 별도의 함수로 래핑해야 합니다. 특히 테스트를 용이하게 하기 때문에 코드를 함수로 구성하는 것이 모범 사례로 간주됩니다. 기능이 없는 전체 코드보다 코드 조각을 테스트하고 격리하는 것이 더 쉽습니다.
함수를 호출하고 결과를 저장합시다. points_in_g1, points_in_g2및 group 변수:
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
points_in_g1, points_in_g2, group
또한 그룹 분할을 시각화하기 위해 색상이 지정된 점으로 산점도를 플로팅합니다.
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)
우리 포인트의 클러스터링은 점점 좋아지다.. 그러나 여전히 두 그룹에 대한 근접성을 고려할 때 두 그룹에 할당할 수 있는 두 개의 점이 그래프 중간에 있습니다. 지금까지 개발한 알고리즘은 두 점을 두 번째 그룹에 할당합니다.
이것은 우리가 X와 Y의 수단을 취하여 두 개의 새로운 중심점을 만들어 프로세스를 한 번 더 반복할 수 있음을 의미합니다. (중심) 그룹에 할당하고 거리에 따라 다시 할당합니다.
중심을 업데이트하는 함수도 만들어 보겠습니다. 이제 전체 프로세스를 해당 함수의 여러 호출로 줄일 수 있습니다.
def updates_centroids(points_in_g1, points_in_g2):
g1_center = np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()
g2_center = np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()
return g1_center, g2_center
g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)
이 세 번째 반복 후에 각 점은 이제 서로 다른 클러스터에 속합니다. 결과가 좋아지고 있는 것 같습니다. 다시 한 번 해보겠습니다. 이제 로 간다 네 번째 반복 우리 방법의:
g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)
이번 네 번째로 얻은 같은 결과 이전 것과 같이. 따라서 우리의 포인트는 더 이상 그룹을 변경하지 않을 것 같습니다. 우리의 결과는 일종의 안정성에 도달했습니다. 변경 불가능한 상태가 되거나 수렴. 그 외에도 우리는 두 그룹에 대해 상상했던 것과 정확히 동일한 결과를 얻었습니다. 이 도달 분할이 의미가 있는지 여부도 알 수 있습니다.
지금까지 수행한 작업을 빠르게 요약해 보겠습니다. 우리는 10개의 매장을 지리적으로 남서부 하단 지역과 북동부 지역의 두 구역으로 나눴습니다. 수익, 일일 고객 수 등 우리가 이미 가지고 있는 것 외에도 더 많은 데이터를 수집하는 것은 흥미로울 수 있습니다. 그렇게 하면 더 풍부한 분석을 수행하고 더 흥미로운 결과를 생성할 수 있습니다.
이와 같은 클러스터링 연구는 이미 확립된 브랜드가 새로운 매장을 오픈할 지역을 선택하고자 할 때 수행할 수 있습니다. 이 경우 위치 외에 고려되는 변수가 더 많습니다.
이 모든 것이 K-평균 알고리즘과 어떤 관련이 있습니까?
이 단계를 수행하는 동안 K-평균 알고리즘과 관련이 있는지 궁금할 수 있습니다. 지금까지 진행한 프로세스는 K-평균 알고리즘. 간단히 말해서, 우리는 그룹/클러스터의 수를 결정하고, 초기 포인트를 무작위로 선택하고, 클러스터가 수렴될 때까지 각 반복에서 중심을 업데이트했습니다. 우리는 기본적으로 각 단계를 신중하게 수행하여 전체 알고리즘을 수작업으로 수행했습니다.
XNUMXD덴탈의 K K-Means에서 클러스터 수 반복 프로세스를 시작하기 전에 설정해야 합니다. 우리의 경우 K = 2. 이 특성은 때때로 다음과 같이 보입니다. 부정 미리 고정된 수의 클러스터를 가질 필요가 없는 계층적 클러스터링과 같은 다른 클러스터링 방법이 있다는 점을 고려하십시오.
수단의 사용으로 인해 K-평균도 다음과 같이 됩니다. 이상치와 극단값에 민감 – 변동성을 높이고 중심이 제 역할을 하는 것을 더 어렵게 만듭니다. 따라서 수행해야 할 필요성을 인식하십시오. 극단값 및 이상치 분석 K-Means 알고리즘을 사용하여 클러스터링을 수행하기 전에
또한 우리의 포인트는 직선 부분으로 분할되었으며 클러스터를 생성할 때 곡선이 없습니다. 이는 K-Means 알고리즘의 단점이기도 합니다.
참고 : 더 유연하고 타원 및 기타 모양에 적용할 수 있어야 하는 경우 일반화된 K-평균 가우스 혼합 모델. 이 모델은 타원형 분할 클러스터에 적응할 수 있습니다.
K-Means는 또한 많은 장점! 그것은 잘 수행 대형 데이터 세트 일부 유형의 계층적 클러스터링 알고리즘을 사용하는 경우 처리하기 어려울 수 있습니다. 또한 수렴을 보장, 그리고 쉽게 일반화하다 및 각색하다. 그 외에도 아마도 가장 많이 사용되는 클러스터링 알고리즘일 것입니다.
이제 K-Means 알고리즘에서 수행되는 모든 단계를 살펴보고 모든 장단점을 이해했으므로 마침내 Scikit-Learn 라이브러리를 사용하여 K-Means를 구현할 수 있습니다.
다음을 사용하여 K-평균 알고리즘을 구현하는 방법 사이킷런
결과를 다시 확인하기 위해 이 프로세스를 다시 수행하지만 이제 3줄의 코드를 사용하여 sklearn:
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.fit(points)
kmeans.labels_
여기에서 레이블은 이전 그룹과 동일합니다. 결과를 빠르게 플로팅해 보겠습니다.
sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)
결과 플롯은 이전 섹션의 플롯과 동일합니다.
모범 사례, 업계에서 인정하는 표준 및 포함된 치트 시트가 포함된 Git 학습에 대한 실습 가이드를 확인하십시오. 인터넷 검색 Git 명령을 중지하고 실제로 배움 이것!
참고 : Scikit-Learn을 사용하여 K-Means 알고리즘을 수행한 방법을 보면 간단하고 너무 걱정할 필요가 없다는 인상을 받을 수 있습니다. K-Means 알고리즘을 단계별로 살펴보았을 때 이전 섹션에서 논의한 모든 단계를 단 3줄의 코드로 수행합니다. 하지만, 악마는 디테일에 있다 이 경우! 알고리즘의 모든 단계와 제한 사항을 이해하지 못하면 K-평균 알고리즘이 예상하지 못한 결과를 제공하는 상황에 직면할 가능성이 큽니다.
Scikit-Learn을 사용하면 다음을 설정하여 더 빠른 수렴을 위해 K-Means를 초기화할 수도 있습니다. init='k-means++' 논쟁. 더 넓은 의미에서, K-평균++ 여전히 선택 k 초기 군집은 균일 분포에 따라 무작위로 중심을 잡습니다. 그런 다음 각 후속 클러스터 중심은 거리 측정값만 계산하는 것이 아니라 확률을 사용하여 나머지 데이터 포인트에서 선택됩니다. 확률을 사용하면 알고리즘 속도가 빨라지고 매우 큰 데이터 세트를 처리할 때 유용합니다.
팔꿈치 방법 – 최적의 그룹 수 선택
여태까지는 그런대로 잘됐다! 점과 중심 사이의 유클리드 거리를 기반으로 10개의 상점을 클러스터링했습니다. 그러나 클러스터링하기가 조금 더 어려운 그래프 중앙의 두 점은 어떻습니까? 그들도 별도의 그룹을 만들 수는 없었을까? 우리가 실제로 선택하여 실수를 했습니까? K = 2 여러 떼? 어쩌면 우리는 실제로 K = 3 여러 떼? 우리는 세 개 이상의 그룹을 가질 수도 있고 그것을 인식하지 못할 수도 있습니다.
여기서 묻는 질문은 K-평균에서 그룹 수(K)를 결정하는 방법. 그 질문에 답하려면 다른 K 값에 대해 "더 나은" 클러스터가 있는지 이해해야 합니다.
그것을 알아내는 순진한 방법은 서로 다른 값을 가진 점을 클러스터링하는 것입니다. K, 그래서, K=2, K=3, K=4 등:
for number_of_clusters in range(1, 11):
kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
kmeans.fit(points)
그러나 서로 다른 클러스터링 포인트 Ks 혼자 충분하지 않을거야. 이상적인 가치를 선택했는지 이해하기 위해 K. 각각의 클러스터링 품질을 평가할 방법이 필요합니다. K 우리는 선택했습니다.
수동으로 계산 군집 제곱합(WCSS) 내
다음은 클러스터링된 포인트가 서로 얼마나 가까운지를 측정하기 위한 이상적인 장소입니다. 그것은 본질적으로 얼마나 많은 변화 우리는 단일 클러스터 안에 있습니다. 이 조치는 군집 내 제곱합및 WCSS 짧게. WCSS가 작을수록 포인트가 더 가까우므로 클러스터가 더 잘 형성됩니다. WCSS 공식은 여러 클러스터에 사용할 수 있습니다.
$$
WCSS = 합계(Pi_1 – Centroid_1)^2 + cdots + 합계(Pi_n – Centroid_n)^2
$$
참고 : 이 가이드에서는 다음을 사용합니다. 유클리드 거리 중심을 얻기 위해 하지만 맨해튼과 같은 다른 거리 측정도 사용할 수 있습니다.
이제 우리는 두 개의 클러스터를 선택했다고 가정하고 WCSS가 무엇이며 어떻게 사용하는지 더 잘 이해하기 위해 WCSS를 구현하려고 시도할 수 있습니다. 공식에서 알 수 있듯이 모든 클러스터 점과 중심 간의 차이 제곱을 합산해야 합니다. 따라서 첫 번째 그룹의 첫 번째 점이 (5, 3) 첫 번째 그룹의 마지막 중심(수렴 후)은 (16.8, 17.0), WCSS는 다음과 같습니다.
$$
WCSS = 합계((5,3) – (16.8, 17.0))^2
$$
$$
WCSS = 합계((5-16.8) + (3-17.0))^2
$$
$$
WCSS = 합계((-11.8) + (-14.0))^2
$$
$$
WCSS = 합계((-25.8))^2
$$
$$
WCSS = 335.24
$$
이 예는 클러스터에서 한 점에 대한 WCSS를 계산하는 방법을 보여줍니다. 그러나 클러스터에는 일반적으로 하나 이상의 점이 포함되며 WCSS를 계산할 때 이 모든 점을 고려해야 합니다. 점과 중심의 클러스터를 수신하고 제곱의 합을 반환하는 함수를 정의하여 이를 수행합니다.
def sum_of_squares(cluster, centroid):
squares = []
for p in cluster:
squares.append((p - centroid)**2)
ss = np.array(squares).sum()
return ss
이제 각 클러스터에 대한 제곱합을 얻을 수 있습니다.
g1 = sum_of_squares(points_in_g1, g1_center)
g2 = sum_of_squares(points_in_g2, g2_center)
그리고 결과를 합산하여 총계를 얻습니다. WCSS:
g1 + g2
결과 :
2964.3999999999996
따라서 우리의 경우에는 K 2와 같으면 총 WCSS는 2964.39. 이제 Ks를 전환하고 이들 모두에 대한 WCSS를 계산할 수 있습니다. 이를 통해 우리는 무엇에 대한 통찰력을 얻을 수 있습니다 K 클러스터링이 가장 잘 수행되도록 선택해야 합니다.
계산 중 WCSS 사용 사이킷런
다행히도 각각에 대해 WCSS를 수동으로 계산할 필요가 없습니다. K. 주어진 클러스터 수에 대해 K-Means 클러스터링을 수행한 후 다음을 사용하여 WCSS를 얻을 수 있습니다. inertia_ 기인하다. 이제 K-Means로 돌아갈 수 있습니다. for 루프를 사용하여 클러스터 수를 변경하고 해당 WCSS 값을 나열합니다.
wcss = []
for number_of_clusters in range(1, 11):
kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
kmeans.fit(points)
wcss.append(kmeans.inertia_)
wcss
목록의 두 번째 값은 이전에 계산한 것과 정확히 동일합니다. K = 2:
[18272.9, # For k=1
2964.3999999999996, # For k=2
1198.75, # For k=3
861.75,
570.5,
337.5,
175.83333333333334,
79.5,
17.0,
0.0]
이러한 결과를 시각화하기 위해 Ks WCSS 값과 함께:
ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss)
다음과 같은 경우 플롯에 중단이 있습니다. x = 2, 라인의 낮은 지점, 그리고 더 낮은 지점 x = 3. 우리에게 상기시켜줍니다. 팔꿈치의 모양. WCSS와 함께 K를 플로팅하여 다음을 사용합니다. 팔꿈치 방법 K의 수를 선택합니다. 그리고 선택한 K는 정확히 가장 낮은 팔꿈치 지점입니다., 그래서, 그것은 3 대신 2, 우리의 경우:
ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss);
plt.axvline(3, linestyle='--', color='r')
K-Means 클러스터 알고리즘을 다시 실행하여 데이터가 어떻게 보이는지 확인할 수 있습니다. 세 개의 클러스터:
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(points)
sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)
우리는 이미 두 개의 클러스터에 만족했지만 엘보우 방법에 따르면 세 개의 클러스터가 데이터에 더 적합할 것입니다. 이 경우 두 가지가 아닌 세 가지 종류의 상점이 있습니다. 엘보우 방식을 사용하기 전에는 서남부와 북동부 클러스터에 대해 생각했지만 이제는 중앙에도 매장이 있습니다. 근처에 경쟁이 적기 때문에 다른 매장을 열기에 좋은 위치일 수 있습니다.
대체 클러스터 품질 측정
클러스터 품질을 평가할 때 사용할 수 있는 다른 측정값도 있습니다.
- 실루엣 점수 – 클러스터 내 포인트 간의 거리뿐만 아니라 클러스터 자체 간의 거리도 분석
- 군집 간 제곱합 (BCSS) – WCSS를 보완하는 메트릭
- 제곱합 오차 (ESS)
- 최대 반경 - 한 점에서 중심까지의 가장 큰 거리를 측정합니다.
- 평균 반경 - 한 점에서 중심까지의 가장 큰 거리의 합을 클러스터 수로 나눈 값.
문제에 따라 일부 대안이 가장 널리 사용되는 측정항목보다 더 적합할 수 있으므로 각각을 실험하고 파악하는 것이 좋습니다. (WCSS 및 실루엣 점수).
결국 많은 데이터 과학 알고리즘과 마찬가지로 각 클러스터 내부의 분산을 줄이고 서로 다른 클러스터 간의 분산을 최대화하려고 합니다. 따라서 더 정의되고 분리 가능한 클러스터가 있습니다.
다른 데이터 세트에 K-평균 적용하기
다른 데이터 세트에서 배운 것을 사용해 봅시다. 이번에는 유사한 와인의 그룹을 찾으려고 노력할 것입니다.
참고 : 데이터 세트를 다운로드할 수 있습니다. 여기에서 지금 확인해 보세요..
우리는 수입으로 시작합니다 pandas 그 (것)들을 읽는 wine-clustering CSV (쉼표로 구분된 값) 파일을 Dataframe 구조:
import pandas as pd
df = pd.read_csv('wine-clustering.csv')
로드한 후 데이터의 처음 XNUMX개 레코드를 살펴보겠습니다. head() 방법:
df.head()
결과 :
Alcohol Malic_Acid Ash Ash_Alcanity Magnesium Total_Phenols Flavanoids Nonflavanoid_Phenols Proanthocyanins Color_Intensity Hue OD280 Proline
0 14.23 1.71 2.43 15.6 127 2.80 3.06 0.28 2.29 5.64 1.04 3.92 1065
1 13.20 1.78 2.14 11.2 100 2.65 2.76 0.26 1.28 4.38 1.05 3.40 1050
2 13.16 2.36 2.67 18.6 101 2.80 3.24 0.30 2.81 5.68 1.03 3.17 1185
3 14.37 1.95 2.50 16.8 113 3.85 3.49 0.24 2.18 7.80 0.86 3.45 1480
4 13.24 2.59 2.87 21.0 118 2.80 2.69 0.39 1.82 4.32 1.04 2.93 735
우리는 와인에 존재하는 물질에 대한 많은 측정치를 가지고 있습니다. 여기에서도 범주형 열이 모두 숫자이기 때문에 변환할 필요가 없습니다. 이제 기술 통계를 살펴 보겠습니다. describe() 방법:
df.describe().T
설명 테이블:
count mean std min 25% 50% 75% max
Alcohol 178.0 13.000618 0.811827 11.03 12.3625 13.050 13.6775 14.83
Malic_Acid 178.0 2.336348 1.117146 0.74 1.6025 1.865 3.0825 5.80
Ash 178.0 2.366517 0.274344 1.36 2.2100 2.360 2.5575 3.23
Ash_Alcanity 178.0 19.494944 3.339564 10.60 17.2000 19.500 21.5000 30.00
Magnesium 178.0 99.741573 14.282484 70.00 88.0000 98.000 107.0000 162.00
Total_Phenols 178.0 2.295112 0.625851 0.98 1.7425 2.355 2.8000 3.88
Flavanoids 178.0 2.029270 0.998859 0.34 1.2050 2.135 2.8750 5.08
Nonflavanoid_Phenols 178.0 0.361854 0.124453 0.13 0.2700 0.340 0.4375 0.66
Proanthocyanins 178.0 1.590899 0.572359 0.41 1.2500 1.555 1.9500 3.58
Color_Intensity 178.0 5.058090 2.318286 1.28 3.2200 4.690 6.2000 13.00
Hue 178.0 0.957449 0.228572 0.48 0.7825 0.965 1.1200 1.71
OD280 178.0 2.611685 0.709990 1.27 1.9375 2.780 3.1700 4.00
Proline 178.0 746.893258 314.907474 278.00 500.500 673.500 985.0000 1680.00
표를 보면 분명히 있습니다. 데이터의 변동성 – 다음과 같은 일부 열의 경우 Alchool 더 많은 것이 있으며 다음과 같은 다른 사람들을 위해 Malic_Acid, 더 적은. 이제 우리는 어떤 것이 있는지 확인할 수 있습니다 null및 NaN 데이터세트의 값:
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 13 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Alcohol 178 non-null float64
1 Malic_Acid 178 non-null float64
2 Ash 178 non-null float64
3 Ash_Alcanity 178 non-null float64
4 Magnesium 178 non-null int64
5 Total_Phenols 178 non-null float64
6 Flavanoids 178 non-null float64
7 Nonflavanoid_Phenols 178 non-null float64
8 Proanthocyanins 178 non-null float64
9 Color_Intensity 178 non-null float64
10 Hue 178 non-null float64
11 OD280 178 non-null float64
12 Proline 178 non-null int64
dtypes: float64(11), int64(2)
memory usage: 18.2 KB
데이터 세트에 빈 값이 없기 때문에 데이터를 삭제하거나 입력할 필요가 없습니다. Seaborn을 사용할 수 있습니다. pairplot() 데이터 분포를 확인하고 데이터세트가 클러스터링에 흥미로울 수 있는 열 쌍을 형성하는지 확인하려면 다음을 수행합니다.
sns.pairplot(df)
pairplot을 보면 두 개의 열이 클러스터링 목적으로 유망해 보입니다. Alcohol 및 OD280 (이것은 와인의 단백질 농도를 결정하는 방법입니다). 3개를 결합한 플롯에 XNUMX개의 별개의 클러스터가 있는 것 같습니다.
상관 관계가 있는 것으로 보이는 다른 열도 있습니다. 가장 주목할만한 Alcohol 및 Total_Phenols및 Alcohol 및 Flavanoids. 쌍 그림에서 관찰할 수 있는 훌륭한 선형 관계가 있습니다.
우리의 초점은 K-Means로 클러스터링하는 것이므로 한 쌍의 열을 선택하겠습니다. Alcohol 및 OD280, 이 데이터세트에 대한 엘보우 방법을 테스트합니다.
참고 : 데이터 세트의 더 많은 열을 사용하는 경우 3차원으로 플롯하거나 데이터를 다음으로 줄여야 합니다. 주성분(PCA 사용). 이것은 유효하고 더 일반적인 접근 방식입니다. 설명하는 정도에 따라 주요 구성 요소를 선택하고 데이터 차원을 줄일 때 정보 손실이 있다는 점을 염두에 두십시오. 따라서 플롯은 근사 실제 데이터가 아니라 실제 데이터입니다.
그룹으로 나누고 싶은 점을 더 자세히 살펴보기 위해 축으로 설정된 두 개의 열을 사용하여 산점도를 그려 보겠습니다.
sns.scatterplot(data=df, x='OD280', y='Alcohol')
이제 열을 정의하고 엘보우 방법을 사용하여 클러스터 수를 결정할 수 있습니다. 우리는 또한 알고리즘을 시작할 것입니다 kmeans++ 더 빨리 수렴하는지 확인하기 위해:
values = df[['OD280', 'Alcohol']]
wcss_wine = []
for i in range(1, 11):
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
kmeans.fit(values)
wcss_wine.append(kmeans.inertia_)
WCSS를 계산했으므로 결과를 플롯할 수 있습니다.
clusters_wine = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
plt.plot(clusters_wine, wcss_wine)
plt.axvline(3, linestyle='--', color='r')
팔꿈치 방법에 따르면 여기에 3개의 클러스터가 있어야 합니다. 마지막 단계에서는 포인트를 3개의 클러스터로 클러스터링하고 색상으로 식별되는 클러스터를 플로팅합니다.
kmeans_wine = KMeans(n_clusters=3, random_state=42)
kmeans_wine.fit(values)
sns.scatterplot(x = values['OD280'], y = values['Alcohol'], hue=kmeans_wine.labels_)
클러스터를 볼 수 있습니다 0, 1및 2 그래프에서. 우리의 분석에 따르면, 0 그룹 단백질 함량이 높고 알코올 함량이 낮은 와인이 있으며, 1 그룹 알코올 도수가 높고 단백질이 적은 와인이 있으며, 2 그룹 와인에는 고단백질과 고 알코올이 모두 포함되어 있습니다.
이것은 매우 흥미로운 데이터 세트이며 정규화 및 PCA 후 데이터를 클러스터링하고 결과를 해석하고 새로운 연결을 찾는 방식으로 분석을 더 진행하는 것이 좋습니다.
결론
K- 평균 클러스터링은 데이터 클러스터링을 위한 간단하지만 매우 효과적인 비지도 머신 러닝 알고리즘입니다. 데이터 포인트 간의 유클리드 거리를 기반으로 데이터를 클러스터링합니다. K-Means 클러스터링 알고리즘은 텍스트 문서, 이미지, 비디오 등을 그룹화하는 데 많이 사용됩니다.
