K-Means 클러스터링: 동작 원리부터 K 선택까지

지도학습 (KNN):
  "이 점과 가까운 K개의 이웃 레이블이 뭐지?"
  → 다수결로 분류

비지도학습 (클러스터링):
  "이 데이터들을 비슷한 것끼리 묶으면 몇 개의 그룹이 나올까?"
  → 레이블 없이 구조를 발견

K = 3으로 설정
데이터 중에서 랜덤으로 3개를 초기 중심점으로 선택

  ■                    데이터 포인트: ●
  ●  ●                 초기 중심점:   ■
      ●   ●
           ■
  ●  ●
     ●  ●
              ●  ●
                 ■
              ●

각 데이터를 가장 가까운 중심점에 할당

  ■                    클러스터 A: ■ ▲
  ▲  ▲                 클러스터 B: ■ ●
      ▲   ●            클러스터 C: ■ ◆
           ■
  ●  ●
     ●  ●
              ◆  ◆
                 ■
              ◆

중심점을 각 클러스터 평균 위치로 이동

     ■  ← 클러스터 A 소속 데이터들의 평균 좌표
  ▲  ▲
      ▲   ●
        ■  ← 클러스터 B 소속 데이터들의 평균 좌표
  ●  ●
     ●  ●
              ◆  ◆
            ■  ← 클러스터 C 소속 데이터들의 평균 좌표
              ◆

전체 흐름:

  초기 중심점 배치 (랜덤 or K-Means++)
       │
       ▼
  ┌─ 각 데이터를 가장 가까운 중심점에 할당 ◄─┐
  │         │                                │
  │         ▼                                │
  │  중심점을 클러스터 평균으로 이동           │
  │         │                                │
  │         ▼                                │
  │  중심점이 변했는가? ── Yes ───────────────┘
  │         │
  │        No
  │         │
  └─── 종료 (수렴)

WCSS = Σₖ₌₁ᴷ Σ(xᵢ ∈ Cₖ) ‖xᵢ - μₖ‖²

Cₖ: k번째 클러스터
μₖ: k번째 클러스터의 중심점(centroid)
‖xᵢ - μₖ‖²: 데이터 xᵢ와 중심점 μₖ 사이의 유클리드 거리 제곱

나쁜 초기화 예시:
  ■ ■ ■ ← 세 중심점이 모두 왼쪽에 몰려 있음
  ● ● ●
  ● ● ●
              ● ● ●
              ● ● ●

  → 오른쪽 클러스터를 제대로 분리하지 못함
  → 지역 최적해에 빠져서 나쁜 결과

K-Means++ 초기화 과정 (K=3):

Step 1: 첫 번째 중심점을 랜덤 선택
  ■ 선택!
  ● ● ●
              ● ● ●

Step 2: 각 데이터의 "가장 가까운 중심점까지 거리" 계산
  → 거리가 먼 데이터일수록 높은 확률로 선택됨

Step 3: 확률에 따라 두 번째 중심점 선택
  ■                        ■ 선택! (멀리 있으니 확률 높았음)
  ● ● ●
              ● ● ●

Step 4: 세 번째도 같은 방식으로
  ■              ■
  ● ● ●
              ■ 선택!
              ● ● ●

WCSS
 │
 │●
 │
 │  ●
 │
 │     ●
 │        ● ← 여기가 "팔꿈치(Elbow)"
 │           ●  ●  ●  ●  ●
 │
 └────────────────────────── K
   1  2  3  4  5  6  7  8  9

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

wcss = []
K_range = range(1, 11)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X)
    wcss.append(km.inertia_)

plt.figure(figsize=(8, 5))
plt.plot(K_range, wcss, 'bo-')
plt.xlabel('K (클러스터 수)')
plt.ylabel('WCSS (Inertia)')
plt.title('Elbow Method')
plt.grid(True, alpha=0.3)
plt.show()

a(i) = 같은 클러스터 내 다른 데이터들과의 평균 거리 (응집도)
b(i) = 가장 가까운 다른 클러스터의 데이터들과의 평균 거리 (분리도)

실루엣 계수 s(i) = (b(i) - a(i)) / max(a(i), b(i))

from sklearn.metrics import silhouette_score

scores = []
K_range = range(2, 11)  # K=1은 의미 없음

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X)
    scores.append(silhouette_score(X, labels))

plt.figure(figsize=(8, 5))
plt.plot(K_range, scores, 'bo-')
plt.xlabel('K (클러스터 수)')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Analysis')
plt.grid(True, alpha=0.3)
plt.show()

Silhouette Diagram (K=3)

클러스터 0  ████████████████████  (넓고 균일 → 좋은 클러스터)
            ██████████████████
            █████████████████
            ████████████████

클러스터 1  ████████████████████████  (가장 넓음 → 응집도 높음)
            ███████████████████████
            ██████████████████████
            █████████████████████

클러스터 2  █████████████  (좁음 → 응집도 낮거나 크기가 작음)
            ████████████
            ███████████
     ──────│────────────────── 평균 실루엣
          0.0              0.6                1.0

from sklearn.metrics import silhouette_samples
import numpy as np

km = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = km.fit_predict(X)
silhouette_vals = silhouette_samples(X, labels)

fig, ax = plt.subplots(figsize=(8, 6))
y_lower = 10

for i in range(3):
    cluster_silhouette = silhouette_vals[labels == i]
    cluster_silhouette.sort()

    size_cluster = len(cluster_silhouette)
    y_upper = y_lower + size_cluster

    ax.fill_betweenx(np.arange(y_lower, y_upper),
                     0, cluster_silhouette, alpha=0.7)
    ax.text(-0.05, y_lower + 0.5 * size_cluster, str(i))
    y_lower = y_upper + 10

avg_score = silhouette_score(X, labels)
ax.axvline(x=avg_score, color='red', linestyle='--', label=f'평균: {avg_score:.3f}')
ax.set_xlabel('실루엣 계수')
ax.set_ylabel('클러스터')
ax.legend()
plt.title('Silhouette Diagram')
plt.show()

K-Means가 잘 작동하는 경우:        K-Means가 실패하는 경우:

    ●●●                                 ●●●●●●●●●●●●
   ●●●●●                              ●●●●●●●●●●●●●●
   ●●●●●         ●●●●●                 ●●●●●●●●●●●●
    ●●●          ●●●●●
                 ●●●●●               ●●●●●●●●●●●●●●●●
                  ●●●                ●●●●●●●●●●●●●●●●●
                                      ●●●●●●●●●●●●●●●

  (구형 클러스터 → OK)              (초승달/고리 형태 → 실패)

정상적인 상황:           이상치가 있는 상황:

  ● ● ●                  ● ● ●
  ● ■ ●                  ● ● ●
  ● ● ●                  ● ● ●
  (중심점 정확)                              ● ← 이상치
                             ■ ← 중심점이 끌려감

일반 K-Means:
  매 반복: 전체 N개 데이터로 중심점 업데이트
  시간 복잡도: O(n * K * d * iterations)

Mini-Batch K-Means:
  매 반복: 랜덤 샘플 b개로 중심점 업데이트 (b << N)
  시간 복잡도: O(b * K * d * iterations)  ← 훨씬 빠름

from sklearn.cluster import MiniBatchKMeans

mbkm = MiniBatchKMeans(
    n_clusters=5,
    batch_size=1024,
    random_state=42,
    n_init=10
)
mbkm.fit(X)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# ─── 1. 데이터 생성 ───
X, y_true = make_blobs(
    n_samples=500,
    centers=4,
    cluster_std=0.8,
    random_state=42
)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ─── 2. Elbow Method ───
wcss = []
sil_scores = []
K_range = range(2, 11)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    wcss.append(km.inertia_)
    sil_scores.append(silhouette_score(X_scaled, labels))

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

axes[0].plot(K_range, wcss, 'bo-')
axes[0].set_xlabel('K')
axes[0].set_ylabel('WCSS (Inertia)')
axes[0].set_title('Elbow Method')
axes[0].grid(True, alpha=0.3)

axes[1].plot(K_range, sil_scores, 'ro-')
axes[1].set_xlabel('K')
axes[1].set_ylabel('Silhouette Score')
axes[1].set_title('Silhouette Analysis')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ─── 3. 최적 K로 클러스터링 ───
best_k = 4
km = KMeans(n_clusters=best_k, random_state=42, n_init=10)
labels = km.fit_predict(X_scaled)
centroids = km.cluster_centers_

# ─── 4. 결과 시각화 ───
plt.figure(figsize=(10, 7))

colors = ['#3182f6', '#ff6b6b', '#00c9a7', '#ffd93d']
for i in range(best_k):
    mask = labels == i
    plt.scatter(X_scaled[mask, 0], X_scaled[mask, 1],
                c=colors[i], label=f'Cluster {i}', alpha=0.6, s=50)

plt.scatter(centroids[:, 0], centroids[:, 1],
            c='black', marker='X', s=200, edgecolors='white',
            linewidths=2, label='Centroids')

plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title(f'K-Means Clustering (K={best_k})')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

print(f'Silhouette Score: {silhouette_score(X_scaled, labels):.4f}')
print(f'Inertia: {km.inertia_:.2f}')
print(f'반복 횟수: {km.n_iter_}')

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# ─── 고객 데이터 생성 (실무에서는 DB에서 추출) ───
np.random.seed(42)
n_customers = 300

data = {
    'recency': np.concatenate([
        np.random.normal(10, 3, 100),   # 최근 구매 고객
        np.random.normal(50, 10, 100),  # 중간 고객
        np.random.normal(120, 20, 100)  # 오래된 고객
    ]),
    'frequency': np.concatenate([
        np.random.normal(30, 5, 100),   # 자주 구매
        np.random.normal(10, 3, 100),   # 가끔 구매
        np.random.normal(3, 1, 100)     # 거의 안 구매
    ]),
    'monetary': np.concatenate([
        np.random.normal(500, 100, 100),  # 고액 구매
        np.random.normal(200, 50, 100),   # 중간 구매
        np.random.normal(50, 20, 100)     # 소액 구매
    ])
}

df = pd.DataFrame(data)
df = df.clip(lower=0)  # 음수 방지

# ─── 피처 스케일링 ───
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df)

# ─── K 선택 (Elbow + Silhouette) ───
results = []
for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    results.append({
        'k': k,
        'inertia': km.inertia_,
        'silhouette': silhouette_score(X_scaled, labels)
    })

results_df = pd.DataFrame(results)
print(results_df.to_string(index=False))

# ─── K=3으로 세분화 ───
km = KMeans(n_clusters=3, random_state=42, n_init=10)
df['cluster'] = km.fit_predict(X_scaled)

# ─── 세그먼트 프로파일링 ───
profile = df.groupby('cluster').agg({
    'recency': 'mean',
    'frequency': 'mean',
    'monetary': 'mean',
    'cluster': 'count'
}).rename(columns={'cluster': 'count'})

print("\n고객 세그먼트 프로파일:")
print(profile.round(1))

출력 예시:

고객 세그먼트 프로파일:
         recency  frequency  monetary  count
cluster
0           10.2       29.8     498.3    100   ← VIP (최근, 자주, 고액)
1           49.5       10.1     201.2    100   ← 일반 (중간 활동)
2          119.8        3.2      52.1    100   ← 이탈 위험 (오래, 드물게, 소액)