K-Means Clustering: Panduan Lengkap

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

# === GENERATE DATASET ===
# Membuat dataset sintetis dengan 3 cluster
np.random.seed(42)
X, y_true = make_blobs(
    n_samples=300,          # 300 titik data
    centers=4,              # 4 pusat cluster asli
    cluster_std=0.60,       # Standar deviasi tiap cluster
    random_state=42
)

print(f"Dataset shape: {X.shape}")
print(f"Fitur: 2 (x1, x2)")
print(f"Cluster asli: {len(np.unique(y_true))}")

# Visualisasi data asli (tanpa label)
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], s=30, alpha=0.7, c='gray')
plt.title('Data Asli (Tanpa Label)')
plt.xlabel('Fitur 1')
plt.ylabel('Fitur 2')
plt.grid(True, alpha=0.3)

# === TERAPKAN K-MEANS ===
kmeans = KMeans(
    n_clusters=4,           # Jumlah cluster
    init='k-means++',       # Inisialisasi cerdas
    n_init=10,              # Jalankan 10x, pilih terbaik
    max_iter=300,           # Maks iterasi
    random_state=42
)

# Fit model
kmeans.fit(X)

# Hasil clustering
labels = kmeans.labels_             # Label cluster tiap titik
centroids = kmeans.cluster_centers_ # Koordinat centroid
inertia = kmeans.inertia_           # WCSS value

print(f"\nHasil Clustering:")
print(f"  Jumlah cluster: {kmeans.n_clusters}")
print(f"  Inertia (WCSS): {inertia:.2f}")
print(f"  Iterasi: {kmeans.n_iter_}")
print(f"\nCentroid:")
for i, c in enumerate(centroids):
    print(f"  Cluster {i}: ({c[0]:.2f}, {c[1]:.2f})")

# Distribusi cluster
unique, counts = np.unique(labels, return_counts=True)
print(f"\nDistribusi cluster:")
for u, c in zip(unique, counts):
    print(f"  Cluster {u}: {c} titik ({c/len(X)*100:.1f}%)")

# Visualisasi hasil
plt.subplot(1, 2, 2)
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
for i in range(4):
    mask = labels == i
    plt.scatter(X[mask, 0], X[mask, 1], s=30, alpha=0.7,
                c=colors[i], label=f'Cluster {i}')
plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='black',
            marker='★', edgecolors='white', linewidth=2,
            label='Centroid', zorder=5)
plt.title(f'K-Means Clustering (K=4, Inertia={inertia:.0f})')
plt.xlabel('Fitur 1')
plt.ylabel('Fitur 2')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# Prediksi cluster untuk data baru
data_baru = np.array([
    [0, 4],    # Titik baru 1
    [-3, -2],  # Titik baru 2
    [5, 2],    # Titik baru 3
])

cluster_baru = kmeans.predict(data_baru)
jarak_centroid = kmeans.transform(data_baru)  # Jarak ke semua centroid

print("Prediksi cluster data baru:")
for i, (point, cluster) in enumerate(zip(data_baru, cluster_baru)):
    jarak = jarak_centroid[i]
    print(f"  Titik {point} → Cluster {cluster}")
    print(f"    Jarak ke centroid: {[f'{d:.2f}' for d in jarak]}")

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

# Generate dataset
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=42)

# === ELBOW METHOD ===
K_range = range(1, 11)
inertias = []

for k in K_range:
    kmeans = KMeans(n_clusters=k, init='k-means++', n_init=10, random_state=42)
    kmeans.fit(X)
    inertias.append(kmeans.inertia_)
    print(f"K={k:2d} → Inertia: {kmeans.inertia_:.2f}")

# Hitung penurunan persentase
print("\nPenurunan Inertia:")
for i in range(1, len(inertias)):
    drop = (inertias[i-1] - inertias[i]) / inertias[i-1] * 100
    print(f"  K={i}→{i+1}: {drop:.1f}% penurunan")

# Plot Elbow
plt.figure(figsize=(10, 6))
plt.plot(K_range, inertias, 'bo-', linewidth=2, markersize=8)
plt.fill_between(K_range, inertias, alpha=0.1, color='blue')

# Tandai elbow point
elbow_k = 4
elbow_idx = elbow_k - 1
plt.annotate(f'Elbow Point\nK={elbow_k}',
             xy=(elbow_k, inertias[elbow_idx]),
             xytext=(elbow_k + 1.5, inertias[elbow_idx] + 50),
             fontsize=12, fontweight='bold', color='red',
             arrowprops=dict(arrowstyle='->', color='red', lw=2))

plt.xlabel('Jumlah Cluster (K)', fontsize=12)
plt.ylabel('Inertia (WCSS)', fontsize=12)
plt.title('Elbow Method — Menentukan K Optimal', fontsize=14)
plt.xticks(K_range)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

print(f"\n✓ K optimal berdasarkan Elbow Method: {elbow_k}")

# pip install kneed
from kneed import KneeLocator

# Deteksi elbow secara otomatis
kneedle = KneeLocator(
    list(K_range),
    inertias,
    curve='convex',      # Bentuk kurva (convex = cembung)
    direction='decreasing' # Arah penurunan
)

optimal_k = kneedle.elbow
print(f"K optimal (otomatis): {optimal_k}")
print(f"Inertia pada K optimal: {inertias[optimal_k - 1]:.2f}")

# Plot dengan elbow yang ditandai otomatis
plt.figure(figsize=(10, 6))
plt.plot(K_range, inertias, 'bo-', linewidth=2, markersize=8)
kneedle.plot_knee()  # Plot dari kneed library
plt.xlabel('Jumlah Cluster (K)')
plt.ylabel('Inertia (WCSS)')
plt.title(f'Elbow Method — K Optimal = {optimal_k}')
plt.grid(True, alpha=0.3)
plt.show()

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

# Generate dataset
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=42)

# === SILHOUETTE SCORE UNTUK BERBAGAI K ===
K_range = range(2, 11)
sil_scores = []

for k in K_range:
    kmeans = KMeans(n_clusters=k, init='k-means++', n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    score = silhouette_score(X, labels)
    sil_scores.append(score)
    print(f"K={k:2d} → Silhouette Score: {score:.4f}")

# Plot Silhouette Score vs K
plt.figure(figsize=(10, 6))
plt.plot(K_range, sil_scores, 'go-', linewidth=2, markersize=8)
plt.fill_between(K_range, sil_scores, alpha=0.1, color='green')

best_k = K_range[np.argmax(sil_scores)]
best_score = max(sil_scores)
plt.annotate(f'K Terbaik = {best_k}\nScore = {best_score:.3f}',
             xy=(best_k, best_score),
             xytext=(best_k + 1, best_score - 0.03),
             fontsize=12, fontweight='bold', color='red',
             arrowprops=dict(arrowstyle='->', color='red', lw=2))

plt.xlabel('Jumlah Cluster (K)', fontsize=12)
plt.ylabel('Silhouette Score', fontsize=12)
plt.title('Silhouette Score — Menentukan K Optimal', fontsize=14)
plt.xticks(K_range)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

print(f"\n✓ K optimal berdasarkan Silhouette: {best_k} (score: {best_score:.4f})")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score

# Fungsi untuk membuat silhouette plot
def plot_silhouette(X, n_clusters, ax):
    kmeans = KMeans(n_clusters=n_clusters, init='k-means++',
                    n_init=10, random_state=42)
    cluster_labels = kmeans.fit_predict(X)
    
    sil_avg = silhouette_score(X, cluster_labels)
    sample_sil_values = silhouette_samples(X, cluster_labels)
    
    y_lower = 10
    colors = plt.cm.Set2(np.linspace(0, 1, n_clusters))
    
    for i in range(n_clusters):
        ith_sil = sample_sil_values[cluster_labels == i]
        ith_sil.sort()
        
        size_cluster = ith_sil.shape[0]
        y_upper = y_lower + size_cluster
        
        ax.fill_betweenx(np.arange(y_lower, y_upper),
                         0, ith_sil,
                         facecolor=colors[i], edgecolor=colors[i],
                         alpha=0.7)
        ax.text(-0.05, y_lower + 0.5 * size_cluster, str(i),
                fontweight='bold', fontsize=11)
        y_lower = y_upper + 10
    
    ax.axvline(x=sil_avg, color='red', linestyle='--', linewidth=2,
               label=f'Rata-rata = {sil_avg:.3f}')
    ax.set_xlabel('Silhouette Coefficient')
    ax.set_ylabel('Cluster')
    ax.set_title(f'K = {n_clusters} (Avg Silhouette: {sil_avg:.3f})')
    ax.legend()

# Plot untuk beberapa nilai K
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
axes = axes.flatten()

for idx, k in enumerate([2, 3, 4, 5]):
    plot_silhouette(X, k, axes[idx])

plt.suptitle('Silhouette Plot untuk Berbagai Nilai K', fontsize=14, y=1.02)
plt.tight_layout()
plt.show()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# === BUAT DATASET PELANGGAN ===
np.random.seed(42)
n = 200

data_pelanggan = pd.DataFrame({
    'customer_id': range(1, n + 1),
    'annual_income': np.concatenate([
        np.random.normal(25, 5, 50),   # Income rendah
        np.random.normal(55, 8, 60),   # Income menengah
        np.random.normal(85, 10, 50),  # Income tinggi
        np.random.normal(45, 6, 40),   # Income menengah-rendah
    ]).round(1),
    'spending_score': np.concatenate([
        np.random.normal(20, 8, 50),   # Spending rendah
        np.random.normal(50, 10, 60),  # Spending menengah
        np.random.normal(75, 8, 50),   # Spending tinggi
        np.random.normal(35, 7, 40),   # Spending rendah-menengah
    ]).clip(1, 100).round(1),
    'age': np.random.randint(18, 65, n),
})

print("Dataset Pelanggan:")
print(data_pelanggan.describe())
print(f"\nSample data:")
print(data_pelanggan.head(10))

# === PREPROCESSING ===
# Pilih fitur untuk clustering
fitur = ['annual_income', 'spending_score']
X_pelanggan = data_pelanggan[fitur].values

# Normalisasi (PENTING untuk K-Means!)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_pelanggan)

print(f"\nData sebelum scaling:")
print(f"  Mean: {X_pelanggan.mean(axis=0)}")
print(f"  Std:  {X_pelanggan.std(axis=0)}")
print(f"\nData setelah scaling:")
print(f"  Mean: {X_scaled.mean(axis=0).round(4)}")
print(f"  Std:  {X_scaled.std(axis=0).round(4)}")

# === ELBOW METHOD ===
K_range = range(1, 11)
inertias = []
sil_scores = []

for k in K_range:
    km = KMeans(n_clusters=k, init='k-means++', n_init=10, random_state=42)
    km.fit(X_scaled)
    inertias.append(km.inertia_)
    if k >= 2:
        from sklearn.metrics import silhouette_score
        sil = silhouette_score(X_scaled, km.labels_)
        sil_scores.append(sil)
        print(f"K={k}: Inertia={km.inertia_:.1f}, Silhouette={sil:.3f}")
    else:
        print(f"K={k}: Inertia={km.inertia_:.1f}")

# Plot Elbow & Silhouette berdampingan
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

ax1.plot(K_range, inertias, 'bo-', linewidth=2)
ax1.set_xlabel('K')
ax1.set_ylabel('Inertia')
ax1.set_title('Elbow Method')
ax1.grid(True, alpha=0.3)

ax2.plot(range(2, 11), sil_scores, 'go-', linewidth=2)
ax2.set_xlabel('K')
ax2.set_ylabel('Silhouette Score')
ax2.set_title('Silhouette Analysis')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# === CLUSTERING DENGAN K OPTIMAL ===
K_OPTIMAL = 5  # Berdasarkan elbow + silhouette
kmeans_final = KMeans(n_clusters=K_OPTIMAL, init='k-means++',
                       n_init=10, random_state=42)
data_pelanggan['cluster'] = kmeans_final.fit_predict(X_scaled)

# Profil setiap cluster
print(f"\n{'='*60}")
print(f"PROFIL CLUSTER (K={K_OPTIMAL})")
print(f"{'='*60}")
for i in range(K_OPTIMAL):
    cluster_data = data_pelanggan[data_pelanggan['cluster'] == i]
    print(f"\n--- Cluster {i} ({len(cluster_data)} pelanggan) ---")
    print(f"  Income rata-rata:  ${cluster_data['annual_income'].mean():.1f}k")
    print(f"  Spending rata-rata: {cluster_data['spending_score'].mean():.1f}")
    print(f"  Usia rata-rata:    {cluster_data['age'].mean():.0f} tahun")

# Visualisasi scatter plot berwarna cluster
plt.figure(figsize=(10, 8))
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']
cluster_names = [
    'Budget Conscious', 'Average Spenders', 'Premium Customers',
    'High Income Low Spend', 'Young Big Spenders'
]

for i in range(K_OPTIMAL):
    mask = data_pelanggan['cluster'] == i
    plt.scatter(data_pelanggan[mask]['annual_income'],
                data_pelanggan[mask]['spending_score'],
                s=60, alpha=0.7, c=colors[i],
                label=f'Cluster {i}: {cluster_names[i]}',
                edgecolors='white', linewidth=0.5)

# Plot centroid
centroids_orig = scaler.inverse_transform(kmeans_final.cluster_centers_)
plt.scatter(centroids_orig[:, 0], centroids_orig[:, 1],
            s=250, c='black', marker='★', edgecolors='white',
            linewidth=2, label='Centroid', zorder=5)

plt.xlabel('Annual Income ($k)', fontsize=12)
plt.ylabel('Spending Score (1-100)', fontsize=12)
plt.title('Segmentasi Pelanggan — K-Means Clustering', fontsize=14)
plt.legend(fontsize=9)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

import time
import numpy as np
from sklearn.cluster import KMeans, MiniBatchKMeans
from sklearn.datasets import make_blobs

# Dataset besar
X_big, y_big = make_blobs(n_samples=100000, centers=10,
                           cluster_std=1.0, random_state=42)
print(f"Dataset: {X_big.shape[0]} titik, {X_big.shape[1]} fitur")

# Bandingkan K-Means vs Mini-Batch
for name, Model in [('K-Means', KMeans), ('Mini-Batch K-Means', MiniBatchKMeans)]:
    start = time.time()
    model = Model(n_clusters=10, init='k-means++', n_init=3,
                  random_state=42, batch_size=1024 if name == 'Mini-Batch K-Means' else None)
    model.fit(X_big)
    elapsed = time.time() - start
    print(f"\n{name}:")
    print(f"  Waktu: {elapsed:.2f} detik")
    print(f"  Inertia: {model.inertia_:.2f}")
    print(f"  Iterasi: {model.n_iter_}")