J = Σ(k=1 to K) Σ(x ∈ Ck) ||x - μk||²

여기서:
  K  = 클러스터 수
  Ck = k번째 클러스터
  μk = k번째 클러스터의 중심점(평균)
  x  = 데이터 포인트
  ||x - μk||² = 유클리드 거리의 제곱

from sklearn.cluster import KMeans

# K-means++ 사용 (init='k-means++' 가 기본값)
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)

labels = kmeans.labels_          # 각 데이터의 클러스터 번호
centers = kmeans.cluster_centers_ # 중심점 좌표
inertia = kmeans.inertia_         # WCSS 값

from sklearn.metrics import silhouette_score

# 실루엣 계수 계산
score = silhouette_score(X, kmeans.labels_)
print(f"실루엣 계수: {score:.4f}")
# 0.7 이상이면 꽤 좋은 클러스터링!

핵심 포인트 조건:
  |Nε(p)| ≥ MinPts

여기서:
  Nε(p) = {q ∈ D | dist(p, q) ≤ ε}  (p의 ε-이웃 집합)
  |Nε(p)| = 이웃 집합의 크기

밀도 직접 도달 가능(Directly Density-Reachable):
  q는 p에서 직접 밀도 도달 가능
  ↔ q ∈ Nε(p) AND |Nε(p)| ≥ MinPts

밀도 도달 가능(Density-Reachable):
  p1, p2, ..., pn 체인이 존재하여
  각 pi+1이 pi에서 직접 밀도 도달 가능

밀도 연결(Density-Connected):
  p와 q가 어떤 점 o에서 모두 밀도 도달 가능

from sklearn.cluster import DBSCAN
import numpy as np

# DBSCAN 적용
dbscan = DBSCAN(eps=0.5, min_samples=5, metric='euclidean')
dbscan.fit(X)

labels = dbscan.labels_
# -1은 노이즈 포인트!

n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)

print(f"클러스터 수: {n_clusters}")
print(f"노이즈 포인트 수: {n_noise}")

# 핵심 포인트 인덱스
core_samples = dbscan.core_sample_indices_

# HDBSCAN 사용 예시 (pip install hdbscan 필요)
import hdbscan

clusterer = hdbscan.HDBSCAN(min_cluster_size=5, min_samples=3)
clusterer.fit(X)

labels = clusterer.labels_
probabilities = clusterer.probabilities_  # 각 포인트의 클러스터 소속 확률!

# scikit-learn의 OPTICS
from sklearn.cluster import OPTICS

optics = OPTICS(min_samples=5, xi=0.05, min_cluster_size=0.05)
optics.fit(X)
labels = optics.labels_

from sklearn.metrics import (
    silhouette_score,
    davies_bouldin_score,
    calinski_harabasz_score,
    adjusted_rand_score,
    normalized_mutual_info_score
)

# 내부 평가 (라벨 없이)
sil = silhouette_score(X, labels)
dbi = davies_bouldin_score(X, labels)
chi = calinski_harabasz_score(X, labels)

print(f"실루엣 계수: {sil:.4f} (높을수록 좋음)")
print(f"Davies-Bouldin: {dbi:.4f} (낮을수록 좋음)")
print(f"Calinski-Harabasz: {chi:.4f} (높을수록 좋음)")

# 외부 평가 (정답 라벨 있을 때)
ari = adjusted_rand_score(true_labels, pred_labels)
nmi = normalized_mutual_info_score(true_labels, pred_labels)
print(f"ARI: {ari:.4f}")
print(f"NMI: {nmi:.4f}")

import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans, DBSCAN
from sklearn.metrics import silhouette_score

# 1. 데이터 전처리 (스케일링은 필수!)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. 고차원이면 PCA로 차원 축소
pca = PCA(n_components=0.95)  # 분산의 95% 보존
X_reduced = pca.fit_transform(X_scaled)

# 3-A. K-means: 엘보우 메서드로 K 결정
inertias = []
sil_scores = []
K_range = range(2, 11)

for k in K_range:
    km = KMeans(n_clusters=k, init='k-means++', n_init=10, random_state=42)
    km.fit(X_reduced)
    inertias.append(km.inertia_)
    sil_scores.append(silhouette_score(X_reduced, km.labels_))

best_k = K_range[np.argmax(sil_scores)]
print(f"최적 K: {best_k}, 실루엣 계수: {max(sil_scores):.4f}")

# 3-B. DBSCAN: k-distance 그래프로 ε 결정
from sklearn.neighbors import NearestNeighbors

k = 5  # MinPts - 1
nbrs = NearestNeighbors(n_neighbors=k).fit(X_reduced)
distances, _ = nbrs.kneighbors(X_reduced)
distances = np.sort(distances[:, k-1], axis=0)
# distances를 플롯해서 꺾이는 지점 찾기 → ε 결정

dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X_reduced)
n_clusters = len(set(db_labels)) - (1 if -1 in db_labels else 0)
n_noise = list(db_labels).count(-1)
print(f"DBSCAN 클러스터 수: {n_clusters}, 노이즈: {n_noise}개")

# UMAP + HDBSCAN 파이프라인 (현재 가장 핫한 조합!)
# pip install umap-learn hdbscan

import umap
import hdbscan

# 1. UMAP으로 차원 축소
reducer = umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42)
embedding = reducer.fit_transform(X_scaled)

# 2. HDBSCAN으로 클러스터링
clusterer = hdbscan.HDBSCAN(
    min_cluster_size=15,
    min_samples=5,
    cluster_selection_epsilon=0.5,
    prediction_data=True
)
clusterer.fit(embedding)

labels = clusterer.labels_
soft_clusters = hdbscan.all_points_membership_vectors(clusterer)
# soft_clusters: 각 포인트의 클러스터 소속 확률 벡터!