02.2_mnist_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Practicum AI Logo image](images/practicum_ai_logo.png) <img src='images/practicumai_deep_learning.png' alt='Practicum AI: Deep Learning Foundations icon' align='right' width=50>\n",
    "\n",
    "***\n",
    "# *Practicum AI:* Deep Learning - MNIST Classifier\n",
    "\n",
    "This exercise adapted from Baig et al. (2020) <i>The Deep Learning Workshop</i> from <a href=\"https://www.packtpub.com/product/the-deep-learning-workshop/9781839219856\">Packt Publishers</a> (Exercise 2.07, page 92).\n",
    "\n",
    "## Amelia's AI Adventure Continues...\n",
    "\n",
    "<img alt=\"A cartoon of Dr. Amelia's dog looking at a computer with a stack of papers next to it showing some handwritten digits.\" src=\"images/Amelias_Dog_MNIST.jpg\" padding=20 align=\"right\" width=250>Amelia and her nutrition studies are back! After her adventures with image recognition and binary classification, she's curious to dive deeper. \n",
    "\n",
    "While Amelia's data collection process is working for most participants in her study, some do not like using the phone application to submit their survey responses. They keep sending in handwritten responses. Realizing that the data from these study participants is still vital to her research, Dr. Amelia is now looking to automate entering these responses using a program to read the numbers that make up the survey responses.\n",
    "\n",
    "Again, Amelia decides to start with the basics: recognizing handwritten numbers. That's where the MNIST dataset comes in. With its vast collection of handwritten digits, it's the perfect training ground for Amelia's next AI adventure.\n",
    "\n",
    "**Note:** The cartoon of Dr Amelia's dog was generated with AI's assistance.\n",
    "\n",
    "Training a model on the MNIST dataset is often considered the \"Hello world!\" of modern computer vision. It is a commonly used first introduction to image recognition with deep learning.\n",
    "\n",
    "\n",
    "![AI Application Development Pathway model](https://github.com/PracticumAI/deep_learning_2_draft/blob/main/M3-AppDev.00_00_22_23.Still001.png?raw=true)\n",
    "\n",
    " >&#128221; While you're going through this notebook, see if you can figure out which steps here are associated with each of the steps of the Development Pathway.\n",
    "\n",
    "## MNIST Handwritten Digit Classification Dataset\n",
    "\n",
    "The [MNIST](http://yann.lecun.com/exdb/mnist/) (Modified National Institute of Standards and Technology) training dataset contains 60,000 28×28 pixel grayscale images of handwritten single digits between 0 and 9, with an additional 10,000 images available for testing. \n",
    "\n",
    "The MNIST dataset is frequently used in machine learning research and has become a standard benchmark for image classification models. Top-performing models often achieve a classification accuracy above 99%, with an error rate between 0.4% and 0.2% on the hold-out test dataset.\n",
    "\n",
    "In this exercise, you will implement a deep (multi-layer) neural network capable of classifying these images of handwritten digits into one of 10 classes. \n",
    "\n",
    "Amelia knows that to start any AI project, she'll need the right tools. She begins by importing the necessary libraries to set the stage for her digit-reading neural network.\n",
    "\n",
    "## 1. Import libraries\n",
    "\n",
    "Import the necessary libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf   # Import the TensorFlow library, which provides tools for machine learning and deep learning.\n",
    "import pandas as pd \n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt  # Import the matplotlib library for plotting and visualization.\n",
    "# This line allows for the display of plots directly within the Jupyter notebook interface.\n",
    "%matplotlib inline  \n",
    " \n",
    "# Import Keras libraries\n",
    "from tensorflow.keras.models import Sequential  # Import the Sequential model: a linear stack of layers from Keras module in TensorFlow.\n",
    "from tensorflow.keras.layers import Dense  # Import the Dense layer: a fully connected neural network layer from Keras module in TensorFlow.\n",
    "from tensorflow.keras.layers import Flatten  # Import the Flatten layer: used to convert input data into a 1D array from Keras module in TensorFlow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Load the MNIST dataset\n",
    "\n",
    "Amelia will need to import the MNIST dataset from the [Keras module](https://keras.io/api/datasets/mnist/). The `train_images` and `test_images` variables contain the training and test images, while `train_labels` and `test_labels` contain the corresponding labels for each item in those datasets.  \n",
    "\n",
    "```python\n",
    "# Import the MNIST dataset from TensorFlow's Keras datasets module\n",
    "mnist = tf.keras.datasets.mnist\n",
    "\n",
    "# Load the MNIST dataset: \n",
    "# - train_images and train_labels are the training images and their corresponding labels.\n",
    "# - test_images and test_labels are the testing images and their corresponding labels.\n",
    "(train_images,train_labels), (test_images,test_labels) = mnist.load_data()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Visualize the data\n",
    "\n",
    "Before we start to work with data, it is always good to get a better idea of what we are working with.\n",
    "\n",
    "How many images do we have in our training and testing datasets? (Hint, remember the `len()` function.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at a random image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set line width for numpy array printing\n",
    "np.set_printoptions(linewidth=150)\n",
    "\n",
    "# Select a random image from train_images\n",
    "select = np.random.randint(0,len(train_images))\n",
    "\n",
    "# Print the image array - longer line length above should allow it to have all 28 rows in 1 line\n",
    "print(train_images[select])\n",
    "\n",
    "# Display the image as an actual image\n",
    "plt.imshow(train_images[select], cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "# Print the true label for the image from train_labels\n",
    "print(f\"The true label for this image is a {train_labels[select]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ouptut of the cell above should help clarify how images are encoded in our data. Each pixel has a value from 0 (black) to 255 (white). Since our images are black and white, we only have one grid of pixels. For color images, we would have three: one for each color, red, green, blue.\n",
    "\n",
    "Our datasets have 60,000 images in `train_images` and 10,000 images in `test_images`. We will use these data as we move forward."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Normalize the data\n",
    "\n",
    "Before we normalize the data, look to see what the current maximum value is in `train_images`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it! What is the max value of train_images?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Amelia normalizes the data to ensure her AI model can efficiently process these images. Processing your model inputs so that they are represented by numbers between 0 and 1 is a best practice for AI model development.\n",
    "\n",
    "Normalize the data by scaling the images so their values are between 0 and 1.\n",
    "\n",
    "```python\n",
    "# Normalize the pixel values of the training and testing images to be between 0 and 1.\n",
    "# This is done by dividing each pixel value by 255 (the maximum pixel value for an 8-bit image).\n",
    "# Normalizing improves the training process and convergence.\n",
    "train_images, test_images = train_images / 255.0, test_images / 255.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look at the maximum value of `train_images` after normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it! After normalization, what is the max value of train_images?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Build the sequential model\n",
    "\n",
    "Now, the fun part begins! Amelia sets out to build her neural network. In the previous exercises, Amelia called a pre-trained model for image recognition and then built a single-layer network for her binary classifier. With her confidence high, she is going to create this model herself out of multiple layers. This approach gives her (and you!) the most control over the function of the model.\n",
    "\n",
    "Using the Sequential API, build your model according to the following details:\n",
    "\n",
    "* First, add a flattened layer to unroll the 28x28 pixel images into a single array of 784. The model should use the input_shape in the function argument to set the input size in the first layer.\n",
    "* Add a dense hidden layer with 50 units (neurons) and ReLU (Rectified Linear Unit) activation function.\n",
    "   * The ReLU function will allow the model to capture non-linearities.\n",
    "* Add a second, dense hidden layer with 20 units and ReLU activation function.\n",
    "* Add a dense output layer with 10 units and the softmax activation function.\n",
    "   * We use ten neurons, each representing the digits 0-9. \n",
    "   * The softmax function ensures the output values are probabilities that sum to 1, making it suitable for classification.\n",
    "\n",
    "Here's a graphical view of what we are doing:\n",
    "\n",
    "![A diagram of the neural network being created. It shows the input 28X28 image being flattened into a 784 dimension array. That is the input. There are two hidden, fully connected layers with 50 and 20 neurons each. The final output layer has 10 neurons for the 10 classes in our model.](images/MNIST_neural_network.png)\n",
    "\n",
    "\n",
    "Your completed neural network should have four layers. Feel free to experiment with different architectures and build your own model.\n",
    "\n",
    "```python\n",
    "# Instantiate a Sequential model, which allows us to build a neural network by stacking layers in a linear fashion.\n",
    "model = Sequential()\n",
    "\n",
    "# Add a Flatten layer to the model which transforms a 2D matrix (28x28 pixels) into a 1D array.\n",
    "# This is necessary because our input images are 28x28 pixels, and we need to flatten them to feed into a dense layer.\n",
    "model.add(Flatten(input_shape=(28,28)))\n",
    "\n",
    "# Add a Dense (fully connected) layer with 50 units and a ReLU activation function.\n",
    "model.add(Dense(units=50, activation='relu'))\n",
    "\n",
    "# Add another Dense layer with 20 units and a ReLU activation function.\n",
    "model.add(Dense(units=20, activation='relu'))\n",
    "\n",
    "# Add a final Dense layer with 10 units and a softmax activation function.\n",
    "model.add(Dense(units=10, activation='softmax'))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Compile the model\n",
    "\n",
    "Compiling is the next step. Here, Amelia will specify the parts of the model that are not in the layers, namely the optimizer, loss function, and performance metric.\n",
    "\n",
    "To `compile` the model, you need to specify an optimizer, a loss function, and a metric to judge your model's performance.\n",
    "\n",
    "Compile the model with the following specifications:\n",
    "* `adam` optimizer: An optimization algorithm that adjusts the model weights to minimize the loss.\n",
    "* `sparse_categorical_crossentropy` loss function: Suitable for classification tasks with integer labels.\n",
    "* `accuracy` metric: To monitor the accuracy of the model's predictions during training and evaluation.\n",
    "\n",
    "```python\n",
    "model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Inspect the model configuration using the summary function\n",
    "\n",
    "Display a summary of the model's architecture, including the layers, their shapes, and the number of parameters.\n",
    "\n",
    "```python\n",
    "model.summary()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model summary indicates that this model has 40,480 parameters (weights and biases). **Note**: If your model summary does not show `Total params: 40480`, double check your model was set up correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Fit the model to the training data\n",
    "\n",
    "Now, train the model on the MNIST dataset using the `fit` method. Set the training to run for 10 epochs.\n",
    "\n",
    "Train the model using the training data:\n",
    "* `train_images`: the input images\n",
    "* `train_labels`: the true labels for each image\n",
    "* `epochs=10`: the number of times the model will cycle through the entire dataset\n",
    "\n",
    "```python\n",
    "\n",
    "model.fit(train_images, train_labels, epochs=10)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Evaluate the model\n",
    "\n",
    "Finally, evaluate your model's performance on the test set by calling the model's `evaluate()` method.\n",
    "\n",
    "\n",
    "Evaluate the model's performance using the testing data:\n",
    "* `test_images`: the input images from the testing set\n",
    "* `test_labels`: the true labels for each image in the testing set\n",
    "\n",
    "The `evaluate` method returns the loss value and any additional metrics (in this case, accuracy) for the model on the testing data.\n",
    "\n",
    "```python\n",
    "model.evaluate(test_images, test_labels)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Model predictions\n",
    "\n",
    "Let's see how the model performs on some randomly selected images.  Are its predictions correct?  \n",
    "\n",
    "Select an image from the test dataset, in this case, the 200th image.\n",
    "\n",
    "Select a specific image from the test dataset for examination or prediction.\n",
    "\n",
    "The variable `loc` is set to the index 200, which means we are selecting the 201st image (0-based index) from the test dataset.\n",
    "\n",
    "```python\n",
    "loc = 200\n",
    "\n",
    "# Extract the corresponding image from the test_images array and store it in the 'test_image' variable.\n",
    "test_image = test_images[loc]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's take a look at the shape of the image.\n",
    "\n",
    "* Get and display the shape (dimensions) of the `test_image` variable.\n",
    "* This provides insight into the structure and size of the image.\n",
    "\n",
    "```python\n",
    "test_image.shape\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that our image is 28x28 pixels. However, the model needs not just the size of the image but also the number of channels. A simple call to the `reshape()` method fixes that problem. \n",
    "\n",
    "* Reshape the 'test_image' from a 2D array (28x28) to a 3D array (1x28x28).\n",
    "* This is commonly done to match the input shape that the model expects when making predictions on single samples.\n",
    "\n",
    "```python\n",
    "test_image = test_image.reshape(1,28,28)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now call the model's `predict()` method, assign the output to result, and then view its contents.\n",
    "\n",
    "* Use the trained model to predict the label for the `test_image`.\n",
    "* The `predict` method returns an array of probabilities for each possible label (in the case of MNIST, digits 0-9).\n",
    "* Each value in the array corresponds to the model's predicted probability that the image belongs to a particular class (digit).\n",
    "\n",
    "```python\n",
    "result = model.predict(test_image)\n",
    "\n",
    "# Print the array of probabilities to the console.\n",
    "print(result)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see, the model has returned the probability of 10 predictions, with the highest one being the most likely.  Use the `argmax` function to see the model's prediction.\n",
    "\n",
    "* Use the `argmax` method to find the index (label) of the maximum value in the `result` array.\n",
    "   * This gives us the model's most likely prediction for the class (digit) of the `test_image`.\n",
    "\n",
    "```python\n",
    "result.argmax()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To verify the prediction, check the label of the corresponding image.\n",
    "\n",
    "\n",
    "* Using the index loc, retrieve the true label (actual digit) for the `test_image` from the `test_labels` array.\n",
    "   * This gives us the actual class (digit) of the `test_image` to compare with the model's prediction.\n",
    "\n",
    "```python\n",
    "test_labels[loc]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, visualize the image with pyplot.\n",
    "\n",
    "* Use the `imshow` function from the `matplotlib` library to display the `test_image` as a visual image.\n",
    "   * This helps in visually examining the content of the `test_image` (which is represented as a 28x28 array of pixel values).\n",
    "\n",
    "```python\n",
    "plt.imshow(test_images[loc])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code it!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we did it! We helped Amelia create a model that can recognize handwritten digits!\n",
    "\n",
    "\n",
    "## Bonus exercise\n",
    "\n",
    "* Write a function that ties all these steps into one function call. The function should take an input image and print the image with the predicted digit and true digit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Before continuing\n",
    "###  <img src='images/alert_icon.svg' alt=\"Alert icon\" width=40 align=center> Alert!\n",
    "> Before continuing to another notebook within the same Jupyter session,\n",
    "> use the **\"Running Terminals and Kernels\" tab** (below the File Browser tab) to **shut down this kernel**. \n",
    "> This will free up this notebook's GPU memory, making it available for\n",
    "> your next notebook.\n",
    ">\n",
    "> Every time you run multiple notebooks within a Jupyter session with a GPU, this should be done.\n",
    ">\n",
    "> ![Screenshot of the Running Terminals and Kernels tab used t oshut down kernels before starting a new notebook](images/stop_kernel.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}