print(X.shape) # (number of images, rumber of rows, number of columns)
print(y.shape)

# Lets look at image at index=0. It is 2D array of 8x8=64 pixels values
X[0]

# Visualize the image at index=0

img_idx=0

plt.imshow(X[img_idx], cmap='gray')
plt.colorbar()
plt.title(f"Digit: {y[img_idx]}")
plt.show()

# Lets see the raw numbers
img_idx=0

print(X[img_idx].shape)
print("--------------------")
# np.set_printoptions(linewidth=150, precision=2, suppress=True)  # Adjust formatting
print(X[img_idx])

print("--------------------")

print(y[img_idx])

# Plot the pixel values on the image
img_idx = 0
img_matrix = X[img_idx]

# annot=True shows values, fmt="g" prevents scientific notation
sns.heatmap(img_matrix, annot=True, fmt="g", cmap="gray", cbar=True)
plt.title(f"Digit: {y[img_idx]}")
plt.show()

# Lets look at X[1], which is digit 1

img_idx=1

plt.imshow(X[img_idx], cmap='gray')
plt.colorbar()
plt.title(f"Digit: {y[img_idx]}")
plt.show()

# The raw values of the pixels are 
img_idx=1

print(X[img_idx].shape)
print("--------------------")
# np.set_printoptions(linewidth=150, precision=2, suppress=True)  # Adjust formatting
print(X[img_idx])

print("--------------------")

print(y[img_idx])

# Flatten the images if needed (convert 8x8 into 1D array of 64 pixels)
X = X.reshape(X.shape[0], -1)  # Converts (1797, 8, 8) -> (1797, 64)
print(X.shape)

#Lets see how does X[0] looks like now after reshape. It is 1D array, with 64 features, aka columns
print(X[0])

# Apply KMeans clustering: I am picking k=10 because I already the number of clusters

kmean = KMeans(n_clusters=10, random_state=42)
clusters = kmean.fit_predict(X)  # Clustering on the entire dataset


# Display the shape of the cluster centers
print(f"Cluster Centers Shape: {kmean.cluster_centers_.shape}")  # Should be (10, 64)

# We see ten clusters in 64 dimensions. 
# Let's visualize each of these cluster centers to see what they represent:
# I pick one digit from each clusters

import matplotlib.pyplot as plt

# Create a figure with a specified size (8 inches wide, 3 inches tall)
fig = plt.figure(figsize=(8, 3))  

# Loop through all 10 clusters found by KMeans
for i in range(10):
    # Add a subplot to the figure: a 2-row, 5-column grid 
    # '1 + i' ensures each image appears in the correct position
    ax = fig.add_subplot(2, 5, 1 + i, xticks=[], yticks=[])  

    # Reshape the i-th cluster center from 1D (64 pixels) back to 2D (8x8 image)
    # Use a grayscale colormap (binary) to display the image
    ax.imshow(kmean.cluster_centers_[i].reshape((8, 8)), cmap=plt.cm.binary)  

    # Add a title to each subplot showing the cluster number
    ax.set_title(f"Cluster {i}")

# Display the full figure with all the subplots
plt.show()

# Lets see all the images in cluster 0

# 1. Get the images and actual labels belonging only to cluster 0
cluster_N_images = X[clusters == 0]
cluster_N_labels = y[clusters == 0]
print(f"Total images in cluster 0: {len(cluster_N_images)}")


# 2. Define a grid layout (e.g., a 4x5 grid for the first 20 images)
rows, cols = 4, 5
fig, axes = plt.subplots(rows, cols, figsize=(10, 8))

for i, ax in enumerate(axes.flat):
    if i < len(cluster_N_images):
        # Reshape the flat 64-element vector back to 8x8
        img = cluster_N_images[i].reshape(8, 8)
        
        # Display the image
        ax.imshow(img, cmap='gray')
        
        # Plot the actual label from variable 'y' as the title
        ax.set_title(f"True Label: {cluster_N_labels[i]}", fontsize=10, weight='bold')
        
    ax.axis('off')  # Hide grid lines and axis numbers

plt.tight_layout()
plt.show()

# Observation: It seems 7

# Lets see all the images in cluster 3

# 1. Get the images and actual labels belonging only to cluster 0
cluster_N_images = X[clusters == 3]
cluster_N_labels = y[clusters == 3]
print(f"Total images in cluster 3: {len(cluster_N_images)}")


# 2. Define a grid layout (e.g., a 4x5 grid for the first 20 images)
rows, cols = 4, 5
fig, axes = plt.subplots(rows, cols, figsize=(10, 8))

for i, ax in enumerate(axes.flat):
    if i < len(cluster_N_images):
        # Reshape the flat 64-element vector back to 8x8
        img = cluster_N_images[i].reshape(8, 8)
        
        # Display the image
        ax.imshow(img, cmap='gray')
        
        # Plot the actual label from variable 'y' as the title
        ax.set_title(f"True Label: {cluster_N_labels[i]}", fontsize=10, weight='bold')
        
    ax.axis('off')  # Hide grid lines and axis numbers

plt.tight_layout()
plt.show()

# Observation: It seems 7

# Print the digits belonging to each cluster
for i in range(10):  # For each cluster
    mask = (clusters == i)  # Get indices of data points belonging to cluster i
    digits_in_cluster = y[mask]  # Get the true labels (digits) of points in this cluster
    print(f"Cluster {i} contains the following digits: {digits_in_cluster}")

# Map each cluster to the most common actual digit
from scipy.stats import mode

# Map each cluster to the most common actual digit
cluster_to_digit = {}
for i in range(10):  # Loop through each cluster
    mask = (clusters == i)  # Get indices where cluster == i
    if np.sum(mask) > 0:  # Ensure the cluster is not empty
        most_common_digit = mode(y[mask], keepdims=True).mode[0]  # Fix IndexError by using keepdims=True
        cluster_to_digit[i] = most_common_digit
    else:
        cluster_to_digit[i] = None  # Handle empty clusters

# Print the mapping of clusters to digits
print("Cluster to Digit Mapping:")
for cluster, digit in cluster_to_digit.items():
    print(f"Cluster {cluster} → Digit {digit}")

from sklearn.metrics import accuracy_score

# Map predicted labels (clusters) to actual digit labels
predicted_labels = np.array([cluster_to_digit[cluster] for cluster in clusters])

# Calculate accuracy using accuracy_score
accuracy = accuracy_score(y, predicted_labels)

# Display the results
print(f"Clustering Accuracy: {accuracy * 100:.2f}%")

from sklearn.metrics import confusion_matrix

# Compute the confusion matrix
cm = confusion_matrix(y, predicted_labels)

# Plot the confusion matrix using Seaborn heatmap
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=range(10), yticklabels=range(10))
plt.title("Confusion Matrix for KMeans Clustering")
plt.xlabel("Predicted Labels")
plt.ylabel("True Labels")
plt.show()

# I want to see percentage of above...

# Compute confusion matrix (rows = true labels, columns = predicted labels)
cm = confusion_matrix(y, predicted_labels)

# Normalize by row (i.e., true label count) to get percentages
cm_percent = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] * 100

# Plot
plt.figure(figsize=(8, 6))
sns.heatmap(cm_percent, annot=True, fmt=".1f", cmap="Blues", xticklabels=range(10), yticklabels=range(10))
plt.title("Confusion Matrix (Percentages) for KMeans Clustering")
plt.xlabel("Predicted Labels")
plt.ylabel("True Labels")
plt.show()