Unsupervised Learning - Clustering (K-Means, DBSCAN, Hierarchical)

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

# Generate sample data: 300 points, 4 natural clusters
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.8, random_state=42)

# Elbow method: try K from 1 to 10
inertias = []
K_range = range(1, 11)
for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X)
    inertias.append(km.inertia_)

print("Inertia values:")
for k, inertia in zip(K_range, inertias):
    print(f"  K={k}: {inertia:.1f}")

# The elbow is at K=4 (biggest drop, then flattening)
# Fit final model with K=4
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
labels = kmeans.fit_predict(X)
print(f"\nCluster assignments (first 10): {labels[:10]}")
print(f"Centroids shape: {kmeans.cluster_centers_.shape}")
print(f"Centroids:\n{kmeans.cluster_centers_}")

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_moons
from sklearn.preprocessing import StandardScaler

# Generate crescent-shaped data (K-Means would fail here)
X, y_true = make_moons(n_samples=300, noise=0.1, random_state=42)

# Scale features (important for distance-based algorithms)
X_scaled = StandardScaler().fit_transform(X)

# Apply DBSCAN
db = DBSCAN(eps=0.3, min_samples=5)
labels = db.fit_predict(X_scaled)

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

print(f"Number of clusters found: {n_clusters}")
print(f"Number of noise points: {n_noise}")
print(f"Cluster labels (unique): {sorted(set(labels))}")
print(f"Points per cluster:")
for label in sorted(set(labels)):
    count = list(labels).count(label)
    name = "Noise" if label == -1 else f"Cluster {label}"
    print(f"  {name}: {count} points")

import numpy as np
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.datasets import make_blobs

# Generate sample data
X, y_true = make_blobs(n_samples=50, centers=3, cluster_std=0.8, random_state=42)

# Method 1: sklearn AgglomerativeClustering
agg = AgglomerativeClustering(n_clusters=3, linkage='ward')
labels = agg.fit_predict(X)
print("Agglomerative Clustering labels (first 15):")
print(labels[:15])
print(f"Points per cluster: {[list(labels).count(i) for i in range(3)]}")

# Method 2: scipy linkage for dendrogram data
Z = linkage(X, method='ward')
print(f"\nLinkage matrix shape: {Z.shape}")
print(f"Last 5 merges (cluster1, cluster2, distance, size):")
for row in Z[-5:]:
    print(f"  Merged {int(row[0])} + {int(row[1])}, distance={row[2]:.2f}, new_size={int(row[3])}")

# To plot: dendrogram(Z, truncate_mode='lastp', p=10)
# The tall vertical lines indicate well-separated clusters

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

# Generate data with 3 natural clusters
X, y_true = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)

# Try different values of K and compare silhouette scores
print("Silhouette scores for different K values:")
for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X)
    score = silhouette_score(X, labels)
    print(f"  K={k}: silhouette={score:.4f}")

# Best K has highest silhouette score
# Detailed analysis for K=3
km = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = km.fit_predict(X)
sample_scores = silhouette_samples(X, labels)

print(f"\nDetailed analysis for K=3:")
print(f"  Overall silhouette score: {silhouette_score(X, labels):.4f}")
for i in range(3):
    cluster_scores = sample_scores[labels == i]
    print(f"  Cluster {i}: mean={cluster_scores.mean():.4f}, "
          f"min={cluster_scores.min():.4f}, size={len(cluster_scores)}")

import numpy as np
from sklearn.cluster import KMeans, DBSCAN
from sklearn.datasets import make_circles
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# Generate concentric circles (K-Means will fail)
X, y_true = make_circles(n_samples=300, noise=0.05, factor=0.5, random_state=42)
X_scaled = StandardScaler().fit_transform(X)

# K-Means on circles
km = KMeans(n_clusters=2, random_state=42, n_init=10)
km_labels = km.fit_predict(X_scaled)
km_sil = silhouette_score(X_scaled, km_labels)

# DBSCAN on circles
db = DBSCAN(eps=0.3, min_samples=5)
db_labels = db.fit_predict(X_scaled)
# Remove noise points for silhouette calculation
mask = db_labels != -1
db_sil = silhouette_score(X_scaled[mask], db_labels[mask]) if mask.sum() > 1 else -1

print("Concentric circles data:")
print(f"  K-Means silhouette: {km_sil:.4f}")
print(f"  DBSCAN silhouette:  {db_sil:.4f}")
print(f"  K-Means unique labels: {sorted(set(km_labels))}")
print(f"  DBSCAN unique labels:  {sorted(set(db_labels))}")
print(f"  DBSCAN noise points:   {list(db_labels).count(-1)}")

# K-Means splits the circles vertically (wrong!)
# DBSCAN correctly identifies inner and outer circles
print("\nK-Means fails because circles are not spherical clusters.")
print("DBSCAN succeeds because it follows density, not shape assumptions.")

import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# Simulate mall customer dataset
np.random.seed(42)
n = 200
data = {
    'CustomerID': range(1, n+1),
    'Gender': np.random.choice(['Male', 'Female'], n),
    'Age': np.random.randint(18, 70, n),
    'AnnualIncome_K': np.concatenate([
        np.random.normal(30, 8, 50),
        np.random.normal(55, 10, 60),
        np.random.normal(85, 8, 50),
        np.random.normal(55, 10, 40)
    ]).astype(int),
    'SpendingScore': np.concatenate([
        np.random.normal(20, 8, 50),
        np.random.normal(50, 12, 60),
        np.random.normal(75, 10, 50),
        np.random.normal(85, 8, 40)
    ]).astype(int)
}
df = pd.DataFrame(data)
print("Dataset shape:", df.shape)
print(df[['Age', 'AnnualIncome_K', 'SpendingScore']].describe().round(1))

# Select features for clustering
features = df[['AnnualIncome_K', 'SpendingScore']]

# Scale features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features)

# Elbow method
print("\nElbow Method:")
for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X_scaled)
    sil = silhouette_score(X_scaled, km.labels_)
    print(f"  K={k}: inertia={km.inertia_:.1f}, silhouette={sil:.4f}")

# Final model with K=4
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
df['Cluster'] = kmeans.fit_predict(X_scaled)

# Analyze segments
print("\nCustomer Segments:")
segment_analysis = df.groupby('Cluster').agg(
    count=('CustomerID', 'count'),
    avg_income=('AnnualIncome_K', 'mean'),
    avg_spending=('SpendingScore', 'mean'),
    avg_age=('Age', 'mean')
).round(1)
print(segment_analysis)

# Business interpretation
print("\nBusiness Interpretation:")
for idx, row in segment_analysis.iterrows():
    if row['avg_income'] > 65 and row['avg_spending'] > 60:
        label = "Premium Customers (high income, high spending)"
    elif row['avg_income'] > 65 and row['avg_spending'] < 40:
        label = "Careful Spenders (high income, low spending)"
    elif row['avg_income'] < 40 and row['avg_spending'] < 40:
        label = "Budget Conscious (low income, low spending)"
    else:
        label = "Average Customers (moderate income and spending)"
    print(f"  Cluster {idx}: {label}")
    print(f"    Count={int(row['count'])}, AvgIncome={row['avg_income']}K, AvgSpending={row['avg_spending']}")

import numpy as np
from sklearn.neighbors import NearestNeighbors
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler

# Generate data with noise
X_clean, _ = make_blobs(n_samples=250, centers=3, cluster_std=0.5, random_state=42)
noise = np.random.uniform(-10, 10, (30, 2))
X = np.vstack([X_clean, noise])
X_scaled = StandardScaler().fit_transform(X)

# K-distance plot to find eps
# Find distance to k-th nearest neighbor (k = min_samples)
k = 5
neighbors = NearestNeighbors(n_neighbors=k)
neighbors.fit(X_scaled)
distances, _ = neighbors.kneighbors(X_scaled)
k_distances = np.sort(distances[:, k-1])  # Distance to k-th neighbor

print("K-distance statistics (k=5):")
print(f"  Min: {k_distances[0]:.4f}")
print(f"  25th percentile: {np.percentile(k_distances, 25):.4f}")
print(f"  50th percentile: {np.percentile(k_distances, 50):.4f}")
print(f"  75th percentile: {np.percentile(k_distances, 75):.4f}")
print(f"  90th percentile: {np.percentile(k_distances, 90):.4f}")
print(f"  Max: {k_distances[-1]:.4f}")

# The 'elbow' in k-distance plot suggests eps ~ 0.5
eps_value = 0.5
db = DBSCAN(eps=eps_value, min_samples=k)
labels = db.fit_predict(X_scaled)

n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)
print(f"\nDBSCAN with eps={eps_value}, min_samples={k}:")
print(f"  Clusters found: {n_clusters}")
print(f"  Noise points: {n_noise} out of {len(X)} total")
print(f"  True noise injected: 30")