Mod1_Wk2 Programming Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN classifier for the MNIST dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instructions\n",
    "\n",
    "In this notebook, you will write code to build, compile and fit a convolutional neural network (CNN) model to the MNIST dataset of images of handwritten digits.\n",
    "\n",
    "Some code cells are provided you in the notebook. You should avoid editing provided code, and make sure to execute the cells in order to avoid unexpected errors. Some cells begin with the line: \n",
    "\n",
    "`#### GRADED CELL ####`\n",
    "\n",
    "Don't move or edit this first line - this is what the automatic grader looks for to recognise graded cells. These cells require you to write your own code to complete them, and are automatically graded when you submit the notebook. Don't edit the function name or signature provided in these cells, otherwise the automatic grader might not function properly. Inside these graded cells, you can use any functions or classes that are imported below, but make sure you don't use any variables that are outside the scope of the function.\n",
    "\n",
    "### How to submit\n",
    "\n",
    "Complete all the tasks you are asked for in the worksheet. When you have finished and are happy with your code, press the **Submit Assignment** button at the top of this notebook.\n",
    "\n",
    "### Let's get started!\n",
    "\n",
    "We'll start running some imports, and loading the dataset. Do not edit the existing imports in the following cell. If you would like to make further Tensorflow imports, you should add them here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### PACKAGE IMPORTS ####\n",
    "\n",
    "# Run this cell first to import all required packages. Do not make any imports elsewhere in the notebook\n",
    "\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# If you would like to make further imports from Tensorflow, add them here\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![MNIST overview image](data/mnist.png)\n",
    "\n",
    "#### The MNIST dataset\n",
    "\n",
    "In this assignment, you will use the [MNIST dataset](http://yann.lecun.com/exdb/mnist/). It consists of a training set of 60,000 handwritten digits with corresponding labels, and a test set of 10,000 images. The images have been normalised and centred. The dataset is frequently used in machine learning research, and has become a standard benchmark for image classification models. \n",
    "\n",
    "- Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. \"Gradient-based learning applied to document recognition.\" Proceedings of the IEEE, 86(11):2278-2324, November 1998.\n",
    "\n",
    "Your goal is to construct a neural network that classifies images of handwritten digits into one of 10 classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load and preprocess the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to load the MNIST data\n",
    "\n",
    "mnist_data = tf.keras.datasets.mnist\n",
    "(train_images, train_labels), (test_images, test_labels) = mnist_data.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, preprocess the data by scaling the training and test images so their values lie in the range from 0 to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### GRADED CELL ####\n",
    "\n",
    "# Complete the following function. \n",
    "# Make sure to not change the function name or arguments.\n",
    "\n",
    "def scale_mnist_data(train_images, test_images):\n",
    "    \"\"\"\n",
    "    This function takes in the training and test images as loaded in the cell above, and scales them\n",
    "    so that they have minimum and maximum values equal to 0 and 1 respectively.\n",
    "    Your function should return a tuple (train_images, test_images) of scaled training and test images.\n",
    "    \"\"\"\n",
    "    train_images = train_images / 255.\n",
    "    test_images = test_images / 255.\n",
    "    \n",
    "    return train_images, test_images\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run your function on the input data\n",
    "\n",
    "scaled_train_images, scaled_test_images = scale_mnist_data(train_images, test_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a dummy channel dimension\n",
    "\n",
    "scaled_train_images = scaled_train_images[..., np.newaxis]\n",
    "scaled_test_images = scaled_test_images[..., np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build the convolutional neural network model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to construct a model to fit to the data. Using the Sequential API, build your CNN model according to the following spec:\n",
    "\n",
    "* The model should use the `input_shape` in the function argument to set the input size in the first layer.\n",
    "* A 2D convolutional layer with a 3x3 kernel and 8 filters. Use 'SAME' zero padding and ReLU activation functions. Make sure to provide the `input_shape` keyword argument in this first layer.\n",
    "* A max pooling layer, with a 2x2 window, and default strides.\n",
    "* A flatten layer, which unrolls the input into a one-dimensional tensor.\n",
    "* Two dense hidden layers, each with 64 units and ReLU activation functions.\n",
    "* A dense output layer with 10 units and the softmax activation function.\n",
    "\n",
    "In particular, your neural network should have six layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### GRADED CELL ####\n",
    "\n",
    "# Complete the following function. \n",
    "# Make sure to not change the function name or arguments.\n",
    "\n",
    "def get_model(input_shape):\n",
    "    \"\"\"\n",
    "    This function should build a Sequential model according to the above specification. Ensure the \n",
    "    weights are initialised by providing the input_shape argument in the first layer, given by the\n",
    "    function argument.\n",
    "    Your function should return the model.\n",
    "    \"\"\"\n",
    "    model = Sequential([\n",
    "        Conv2D(8, (3,3), padding='same',activation='relu',input_shape=(28,28,1)),\n",
    "        MaxPooling2D((2,2)),\n",
    "        Flatten(),\n",
    "        Dense(64,activation='relu'),\n",
    "        Dense(64,activation='relu'),\n",
    "        Dense(10,activation='softmax')\n",
    "    ])\n",
    "    return model\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run your function to get the model\n",
    "\n",
    "model = get_model(scaled_train_images[0].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compile the model\n",
    "\n",
    "You should now compile the model using the `compile` method. To do so, you need to specify an optimizer, a loss function and a metric to judge the performance of your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### GRADED CELL ####\n",
    "\n",
    "# Complete the following function. \n",
    "# Make sure to not change the function name or arguments.\n",
    "\n",
    "def compile_model(model):\n",
    "    \"\"\"\n",
    "    This function takes in the model returned from your get_model function, and compiles it with an optimiser,\n",
    "    loss function and metric.\n",
    "    Compile the model using the Adam optimiser (with default settings), the cross-entropy loss function and\n",
    "    accuracy as the only metric. \n",
    "    Your function doesn't need to return anything; the model will be compiled in-place.\n",
    "    \"\"\"\n",
    "    model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run your function to compile the model\n",
    "\n",
    "compile_model(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fit the model to the training data\n",
    "\n",
    "Now you should train the model on the MNIST dataset, using the model's `fit` method. Set the training to run for 5 epochs, and return the training history to be used for plotting the learning curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### GRADED CELL ####\n",
    "\n",
    "# Complete the following function. \n",
    "# Make sure to not change the function name or arguments.\n",
    "\n",
    "def train_model(model, scaled_train_images, train_labels):\n",
    "    \"\"\"\n",
    "    This function should train the model for 5 epochs on the scaled_train_images and train_labels. \n",
    "    Your function should return the training history, as returned by model.fit.\n",
    "    \"\"\"\n",
    "    history = model.fit(scaled_train_images, train_labels,epochs=5,batch_size=64)\n",
    "    return history\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples\n",
      "Epoch 1/5\n",
      "60000/60000 [==============================] - 75s 1ms/sample - loss: 0.2815 - accuracy: 0.9168\n",
      "Epoch 2/5\n",
      "60000/60000 [==============================] - 73s 1ms/sample - loss: 0.0893 - accuracy: 0.9732\n",
      "Epoch 3/5\n",
      "60000/60000 [==============================] - 72s 1ms/sample - loss: 0.0597 - accuracy: 0.9818\n",
      "Epoch 4/5\n",
      "60000/60000 [==============================] - 73s 1ms/sample - loss: 0.0471 - accuracy: 0.9849\n",
      "Epoch 5/5\n",
      "60000/60000 [==============================] - 73s 1ms/sample - loss: 0.0372 - accuracy: 0.9883\n"
     ]
    }
   ],
   "source": [
    "# Run your function to train the model\n",
    "\n",
    "history = train_model(model, scaled_train_images, train_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot the learning curves\n",
    "\n",
    "We will now plot two graphs:\n",
    "* Epoch vs accuracy\n",
    "* Epoch vs loss\n",
    "\n",
    "We will load the model history into a pandas `DataFrame` and use the `plot` method to output the required graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to load the model history into a pandas DataFrame\n",
    "\n",
    "frame = pd.DataFrame(history.history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Accuracy'), Text(0.5, 0, 'Epochs')]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to make the Accuracy vs Epochs plot\n",
    "\n",
    "acc_plot = frame.plot(y=\"accuracy\", title=\"Accuracy vs Epochs\", legend=False)\n",
    "acc_plot.set(xlabel=\"Epochs\", ylabel=\"Accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Loss'), Text(0.5, 0, 'Epochs')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to make the Loss vs Epochs plot\n",
    "\n",
    "acc_plot = frame.plot(y=\"loss\", title = \"Loss vs Epochs\",legend=False)\n",
    "acc_plot.set(xlabel=\"Epochs\", ylabel=\"Loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate the model\n",
    "\n",
    "Finally, you should evaluate the performance of your model on the test set, by calling the model's `evaluate` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### GRADED CELL ####\n",
    "\n",
    "# Complete the following function. \n",
    "# Make sure to not change the function name or arguments.\n",
    "\n",
    "def evaluate_model(model, scaled_test_images, test_labels):\n",
    "    \"\"\"\n",
    "    This function should evaluate the model on the scaled_test_images and test_labels. \n",
    "    Your function should return a tuple (test_loss, test_accuracy).\n",
    "    \"\"\"\n",
    "    test_loss, test_accuracy = model.evaluate(scaled_test_images, test_labels, verbose=2)\n",
    "    \n",
    "    return test_loss, test_accuracy\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000/1 - 5s - loss: 0.0267 - accuracy: 0.9828\n",
      "Test loss: 0.05286471021657344\n",
      "Test accuracy: 0.9828000068664551\n"
     ]
    }
   ],
   "source": [
    "# Run your function to evaluate the model\n",
    "\n",
    "test_loss, test_accuracy = evaluate_model(model, scaled_test_images, test_labels)\n",
    "print(f\"Test loss: {test_loss}\")\n",
    "print(f\"Test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model predictions\n",
    "\n",
    "Let's see some model predictions! We will randomly select four images from the test data, and display the image and label for each. \n",
    "\n",
    "For each test image, model's prediction (the label with maximum probability) is shown, together with a plot showing the model's categorical distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x864 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to get model predictions on randomly selected test images\n",
    "\n",
    "num_test_images = scaled_test_images.shape[0]\n",
    "\n",
    "random_inx = np.random.choice(num_test_images, 4)\n",
    "random_test_images = scaled_test_images[random_inx, ...]\n",
    "random_test_labels = test_labels[random_inx, ...]\n",
    "\n",
    "predictions = model.predict(random_test_images)\n",
    "\n",
    "fig, axes = plt.subplots(4, 2, figsize=(16, 12))\n",
    "fig.subplots_adjust(hspace=0.4, wspace=-0.2)\n",
    "\n",
    "for i, (prediction, image, label) in enumerate(zip(predictions, random_test_images, random_test_labels)):\n",
    "    axes[i, 0].imshow(np.squeeze(image))\n",
    "    axes[i, 0].get_xaxis().set_visible(False)\n",
    "    axes[i, 0].get_yaxis().set_visible(False)\n",
    "    axes[i, 0].text(10., -1.5, f'Digit {label}')\n",
    "    axes[i, 1].bar(np.arange(len(prediction)), prediction)\n",
    "    axes[i, 1].set_xticks(np.arange(len(prediction)))\n",
    "    axes[i, 1].set_title(f\"Categorical distribution. Model prediction: {np.argmax(prediction)}\")\n",
    "    \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations for completing this programming assignment! In the next week of the course we will take a look at including validation and regularisation in our model training, and introduce Keras callbacks."
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "tensor-flow-2-1",
   "graded_item_id": "g0YqY",
   "launcher_item_id": "N6gmY"
  },
  "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.9.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "81794d4967e6c3204c66dcd87b604927b115b27c00565d3d43f05ba2f3a2cb0d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}