Handwritten_Digit_Recognition_(ML,_Difficulty_5_10).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries"
      ],
      "metadata": {
        "id": "h7_8NnGA0clS"
      },
      "execution_count": 138,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install dash plotly jupyter-dash  # Installing Dash, Plotly, and Jupyter Dash for building interactive web apps and visualizations\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dGegPG_T0pyr",
        "outputId": "8b22d15e-0504-4165-eba7-8c168026b93c"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: dash in /usr/local/lib/python3.11/dist-packages (2.18.2)\n",
            "Requirement already satisfied: plotly in /usr/local/lib/python3.11/dist-packages (5.24.1)\n",
            "Requirement already satisfied: jupyter-dash in /usr/local/lib/python3.11/dist-packages (0.4.2)\n",
            "Requirement already satisfied: Flask<3.1,>=1.0.4 in /usr/local/lib/python3.11/dist-packages (from dash) (3.0.3)\n",
            "Requirement already satisfied: Werkzeug<3.1 in /usr/local/lib/python3.11/dist-packages (from dash) (3.0.6)\n",
            "Requirement already satisfied: dash-html-components==2.0.0 in /usr/local/lib/python3.11/dist-packages (from dash) (2.0.0)\n",
            "Requirement already satisfied: dash-core-components==2.0.0 in /usr/local/lib/python3.11/dist-packages (from dash) (2.0.0)\n",
            "Requirement already satisfied: dash-table==5.0.0 in /usr/local/lib/python3.11/dist-packages (from dash) (5.0.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.11/dist-packages (from dash) (8.6.1)\n",
            "Requirement already satisfied: typing-extensions>=4.1.1 in /usr/local/lib/python3.11/dist-packages (from dash) (4.12.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from dash) (2.32.3)\n",
            "Requirement already satisfied: retrying in /usr/local/lib/python3.11/dist-packages (from dash) (1.3.4)\n",
            "Requirement already satisfied: nest-asyncio in /usr/local/lib/python3.11/dist-packages (from dash) (1.6.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from dash) (75.1.0)\n",
            "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.11/dist-packages (from plotly) (9.0.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from plotly) (24.2)\n",
            "Requirement already satisfied: ipython in /usr/local/lib/python3.11/dist-packages (from jupyter-dash) (7.34.0)\n",
            "Requirement already satisfied: ipykernel in /usr/local/lib/python3.11/dist-packages (from jupyter-dash) (5.5.6)\n",
            "Requirement already satisfied: ansi2html in /usr/local/lib/python3.11/dist-packages (from jupyter-dash) (1.9.2)\n",
            "Requirement already satisfied: Jinja2>=3.1.2 in /usr/local/lib/python3.11/dist-packages (from Flask<3.1,>=1.0.4->dash) (3.1.5)\n",
            "Requirement already satisfied: itsdangerous>=2.1.2 in /usr/local/lib/python3.11/dist-packages (from Flask<3.1,>=1.0.4->dash) (2.2.0)\n",
            "Requirement already satisfied: click>=8.1.3 in /usr/local/lib/python3.11/dist-packages (from Flask<3.1,>=1.0.4->dash) (8.1.8)\n",
            "Requirement already satisfied: blinker>=1.6.2 in /usr/local/lib/python3.11/dist-packages (from Flask<3.1,>=1.0.4->dash) (1.9.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from Werkzeug<3.1->dash) (3.0.2)\n",
            "Requirement already satisfied: zipp>=3.20 in /usr/local/lib/python3.11/dist-packages (from importlib-metadata->dash) (3.21.0)\n",
            "Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.11/dist-packages (from ipykernel->jupyter-dash) (0.2.0)\n",
            "Requirement already satisfied: traitlets>=4.1.0 in /usr/local/lib/python3.11/dist-packages (from ipykernel->jupyter-dash) (5.7.1)\n",
            "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.11/dist-packages (from ipykernel->jupyter-dash) (6.1.12)\n",
            "Requirement already satisfied: tornado>=4.2 in /usr/local/lib/python3.11/dist-packages (from ipykernel->jupyter-dash) (6.4.2)\n",
            "Requirement already satisfied: jedi>=0.16 in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (0.19.2)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (4.4.2)\n",
            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (0.7.5)\n",
            "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (3.0.50)\n",
            "Requirement already satisfied: pygments in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (2.18.0)\n",
            "Requirement already satisfied: backcall in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (0.2.0)\n",
            "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (0.1.7)\n",
            "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.11/dist-packages (from ipython->jupyter-dash) (4.9.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->dash) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->dash) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->dash) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->dash) (2024.12.14)\n",
            "Requirement already satisfied: six>=1.7.0 in /usr/local/lib/python3.11/dist-packages (from retrying->dash) (1.17.0)\n",
            "Requirement already satisfied: parso<0.9.0,>=0.8.4 in /usr/local/lib/python3.11/dist-packages (from jedi>=0.16->ipython->jupyter-dash) (0.8.4)\n",
            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.11/dist-packages (from pexpect>4.3->ipython->jupyter-dash) (0.7.0)\n",
            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.11/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython->jupyter-dash) (0.2.13)\n",
            "Requirement already satisfied: jupyter-core>=4.6.0 in /usr/local/lib/python3.11/dist-packages (from jupyter-client->ipykernel->jupyter-dash) (5.7.2)\n",
            "Requirement already satisfied: pyzmq>=13 in /usr/local/lib/python3.11/dist-packages (from jupyter-client->ipykernel->jupyter-dash) (24.0.1)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.11/dist-packages (from jupyter-client->ipykernel->jupyter-dash) (2.8.2)\n",
            "Requirement already satisfied: platformdirs>=2.5 in /usr/local/lib/python3.11/dist-packages (from jupyter-core>=4.6.0->jupyter-client->ipykernel->jupyter-dash) (4.3.6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wEgew9CI0p2G"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import warnings"
      ],
      "metadata": {
        "id": "5GOSjYb70cn2"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "warnings.filterwarnings(\"ignore\") # Suppress all warnings"
      ],
      "metadata": {
        "id": "l1V3Qkhe0cqS"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "h-36wqBF0ctO"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_datasets as tfds  # Import TensorFlow Datasets (TFDS) for loading datasets\n"
      ],
      "metadata": {
        "id": "bJgMYZIG0cw5"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np  # Import NumPy for numerical operations"
      ],
      "metadata": {
        "id": "WLiZr0MU0kY0"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt  # Import Matplotlib for visualizing data"
      ],
      "metadata": {
        "id": "sUJEO1uf0kbK"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf  # Import TensorFlow for machine learning tasks"
      ],
      "metadata": {
        "id": "N_YEVXt70kd2"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.utils import to_categorical  # Import utility to convert labels to one-hot encoding\n"
      ],
      "metadata": {
        "id": "zrMyz4KP0cz7"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras import layers, models  # Import layers and models from Keras to build the neural network\n"
      ],
      "metadata": {
        "id": "734VAflT0c2s"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import dash  # Import Dash for creating interactive web apps"
      ],
      "metadata": {
        "id": "uVTTw_qP0c5f"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from dash import dcc, html  # Import Dash components for layout and interactivity\n"
      ],
      "metadata": {
        "id": "IR8YrSps1Lfd"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import plotly.graph_objs as go  # Import Plotly for creating interactive plots\n"
      ],
      "metadata": {
        "id": "6e5ADkR81LiX"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix  # Import confusion matrix function for model evaluation\n"
      ],
      "metadata": {
        "id": "DkV0B2Ua1LnA"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns  # Import Seaborn for visualizing the confusion matrix\n"
      ],
      "metadata": {
        "id": "TMIu7xgY1Lpt"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "W4-IKHSS1WYN"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JEUXWaI11Lsl"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uolYrw8a1LvP"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Xg540diA1XrO"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "sRUBgb4g1X9K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1: Data Loading and Preprocessing"
      ],
      "metadata": {
        "id": "A7w1Qk9o1ZpU"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load MNIST dataset using TensorFlow Datasets (automatically handles downloading and preprocessing)\n"
      ],
      "metadata": {
        "id": "4-2sLvaw1Lx0"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data, test_data = tfds.load('mnist', as_supervised=True, split=['train', 'test'])  # Load train and test splits from MNIST dataset\n"
      ],
      "metadata": {
        "id": "MLt-E9Ea1hVu"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BUk7PQbX1hYa"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Normalize and preprocess the data"
      ],
      "metadata": {
        "id": "Une73y0X1hbj"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_image(image, label):\n",
        "    \"\"\"\n",
        "    Normalize the image to the [0, 1] range and reshape the image to (28, 28, 1).\n",
        "    This is done for both the training and test data.\n",
        "    \"\"\"\n",
        "    image = tf.cast(image, tf.float32) / 255.0  # Normalize pixel values to [0, 1]\n",
        "    image = tf.reshape(image, (28, 28, 1))  # Reshape image to 28x28 with 1 color channel (grayscale)\n",
        "    return image, label"
      ],
      "metadata": {
        "id": "18yFJAxO1heS"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Zq-bRhjR1n0K"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply preprocessing function to both training and test data"
      ],
      "metadata": {
        "id": "mQk8uQKL1n7C"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = train_data.map(preprocess_image)  # Apply preprocessing to training data\n"
      ],
      "metadata": {
        "id": "X7GPvdfG_CAu"
      },
      "execution_count": 132,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_data = test_data.map(preprocess_image)  # Apply preprocessing to test data\n"
      ],
      "metadata": {
        "id": "KA7BoGE41oBQ"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sOHxagMB1oGM"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Batch and shuffle the training data"
      ],
      "metadata": {
        "id": "G7xnOT-P1oJQ"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = train_data.shuffle(60000).batch(32)  # Shuffle the training data and batch into 32 samples per batch\n"
      ],
      "metadata": {
        "id": "IZFt06n51oMv"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_data = test_data.batch(32)  # Batch the test data into 32 samples per batch\n"
      ],
      "metadata": {
        "id": "FYfwnpDW1oPs"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8Ud_A0ZB1zM5"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the shape of the training data to verify"
      ],
      "metadata": {
        "id": "apZDjKuG1zP5"
      },
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for images, labels in train_data.take(1):  # Take one batch from the training data\n",
        "    print(\"Training data shape:\", images.shape)  # Print the shape of images in the batch\n",
        "    print(\"Labels shape:\", labels.shape)  # Print the shape of labels in the batch\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B8fJWjAY1zTb",
        "outputId": "08ba22f2-7930-40c2-fe68-44ba3354f9bd"
      },
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training data shape: (32, 28, 28, 1)\n",
            "Labels shape: (32,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "----\n",
        "---"
      ],
      "metadata": {
        "id": "BhJ6O_7A16DN"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eVkCgVir17jw"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "22VzKlS217nj"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "u-rLUbBO1710"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "ez1NALeZ18AZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 2: Data Visualization"
      ],
      "metadata": {
        "id": "cI-F-NEU19LD"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize the first 25 training images and their corresponding labels"
      ],
      "metadata": {
        "id": "RXE2rbp01-Nd"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig, axes = plt.subplots(5, 5, figsize=(10, 10))  # Create a 5x5 grid of subplots\n",
        "axes = axes.flatten()  # Flatten the 2D array of axes to make it easier to loop through\n",
        "\n",
        "for i in range(25):  # Loop through the first 25 images in the training set\n",
        "    ax = axes[i]  # Get the current subplot axis\n",
        "    ax.imshow(train_images[i].reshape(28, 28), cmap='gray')  # Display image, reshaped to 28x28, in grayscale\n",
        "    ax.set_title(f\"Label: {train_labels[i].argmax()}\")  # Display the label (argmax for one-hot encoded labels)\n",
        "    ax.axis('off')  # Turn off axis lines for better visualization\n",
        "\n",
        "plt.tight_layout()  # Adjust subplots to minimize gaps between them\n",
        "plt.show()  # Show the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 661
        },
        "id": "HJ_mL3hO1-Q2",
        "outputId": "4e16444b-5650-4f60-f161-afbd3c6dd0e9"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x1000 with 25 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "QaeFFuPF2aEz"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VkklBrN22bS9"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "oKCcBBfq2bXN"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "l453rS4a2blt"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "vLB1bgOs2bzZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 3: Model Architecture"
      ],
      "metadata": {
        "id": "TkhZrvwT2dHu"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Build the Convolutional Neural Network (CNN) model"
      ],
      "metadata": {
        "id": "cnuV-GeM2fkn"
      },
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = models.Sequential()  # Initialize a Sequential model (stack of layers)\n"
      ],
      "metadata": {
        "id": "IsUrG2Wj2fof"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "R25cB6Ll2fr7"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add a convolutional layer with 32 filters, 3x3 kernel size, ReLU activation, and input shape of (28, 28, 1)\n"
      ],
      "metadata": {
        "id": "KaShC-ar2fwB"
      },
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))\n"
      ],
      "metadata": {
        "id": "Kve3uYGr1-Uj"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "n9NRH3Le2pGi"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add a max-pooling layer to reduce spatial dimensions (2x2 pool size)"
      ],
      "metadata": {
        "id": "uQy34Fmi2pKN"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.MaxPooling2D((2, 2)))"
      ],
      "metadata": {
        "id": "KjaSxNjM2pOR"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Eba1Np5J2pR_"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add another convolutional layer with 64 filters and 3x3 kernel size"
      ],
      "metadata": {
        "id": "1ovUV5PL2pVr"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))"
      ],
      "metadata": {
        "id": "x1rdfgt62pZd"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "kweGizj_2pdN"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add another max-pooling layer to further reduce spatial dimensions"
      ],
      "metadata": {
        "id": "3cKTItZN2phX"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.MaxPooling2D((2, 2)))"
      ],
      "metadata": {
        "id": "eUjYmhyj1-bq"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "PSIsWVFc20On"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add a third convolutional layer with 64 filters"
      ],
      "metadata": {
        "id": "Y92JgirB20de"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))"
      ],
      "metadata": {
        "id": "unDEoKjE20hu"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GIEcfy0h20ld"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Flatten the 2D feature maps into a 1D vector for the dense layers"
      ],
      "metadata": {
        "id": "Htfs39UD20pV"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Flatten())"
      ],
      "metadata": {
        "id": "br4JUbma20s9"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ed6g7SSd20wi"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add a fully connected (dense) layer with 64 neurons and ReLU activation"
      ],
      "metadata": {
        "id": "-cGdMzxi200T"
      },
      "execution_count": 63,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Dense(64, activation='relu'))"
      ],
      "metadata": {
        "id": "vfzEkz252033"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "z3QHntMD1-fD"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add the output layer with 10 neurons (one for each digit) and softmax activation for classification\n"
      ],
      "metadata": {
        "id": "-3Aiffcs1zXa"
      },
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Dense(10, activation='softmax'))"
      ],
      "metadata": {
        "id": "2IzsldbD1zbz"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "W-6QV25N3G8D"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the summary of the model architecture to see the details"
      ],
      "metadata": {
        "id": "bTayIL8l3G_v"
      },
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        },
        "id": "9uxHMcsS3HDr",
        "outputId": "b4618239-7f1a-4987-cf81-a6ffbaa33ead"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1mModel: \"sequential_2\"\u001b[0m\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_2\"</span>\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                        \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape               \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m        Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m26\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │             \u001b[38;5;34m320\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ max_pooling2d_4 (\u001b[38;5;33mMaxPooling2D\u001b[0m)       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m64\u001b[0m)          │          \u001b[38;5;34m18,496\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ max_pooling2d_5 (\u001b[38;5;33mMaxPooling2D\u001b[0m)       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m64\u001b[0m)            │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m64\u001b[0m)            │          \u001b[38;5;34m36,928\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten_2 (\u001b[38;5;33mFlatten\u001b[0m)                  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m576\u001b[0m)                 │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_4 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)                  │          \u001b[38;5;34m36,928\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_5 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)                  │             \u001b[38;5;34m650\u001b[0m │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃<span style=\"font-weight: bold\"> Layer (type)                         </span>┃<span style=\"font-weight: bold\"> Output Shape                </span>┃<span style=\"font-weight: bold\">         Param # </span>┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ conv2d_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │             <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ max_pooling2d_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">11</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">11</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)          │          <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ max_pooling2d_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">5</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">5</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)            │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)            │          <span style=\"color: #00af00; text-decoration-color: #00af00\">36,928</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)                  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">576</span>)                 │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)                  │          <span style=\"color: #00af00; text-decoration-color: #00af00\">36,928</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)                  │             <span style=\"color: #00af00; text-decoration-color: #00af00\">650</span> │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m93,322\u001b[0m (364.54 KB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">93,322</span> (364.54 KB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m93,322\u001b[0m (364.54 KB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">93,322</span> (364.54 KB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "----\n",
        "----"
      ],
      "metadata": {
        "id": "YG1sgC4a3Me7"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vmnRBPCa3Nzj"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1Jkqh_7W3N4K"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jpoeULV980xz"
      },
      "execution_count": 88,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "jfiUxlDN3OYG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 4: Model Compilation"
      ],
      "metadata": {
        "id": "EjLk6m1r3Pof"
      },
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model using the Adam optimizer and categorical crossentropy loss function for multi-class classification\n"
      ],
      "metadata": {
        "id": "djRj0qX_1zey"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "TEEO0fyG1ziK"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "----\n",
        "----"
      ],
      "metadata": {
        "id": "lWgdRLjM3fiZ"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DZ73ECoa3g5l"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "PuBulmzU3g-t"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dRj3KlxX3hE8"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "----\n",
        "----"
      ],
      "metadata": {
        "id": "b4XFh4rH3hLT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 5: Model Training"
      ],
      "metadata": {
        "id": "4bt7Wi6Z3iZI"
      },
      "execution_count": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model with the training data"
      ],
      "metadata": {
        "id": "2vmMiR5n9Sz-"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(train_images, train_labels,\n",
        "                    epochs=10,  # Number of epochs to train\n",
        "                    batch_size=64,  # Batch size for each update\n",
        "                    validation_data=(test_images, test_labels))  # Use test data for validation\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQ_Nl9uI9J-c",
        "outputId": "e06bcdf8-abab-41b6-ecfa-39cf8f374a45"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 9ms/step - accuracy: 0.9964 - loss: 0.0138 - val_accuracy: 0.9917 - val_loss: 0.0326\n",
            "Epoch 2/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 4ms/step - accuracy: 0.9985 - loss: 0.0054 - val_accuracy: 0.9916 - val_loss: 0.0410\n",
            "Epoch 3/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 6ms/step - accuracy: 0.9985 - loss: 0.0048 - val_accuracy: 0.9897 - val_loss: 0.0501\n",
            "Epoch 4/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 5ms/step - accuracy: 0.9987 - loss: 0.0039 - val_accuracy: 0.9916 - val_loss: 0.0357\n",
            "Epoch 5/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 5ms/step - accuracy: 0.9986 - loss: 0.0037 - val_accuracy: 0.9911 - val_loss: 0.0400\n",
            "Epoch 6/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 5ms/step - accuracy: 0.9985 - loss: 0.0050 - val_accuracy: 0.9926 - val_loss: 0.0380\n",
            "Epoch 7/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 5ms/step - accuracy: 0.9988 - loss: 0.0038 - val_accuracy: 0.9924 - val_loss: 0.0406\n",
            "Epoch 8/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 6ms/step - accuracy: 0.9989 - loss: 0.0036 - val_accuracy: 0.9909 - val_loss: 0.0480\n",
            "Epoch 9/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 5ms/step - accuracy: 0.9987 - loss: 0.0037 - val_accuracy: 0.9912 - val_loss: 0.0447\n",
            "Epoch 10/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 4ms/step - accuracy: 0.9992 - loss: 0.0030 - val_accuracy: 0.9903 - val_loss: 0.0490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "fZ2jlBUX34AX"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TlD208nI35Vq"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "mezgwmOs35as"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zCnJiSgs35fQ"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "----\n",
        "----"
      ],
      "metadata": {
        "id": "xQ5gRDpG35ov"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 6: Model Evaluation"
      ],
      "metadata": {
        "id": "OX3o8XMf3620"
      },
      "execution_count": 92,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model on the test data to see how well it generalizes to new, unseen data\n"
      ],
      "metadata": {
        "id": "Btm6dy_j3xaq"
      },
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss, test_accuracy = model.evaluate(test_images, test_labels, verbose=2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7WK1DAzk1oTF",
        "outputId": "62b80b92-c97d-4751-b302-2b89d0917d3c"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 - 1s - 3ms/step - accuracy: 0.9903 - loss: 0.0490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sLsi6rBU1hhU"
      },
      "execution_count": 94,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the test accuracy and loss values"
      ],
      "metadata": {
        "id": "EGzSlby_1L0v"
      },
      "execution_count": 95,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n",
        "print(f\"Test Loss: {test_loss:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Csz67wa61Vy8",
        "outputId": "52dfa253-312f-48ca-eaaa-1fae31895c6d"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy: 0.9903\n",
            "Test Loss: 0.0490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "XiUKSG-94HVV"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "54n-2Out4Itv"
      },
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nLmA3gbg4I0a"
      },
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WmN8Vvb_4I_s"
      },
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "hvZ2dnd04JF-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 8: Making Predictions"
      ],
      "metadata": {
        "id": "Sj32ApwE4KdO"
      },
      "execution_count": 97,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get predictions on the first 10 test images"
      ],
      "metadata": {
        "id": "T2ARr3B14EcW"
      },
      "execution_count": 98,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = model.predict(test_images[:10])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N-2EWQZV4Ejn",
        "outputId": "1d64e0bb-bc86-4e08-e4b0-bd7e786b83ad"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 240ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eayW2vWC4Eot"
      },
      "execution_count": 99,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert the predictions to class labels (highest probability)"
      ],
      "metadata": {
        "id": "YK1hmBVg4Es_"
      },
      "execution_count": 100,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predicted_labels = np.argmax(predictions, axis=1)"
      ],
      "metadata": {
        "id": "VYAAkXyX4Ext"
      },
      "execution_count": 101,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "true_labels = np.argmax(test_labels[:10], axis=1)  # Convert one-hot labels to integer labels\n"
      ],
      "metadata": {
        "id": "iFg0jgIJ4E2D"
      },
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "O5TJ2Pfl4UWU"
      },
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the predicted and true labels for comparison"
      ],
      "metadata": {
        "id": "9nhyhNLG4Uaz"
      },
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10):\n",
        "    print(f\"Image {i + 1}:\")\n",
        "    print(f\"Predicted Label: {predicted_labels[i]}\")\n",
        "    print(f\"True Label: {true_labels[i]}\")\n",
        "    print(\"-\" * 30)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BeWL0IYG4UgR",
        "outputId": "84fb41c4-a387-4f10-cdb1-d15dede04f72"
      },
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image 1:\n",
            "Predicted Label: 7\n",
            "True Label: 7\n",
            "------------------------------\n",
            "Image 2:\n",
            "Predicted Label: 2\n",
            "True Label: 2\n",
            "------------------------------\n",
            "Image 3:\n",
            "Predicted Label: 1\n",
            "True Label: 1\n",
            "------------------------------\n",
            "Image 4:\n",
            "Predicted Label: 0\n",
            "True Label: 0\n",
            "------------------------------\n",
            "Image 5:\n",
            "Predicted Label: 4\n",
            "True Label: 4\n",
            "------------------------------\n",
            "Image 6:\n",
            "Predicted Label: 1\n",
            "True Label: 1\n",
            "------------------------------\n",
            "Image 7:\n",
            "Predicted Label: 4\n",
            "True Label: 4\n",
            "------------------------------\n",
            "Image 8:\n",
            "Predicted Label: 9\n",
            "True Label: 9\n",
            "------------------------------\n",
            "Image 9:\n",
            "Predicted Label: 5\n",
            "True Label: 5\n",
            "------------------------------\n",
            "Image 10:\n",
            "Predicted Label: 9\n",
            "True Label: 9\n",
            "------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "yNw4L6sS4aXW"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "se9JR1LY4bpb"
      },
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "o42RucQa4bvX"
      },
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "j0Tgid7S4b0W"
      },
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "CDgpvxZt4cAL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 9: Visualizing Predictions"
      ],
      "metadata": {
        "id": "z3cEMO664c_-"
      },
      "execution_count": 105,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10, 5)) # Set up the plot\n",
        "\n",
        "# Loop through the first 10 test images and display them along with their predictions\n",
        "for i in range(10):\n",
        "    plt.subplot(2, 5, i + 1)  # Create a subplot (2 rows, 5 columns)\n",
        "\n",
        "    # Display the image\n",
        "    plt.imshow(test_images[i].reshape(28, 28), cmap='gray')\n",
        "\n",
        "    # Check if the prediction matches the true label\n",
        "    if predicted_labels[i] == true_labels[i]:\n",
        "        color = 'green'  # Correct prediction\n",
        "    else:\n",
        "        color = 'red'    # Incorrect prediction\n",
        "\n",
        "    # Display the true and predicted labels\n",
        "    plt.title(f\"True: {true_labels[i]}\\nPred: {predicted_labels[i]}\", color=color)\n",
        "\n",
        "    plt.axis('off')  # Turn off axis for cleaner visualization\n",
        "\n",
        "plt.tight_layout()  # Adjust subplots to avoid overlap\n",
        "plt.show()  # Show the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "id": "lx48hklH4Ukw",
        "outputId": "01ccdf32-7942-4e60-c00c-dfd5205da2d9"
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "rdk16jST4sX0"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_-SR64_x4taF"
      },
      "execution_count": 106,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Pd3oyrea4tgD"
      },
      "execution_count": 106,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "W6Nj7m584tlU"
      },
      "execution_count": 106,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "nnLug1Hc4trf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 10: Confusion Matrix"
      ],
      "metadata": {
        "id": "aTL7HF1d4uqf"
      },
      "execution_count": 107,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute confusion matrix to evaluate the performance of the model"
      ],
      "metadata": {
        "id": "UPfQ98kE1V3U"
      },
      "execution_count": 108,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cm = confusion_matrix(true_labels, predicted_labels)"
      ],
      "metadata": {
        "id": "06LZzH3L1V7z"
      },
      "execution_count": 109,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "QycjQpe44ysK"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the confusion matrix as a heatmap using Seaborn"
      ],
      "metadata": {
        "id": "_tEgVMcD4yxq"
      },
      "execution_count": 110,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=np.arange(10), yticklabels=np.arange(10))\n",
        "plt.title('Confusion Matrix')  # Set the title of the confusion matrix\n",
        "plt.xlabel('Predicted Label')  # Label for the x-axis\n",
        "plt.ylabel('True Label')  # Label for the y-axis\n",
        "plt.show()  # Display the confusion matrix heatmap"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 543
        },
        "id": "UziXfZIG4y5q",
        "outputId": "c5386865-30a1-4d66-893d-e6c14434a9e8"
      },
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "EW4k9q2w49dj"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6l4CDt824-my"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WQRnOR3g4-tH"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sczJ3z2C4-yk"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "8yiNKQbW4_3A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 11: Model Persistence"
      ],
      "metadata": {
        "id": "td342mUo5BAo"
      },
      "execution_count": 112,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the trained model to a file (so it can be loaded later without retraining)\n"
      ],
      "metadata": {
        "id": "owtGwXAH5BG7"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.save('handwritten_digit_recognition_model.h5')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i76Up_f95BNS",
        "outputId": "03f5171d-77eb-4395-b98e-f2cf4cf3427e"
      },
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "-----\n",
        "----"
      ],
      "metadata": {
        "id": "vk3dW7Kc5IrF"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3uCC8fOK5J2P"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xXK6sZlC5J8o"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4GGDBL_s5KkA"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "0yfXFsYU5KqF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 12: Load the Saved Model"
      ],
      "metadata": {
        "id": "QLn6drxt5L3l"
      },
      "execution_count": 115,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the previously saved model from the .h5 file"
      ],
      "metadata": {
        "id": "nbB--OcN5L-K"
      },
      "execution_count": 116,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model = tf.keras.models.load_model('handwritten_digit_recognition_model.h5')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0J9uuSJd5MED",
        "outputId": "c33f68e2-eaae-49d7-95ac-be9eb388e07f"
      },
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "dFT9u9ef5Sp1"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BryKoDLY5TwD"
      },
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZOjoqDc15T24"
      },
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DjgdH-L65UTl"
      },
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "bFgSVe3y5UaC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 13: Evaluate the Loaded Model"
      ],
      "metadata": {
        "id": "zt1xAC3H5VY9"
      },
      "execution_count": 118,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the loaded model on the test data to check its performance after loading\n"
      ],
      "metadata": {
        "id": "MP1KyrHo5MKW"
      },
      "execution_count": 119,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss, test_accuracy = loaded_model.evaluate(test_images, test_labels, verbose=2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "INf3QVHJ5anJ",
        "outputId": "52ca07cf-4af2-45c7-a898-00d9b6a6d46c"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 - 1s - 5ms/step - accuracy: 0.9903 - loss: 0.0490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pEgkZRYZ5ask"
      },
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the test accuracy and loss for the loaded model"
      ],
      "metadata": {
        "id": "gICo_i0U5ayL"
      },
      "execution_count": 121,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Test Accuracy of the loaded model: {test_accuracy:.4f}\")\n",
        "print(f\"Test Loss of the loaded model: {test_loss:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o9gXFEJD5a4r",
        "outputId": "68793d56-5816-48b9-822f-4b3a6953dfac"
      },
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy of the loaded model: 0.9903\n",
            "Test Loss of the loaded model: 0.0490\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "9juA5vIJ5jGH"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "z5rpxpdm5kV4"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "I169BuIu5keX"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tCNC8uHW5kku"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "xPVU24v45lWt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 14: Dash Web App for Displaying Predictions"
      ],
      "metadata": {
        "id": "kLhh0PZ_5msf"
      },
      "execution_count": 123,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize Dash app"
      ],
      "metadata": {
        "id": "313-yB-65mzw"
      },
      "execution_count": 124,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "app = dash.Dash(__name__)"
      ],
      "metadata": {
        "id": "bJViY4Ww5kqs"
      },
      "execution_count": 125,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JFWPXhS15a-D"
      },
      "execution_count": 127,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define layout of the app (including a slider to select images and display the image with its predicted label)\n"
      ],
      "metadata": {
        "id": "RrJcFeZH4-7K"
      },
      "execution_count": 137,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "app.layout = html.Div([\n",
        "    html.H1(\"MNIST Handwritten Digit Recognition\"),  # Heading of the web page\n",
        "    dcc.Slider(  # Slider to select which image to display\n",
        "        id='image-slider',\n",
        "        min=0,\n",
        "        max=100,  # Slider range from 0 to 100\n",
        "        step=1,\n",
        "        value=0,  # Default value is the first image\n",
        "        marks={i: str(i) for i in range(0, 101, 10)},  # Display marks at every 10th index\n",
        "    ),\n",
        "    html.Div(id='image-display'),  # Area to display the image and predicted label\n",
        "])"
      ],
      "metadata": {
        "id": "NFXcWDPf4y_9"
      },
      "execution_count": 127,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#  Define the Callback to Update Image"
      ],
      "metadata": {
        "id": "k4xiLeZn52cL"
      },
      "execution_count": 128,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@app.callback(\n",
        "    dash.dependencies.Output('image-display', 'children'),\n",
        "    [dash.dependencies.Input('image-slider', 'value')]\n",
        ")\n",
        "def update_image(index):\n",
        "    \"\"\"\n",
        "    Callback function to update the displayed image and predicted label based on slider value.\n",
        "    \"\"\"\n",
        "    image = test_images[index].reshape(28, 28)  # Get the selected image\n",
        "    label = true_labels[index]  # Get the true label\n",
        "    predicted_label = predicted_labels[index]  # Get the predicted label\n",
        "\n",
        "    # Display the image and prediction\n",
        "    return html.Div([\n",
        "        html.Img(src='data:image/png;base64,{}'.format(base64.b64encode(image.tobytes()).decode()),\n",
        "                 style={'height': '300px', 'width': '300px'}),\n",
        "        html.H3(f\"True Label: {label}, Predicted Label: {predicted_label}\")\n",
        "    ])"
      ],
      "metadata": {
        "id": "76_3We--4zFM"
      },
      "execution_count": 129,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TWGWV2CG58D2"
      },
      "execution_count": 129,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Run the app on localhost"
      ],
      "metadata": {
        "id": "KQ8aRNZS58Ji"
      },
      "execution_count": 130,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if __name__ == '__main__':\n",
        "    app.run_server(debug=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 671
        },
        "id": "sW8FFCjc4zKR",
        "outputId": "61fe85a0-7474-43ab-940a-b2fff1eb388a"
      },
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "(async (port, path, width, height, cache, element) => {\n",
              "    if (!google.colab.kernel.accessAllowed && !cache) {\n",
              "      return;\n",
              "    }\n",
              "    element.appendChild(document.createTextNode(''));\n",
              "    const url = await google.colab.kernel.proxyPort(port, {cache});\n",
              "    const iframe = document.createElement('iframe');\n",
              "    iframe.src = new URL(path, url).toString();\n",
              "    iframe.height = height;\n",
              "    iframe.width = width;\n",
              "    iframe.style.border = 0;\n",
              "    iframe.allow = [\n",
              "        'accelerometer',\n",
              "        'autoplay',\n",
              "        'camera',\n",
              "        'clipboard-read',\n",
              "        'clipboard-write',\n",
              "        'gyroscope',\n",
              "        'magnetometer',\n",
              "        'microphone',\n",
              "        'serial',\n",
              "        'usb',\n",
              "        'xr-spatial-tracking',\n",
              "    ].join('; ');\n",
              "    element.appendChild(iframe);\n",
              "  })(8050, \"/\", \"100%\", 650, false, window.element)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "---"
      ],
      "metadata": {
        "id": "GATfKzXA6AHI"
      }
    }
  ]
}