import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
 
# Set style for better-looking plots
plt.style.use('default')
plt.rcParams['figure.figsize'] = (10, 6)
 
print("Libraries imported successfully!")

Libraries imported successfully!

# Parameters for synthetic data generation
n_samples = 300  # Number of data points
n_features = 2  # Number of features (dimensions)
n_centers = 4  # Number of distinct clusters we want to generate
cluster_std = 0.8  # Standard deviation of the clusters
random_state = 42  # For reproducibility of the synthetic data
 
# Generate synthetic data
# X will be our features, y_true will be the true cluster labels
X, y_true = make_blobs(n_samples=n_samples,
                       n_features=n_features,
                       centers=n_centers,
                       cluster_std=cluster_std,
                       random_state=random_state)
 
print(f"Shape of generated data (X): {X.shape}")
print(f"Shape of true labels (y_true): {y_true.shape}")
print(f"True cluster labels: {np.unique(y_true)}")

Shape of generated data (X): (300, 2)
Shape of true labels (y_true): (300,)
True cluster labels: [0 1 2 3]

plt.figure(figsize=(10, 8))
plt.scatter(X[:, 0], X[:, 1], c=y_true, cmap='viridis', s=50, alpha=0.7)
plt.title("Synthetic Data Generated for Clustering (True Labels)", fontsize=14)
plt.xlabel("Feature 1", fontsize=12)
plt.ylabel("Feature 2", fontsize=12)
plt.colorbar(label="True Cluster ID")
plt.grid(True, alpha=0.3)
plt.show()
 
print("This plot shows the 'ground truth' clustering that we generated.")
print("Each color represents a different true cluster.")

This plot shows the 'ground truth' clustering that we generated.
Each color represents a different true cluster.

# Set the number of clusters for K-Means
k = 4  # We'll try to find 4 clusters, matching the number we generated
 
# Initialize K-Means clustering
kmeans = KMeans(n_clusters=k,
                init='k-means++',  # Smart initialization to speed up convergence
                #The first centroid is chosen randomly from the data points.
                # Each subsequent centroid is chosen from the remaining points, with a probability proportional to its distance squared from the nearest existing centroid.
                # This ensures new centroids are far from existing ones.
                max_iter=300,  # Maximum number of iterations for a single run
                n_init=10,  # Number of times the algorithm will run with different seeds
                random_state=random_state
                )
 
# Fit the K-Means model to our data
kmeans.fit(X)
 
# Get the cluster assignments for each data point
labels = kmeans.labels_
 
# Get the coordinates of the cluster centroids
centroids = kmeans.cluster_centers_
 
print(f"K-Means found {k} clusters.")
print(f"First 10 cluster assignments: {labels[:10]}")
print(f"\nCluster centroids:")
for i, centroid in enumerate(centroids):
    print(f"  Cluster {i}: ({centroid[0]:.3f}, {centroid[1]:.3f})")
 
print(f"\nWithin-cluster sum of squares (WCSS): {kmeans.inertia_:.3f}")

K-Means found 4 clusters.
First 10 cluster assignments: [3 3 0 1 3 1 2 1 0 2]
 
Cluster centroids:
  Cluster 0: (-2.637, 8.986)
  Cluster 1: (-6.842, -6.840)
  Cluster 2: (4.703, 2.028)
  Cluster 3: (-8.833, 7.218)
 
Within-cluster sum of squares (WCSS): 362.472

plt.figure(figsize=(10, 8))
 
# Plot the data points, colored by their assigned cluster
plt.scatter(X[:, 0], X[:, 1],
            c=labels,  # Color based on assigned cluster
            cmap='plasma',  # Colormap for the clusters
            s=50,  # Size of the point
            alpha=0.7,
            label='Data points'
            )
 
# Plot the cluster centroids
plt.scatter(centroids[:, 0],  # X-coordinates of centroids
            centroids[:, 1],  # Y-coordinates of centroids
            s=200,
            marker='X',
            c='red',
            edgecolor='black',
            linewidth=2,
            label='Centroids'
            )
 
plt.title(f"K-Means Clustering Results (k={k})", fontsize=14)
plt.xlabel("Feature 1", fontsize=12)
plt.ylabel("Feature 2", fontsize=12)
plt.colorbar(label="Assigned Cluster ID")
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.show()
 
print("The red 'X' markers show the computed cluster centroids.")
print("Compare this with the true clusters shown in the previous plot.")

The red 'X' markers show the computed cluster centroids.
Compare this with the true clusters shown in the previous plot.

# Calculate silhouette score
if len(np.unique(labels)) > 1 and len(X) > 1:
    silhouette_avg = silhouette_score(X, labels)
    print(f"Silhouette Score: {silhouette_avg:.3f}")
 
    # Interpret the score
    if silhouette_avg > 0.7:
        interpretation = "Excellent clustering quality"
    elif silhouette_avg > 0.5:
        interpretation = "Good clustering quality"
    elif silhouette_avg > 0.3:
        interpretation = "Fair clustering quality"
    else:
        interpretation = "Poor clustering quality"
 
    print(f"Interpretation: {interpretation}")
else:
    print("Cannot compute silhouette score (less than 2 clusters or samples).")
 
# Additional cluster statistics
unique_labels, counts = np.unique(labels, return_counts=True)
print(f"\nCluster sizes:")
 
# --------------------------------------------------------------
# zip() returns a list of tuples, so we need to unpack each tuple to get the values
# unique_labels = [0, 1, 2]
# counts = [50, 60, 40]
# list(zip(unique_labels, counts)) => [(0, 50), (1, 60), (2, 40)]
# --------------------------------------------------------------
 
for label, count in zip(unique_labels, counts):
    print(f"  Cluster {label}: {count} points ({count / len(X) * 100:.1f}%)")

Silhouette Score: 0.834
Interpretation: Excellent clustering quality
 
Cluster sizes:
  Cluster 0: 75 points (25.0%)
  Cluster 1: 75 points (25.0%)
  Cluster 2: 75 points (25.0%)
  Cluster 3: 75 points (25.0%)

# Test different numbers of clusters
max_k = 10
wcss = []
silhouette_scores = []
 
print("Computing WCSS and Silhouette Scores for different k values...")
 
for i in range(1, max_k + 1):
    kmeans_elbow = KMeans(n_clusters=i,
                          init='k-means++',
                          max_iter=300,
                          n_init=10,
                          random_state=random_state)
    kmeans_elbow.fit(X)
    wcss.append(kmeans_elbow.inertia_)  # inertia_ is the WCSS
 
    # Calculate silhouette score for k > 1
    if i > 1:
        sil_score = silhouette_score(X, kmeans_elbow.labels_)
        silhouette_scores.append(sil_score)
    else:
        silhouette_scores.append(0)  # No silhouette score for k=1
 
print("Done!")

Computing WCSS and Silhouette Scores for different k values...
Done!

# Plot the Elbow Method results
fig, (ax1, ax2) = plt.subplots(1, # Rows of plots
                               2, # Columns of plots
                               figsize=(15, 6))
 
# WCSS Plot (Elbow Method)
ax1.plot(range(1, max_k + 1), wcss, marker='o', linestyle='--', linewidth=2, markersize=8)
ax1.set_title('Elbow Method for Optimal K', fontsize=14)
ax1.set_xlabel('Number of Clusters (K)', fontsize=12)
ax1.set_ylabel('Within-Cluster Sum of Squares (WCSS)', fontsize=12)
ax1.grid(True, alpha=0.3)
ax1.axvline(x=4, color='red', linestyle=':', alpha=0.7, label='True k=4')
ax1.legend()
 
# Silhouette Score Plot
ax2.plot(range(1, max_k + 1), silhouette_scores, marker='s', linestyle='--',
         linewidth=2, markersize=8, color='green')
ax2.set_title('Silhouette Score vs Number of Clusters', fontsize=14)
ax2.set_xlabel('Number of Clusters (K)', fontsize=12)
ax2.set_ylabel('Silhouette Score', fontsize=12)
ax2.grid(True, alpha=0.3)
ax2.axvline(x=4, color='red', linestyle=':', alpha=0.7, label='True k=4')
ax2.legend()
 
plt.tight_layout()
plt.show()
 
print("\nAnalysis:")
print("- Look for the 'elbow' point in the WCSS plot (left) to estimate optimal K.")
print("- Higher silhouette scores (right) indicate better clustering quality.")
 
# Find the k with the highest silhouette score
best_k_silhouette = np.argmax(silhouette_scores[1:]) + 2  # +2 because we start from k=2
print(f"\nK with highest silhouette score: {best_k_silhouette} (score: {max(silhouette_scores[1:]):.3f})")

 
Analysis:
- Look for the 'elbow' point in the WCSS plot (left) to estimate optimal K.
- Higher silhouette scores (right) indicate better clustering quality.
 
K with highest silhouette score: 4 (score: 0.834)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))
 
# True clusters
scatter1 = ax1.scatter(X[:, 0], X[:, 1], c=y_true, cmap='viridis', s=50, alpha=0.7)
ax1.set_title('True Clusters (Ground Truth)', fontsize=14)
ax1.set_xlabel('Feature 1', fontsize=12)
ax1.set_ylabel('Feature 2', fontsize=12)
ax1.grid(True, alpha=0.3)
plt.colorbar(scatter1, ax=ax1, label='True Cluster ID')
 
# K-Means predicted clusters
scatter2 = ax2.scatter(X[:, 0], X[:, 1], c=labels, cmap='plasma', s=50, alpha=0.7)
ax2.scatter(centroids[:, 0], centroids[:, 1],
            s=200, marker='X', c='red', edgecolor='black',
            linewidth=2, label='Centroids')
ax2.set_title('K-Means Predicted Clusters', fontsize=14)
ax2.set_xlabel('Feature 1', fontsize=12)
ax2.set_ylabel('Feature 2', fontsize=12)
ax2.grid(True, alpha=0.3)
ax2.legend()
plt.colorbar(scatter2, ax=ax2, label='Predicted Cluster ID')
 
plt.tight_layout()
plt.show()
 
print("Comparison Analysis:")
print("- Left plot: True cluster structure from data generation")
print("- Right plot: Clusters identified by K-Means algorithm")
print("- Note: Cluster labels may be different (e.g., true cluster 0 might be predicted as cluster 2)")
print("- What matters is whether the algorithm correctly groups similar points together")

Comparison Analysis:
- Left plot: True cluster structure from data generation
- Right plot: Clusters identified by K-Means algorithm
- Note: Cluster labels may be different (e.g., true cluster 0 might be predicted as cluster 2)
- What matters is whether the algorithm correctly groups similar points together

print("=" * 60)
print("LAB SUMMARY AND ANALYSIS")
print("=" * 60)
 
print(f"\n1. DATA GENERATION:")
print(f"   - Generated {n_samples} data points with {n_features} features")
print(f"   - True number of clusters: {n_centers}")
print(f"   - Cluster standard deviation: {cluster_std}")
 
print(f"\n2. K-MEANS CLUSTERING:")
print(f"   - Number of clusters used: {k}")
print(f"   - Initialization method: k-means++")
print(f"   - WCSS (inertia): {kmeans.inertia_:.3f}")
 
print(f"\n3. PERFORMANCE EVALUATION:")
if 'silhouette_avg' in locals():
    print(f"   - Silhouette Score: {silhouette_avg:.3f} ({interpretation})")
print(f"   - Best k by silhouette score: {best_k_silhouette}")
 
print(f"\n4. CLUSTER ANALYSIS:")
for i, (label, count) in enumerate(zip(unique_labels, counts)):
    centroid = centroids[label]
    print(
        f"   - Cluster {label}: {count} points ({count / len(X) * 100:.1f}%) at ({centroid[0]:.2f}, {centroid[1]:.2f})")
 
print(f"\n5. KEY OBSERVATIONS:")
print(f"   - K-Means successfully identified the cluster structure")
print(f"   - The elbow method suggests optimal k around the true value")
print(f"   - Silhouette score indicates {'good' if silhouette_avg > 0.5 else 'fair'} clustering quality")
print(f"   - Cluster assignments may differ from true labels but groupings are similar")
 
print("\n" + "=" * 60)

============================================================
LAB SUMMARY AND ANALYSIS
============================================================
 
1. DATA GENERATION:
   - Generated 300 data points with 2 features
   - True number of clusters: 4
   - Cluster standard deviation: 0.8
 
2. K-MEANS CLUSTERING:
   - Number of clusters used: 4
   - Initialization method: k-means++
   - WCSS (inertia): 362.472
 
3. PERFORMANCE EVALUATION:
   - Silhouette Score: 0.834 (Excellent clustering quality)
   - Best k by silhouette score: 4
 
4. CLUSTER ANALYSIS:
   - Cluster 0: 75 points (25.0%) at (-2.64, 8.99)
   - Cluster 1: 75 points (25.0%) at (-6.84, -6.84)
   - Cluster 2: 75 points (25.0%) at (4.70, 2.03)
   - Cluster 3: 75 points (25.0%) at (-8.83, 7.22)
 
5. KEY OBSERVATIONS:
   - K-Means successfully identified the cluster structure
   - The elbow method suggests optimal k around the true value
   - Silhouette score indicates good clustering quality
   - Cluster assignments may differ from true labels but groupings are similar
 
============================================================