Source Code

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, precision_recall_fscore_support
import matplotlib.pyplot as plt
import numpy as np

# Load and preprocess the MNIST dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # Normalize pixel values to between 0 and 1

# Reshape the data to fit the model
x_train = np.expand_dims(x_train, axis=-1)
x_test = np.expand_dims(x_test, axis=-1)

# One-hot encode the labels
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Build the CNN model
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

# Compile the model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Train the model
history = model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

# Save the model
model.save('mnist_cnn_model.h5')

# Plot accuracy and loss graphs
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"\nTest Accuracy: {test_acc * 100:.2f}%")

# Select random images from the test set
num_images = 10
random_indices = np.random.choice(len(x_test), num_images)

# Make predictions
predictions = np.argmax(model.predict(x_test[random_indices]), axis=-1)

# Plot the images along with their true and predicted labels
plt.figure(figsize=(12, 6))
for i, idx in enumerate(random_indices):
    plt.subplot(2, 5, i + 1)
    plt.imshow(x_test[idx].reshape(28, 28), cmap='gray')
    plt.title(f'True: {np.argmax(y_test[idx])}, Predicted: {predictions[i]}')
    plt.axis('off')
plt.show()

# Evaluate performance using different metrics
print("\nConfusion Matrix:")
print(confusion_matrix(np.argmax(y_test, axis=1), np.argmax(model.predict(x_test), axis=-1)))

print("\nClassification Report:")
print(classification_report(np.argmax(y_test, axis=1), np.argmax(model.predict(x_test), axis=-1)))

# Calculate overall accuracy and class-wise accuracies
overall_accuracy = accuracy_score(np.argmax(y_test, axis=1), np.argmax(model.predict(x_test), axis=-1))
class_accuracies = np.sum(np.argmax(y_test, axis=1) == np.argmax(model.predict(x_test), axis=-1)) / len(np.argmax(model.predict(x_test), axis=-1))

print(f"\nOverall Accuracy: {overall_accuracy * 100:.2f}%")
print(f"Class-wise Accuracy: {class_accuracies * 100:.2f}%")

# Calculate precision, recall, and F1 Score for each class
precision, recall, f1_score, _ = precision_recall_fscore_support(np.argmax(y_test, axis=1), np.argmax(model.predict(x_test), axis=-1), average=None)

print("\nPrecision for each class:")
for i in range(10):
    print(f"Class {i}: {precision[i]:.4f}")

print("\nRecall for each class:")
for i in range(10):
    print(f"Class {i}: {recall[i]:.4f}")

print("\nF1 Score for each class:")
for i in range(10):
    print(f"Class {i}: {f1_score[i]:.4f}")