simple_nn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2RooUjSI0Pum"
   },
   "source": [
    "# Introduction to deep learning: handwritten digit recognition\n",
    "\n",
    "This notebook provides examples of a neural network for image classification. We will do the following excercises:\n",
    "- Handwritten digit recognition with fully connected network\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZWNXK6VZ0Puo"
   },
   "source": [
    "# Exercise 1: Fully connected network for handwritten digit recognition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RcTeSgL-0Pup"
   },
   "source": [
    "## Step 1: Load libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "CQWAK8Rd0Pup"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import keras\n",
    "from keras import optimizers\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oEfWqo8T0Puq",
    "outputId": "92ca57c5-edea-44f7-d11c-bdb1e05a7226"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xnH3yUzs0Puq"
   },
   "source": [
    "## Step 2: Load dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gms4CeYf0Pur"
   },
   "source": [
    "Loading the dataset returns four NumPy arrays:\n",
    "\n",
    "* The `train_images` and `train_labels` arrays are the *training set*—the data the model uses to learn.\n",
    "* The model is tested against the *test set*, the `test_images`, and `test_labels` arrays.\n",
    "\n",
    "The images are 28x28 NumPy arrays, with pixel values ranging from 0 to 255. The *labels* are an array of integers, ranging from 0 to 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XZw1JIGr0Pux",
    "outputId": "2a3a07d6-f851-44cd-96bc-209e53640be4"
   },
   "outputs": [],
   "source": [
    "# first, we load a dataset of handwritten digits. The dataset consists of greyscale images. If you want to try RGB digit try this dataset: https://www.kaggle.com/prasunroy/synthetic-digits \n",
    "mnist = tf.keras.datasets.mnist.load_data(path=\"mnist.npz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "V7k9LvYk0Pux"
   },
   "outputs": [],
   "source": [
    "# Here, we download images (x) and labels (y)\n",
    "# 60000 training set; 10000 test set\n",
    "(x_train, y_train),(x_test, y_test) = tf.keras.datasets.mnist.load_data(path=\"mnist.npz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P9lR5aqy0Pux"
   },
   "source": [
    "## Step 2.1: Explore the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "jzd195bn0Puy",
    "outputId": "cd22f51c-40b6-4d9a-d5d8-3ce2fd650a32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 0\n",
    "plt.imshow(x_train[index])\n",
    "print(y_train[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vkuNPOSX0Puy"
   },
   "source": [
    "Scale these values to a range of 0 to 1 before feeding them to the neural network model. To do so, divide the values by 255. It's important that the *training set* and the *testing set* be preprocessed in the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "oTwJTmBe0Puy"
   },
   "outputs": [],
   "source": [
    "### Normalise images\n",
    "x_train = x_train / 255.0\n",
    "x_test = x_test / 255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WwhPMcvr0Puz",
    "outputId": "efaba60d-93bb-477f-b45a-288b1eb1626b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ApMkQN8a0Puz",
    "outputId": "8a708d8f-62ee-44f4-d61d-fd6a2d31d95c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train[0].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6rqrPdFm0Pu0"
   },
   "source": [
    "## Step3: Build the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fAndMo5N0Pu0"
   },
   "source": [
    "We will use Keras sequential class: see documentation  [here](https://keras.io/api/models/ )\n",
    "\n",
    "The basic building block of a neural network is the *layer*. Layers extract representations from the data fed into them. Hopefully, these representations are meaningful for the problem at hand.\n",
    "\n",
    "Most of deep learning consists of chaining together simple layers. Most layers, such as `tf.keras.layers.Dense`, have parameters that are learned during training.\n",
    "\n",
    "The Sequential model is a simple list of layers, but is limited to single-input, single-output stacks of layers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "AA0Z95ev0Pu0"
   },
   "outputs": [],
   "source": [
    "model = keras.models.Sequential([keras.layers.Flatten(), \n",
    "                                keras.layers.Dense(128, activation=tf.nn.relu),\n",
    "                                keras.layers.Dense(10, activation=tf.nn.softmax)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wdr6b4nY0Pu0"
   },
   "source": [
    "The first layer in this network, `tf.keras.layers.Flatten`, transforms the format of the images from a two-dimensional array (of 28 by 28 pixels) to a one-dimensional array (of 28 * 28 = 784 pixels). Think of this layer as unstacking rows of pixels in the image and lining them up. This layer has no parameters to learn; it only reformats the data.\n",
    "\n",
    "After the pixels are flattened, the network consists of a sequence of two `tf.keras.layers.Dense` layers. These are densely connected, or fully connected, neural layers. The first `Dense` layer has 128 nodes (or neurons). The second (and last) layer returns a logits array with length of 10. Each node contains a score that indicates the current image belongs to one of the 10 classes.\n",
    "\n",
    "### Compile the model\n",
    "\n",
    "Before the model is ready for training, it needs a few more settings. These are added during the model's *compile* step:\n",
    "\n",
    "* *Loss function* —This measures how accurate the model is during training. You want to minimize this function to \"steer\" the model in the right direction.\n",
    "* *Optimizer* —This is how the model is updated based on the data it sees and its loss function.\n",
    "* *Metrics* —Used to monitor the training and testing steps. The following example uses *accuracy*, the fraction of the images that are correctly classified.\n",
    "\n",
    "\n",
    "We will use Adam optimization algorithm. Adam is a stochastic gradient descent method that computes individual adaptive learning rates for different parameters from estimates of first- and second-order moments of the gradients. [Read more here](https://www.tensorflow.org/swift/api_docs/Classes/Adam).\n",
    "\n",
    "Reference: [“Adam: A Method for Stochastic Optimization”](https://arxiv.org/pdf/1412.6980v8.pdf) (Kingma and Ba, 2014)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "ZuZn9uYx0Pu1"
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=tf.keras.optimizers.Adam(),\n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jMzHO29d0Pu1"
   },
   "source": [
    "## Step 4: Train the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fi8QaK_V0Pu1"
   },
   "source": [
    "Training the neural network model requires the following steps:\n",
    "\n",
    "1. Feed the training data to the model. In this example, the training data is in the `train_images` and `train_labels` arrays.\n",
    "2. The model learns to associate images and labels.\n",
    "3. You ask the model to make predictions about a test set—in this example, the `test_images` array.\n",
    "4. Verify that the predictions match the labels from the `test_labels` array.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yzZQDYyj0Pu1"
   },
   "source": [
    "### Feed the model\n",
    "\n",
    "To start training,  call the `model.fit` method—so called because it \"fits\" the model to the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Zbp1w3D_0Pu2",
    "outputId": "aadb4ae2-4ed3-4a69-f043-c189ce122ce0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "60000/60000 [==============================] - 6s 95us/step - loss: 0.2522 - accuracy: 0.9282\n",
      "Epoch 2/20\n",
      "60000/60000 [==============================] - 5s 90us/step - loss: 0.1097 - accuracy: 0.9673\n",
      "Epoch 3/20\n",
      "60000/60000 [==============================] - 5s 91us/step - loss: 0.0761 - accuracy: 0.9769\n",
      "Epoch 4/20\n",
      "60000/60000 [==============================] - 6s 93us/step - loss: 0.0578 - accuracy: 0.9822\n",
      "Epoch 5/20\n",
      "60000/60000 [==============================] - 6s 94us/step - loss: 0.0447 - accuracy: 0.9865\n",
      "Epoch 6/20\n",
      "60000/60000 [==============================] - 6s 95us/step - loss: 0.0348 - accuracy: 0.9893\n",
      "Epoch 7/20\n",
      "60000/60000 [==============================] - 6s 98us/step - loss: 0.0288 - accuracy: 0.9911\n",
      "Epoch 8/20\n",
      "60000/60000 [==============================] - 6s 99us/step - loss: 0.0228 - accuracy: 0.9933\n",
      "Epoch 9/20\n",
      "60000/60000 [==============================] - 6s 101us/step - loss: 0.0191 - accuracy: 0.9942\n",
      "Epoch 10/20\n",
      "60000/60000 [==============================] - 6s 99us/step - loss: 0.0156 - accuracy: 0.9949\n",
      "Epoch 11/20\n",
      "60000/60000 [==============================] - 6s 97us/step - loss: 0.0125 - accuracy: 0.9960\n",
      "Epoch 12/20\n",
      "60000/60000 [==============================] - 6s 98us/step - loss: 0.0111 - accuracy: 0.9964\n",
      "Epoch 13/20\n",
      "60000/60000 [==============================] - 6s 97us/step - loss: 0.0097 - accuracy: 0.9968\n",
      "Epoch 14/20\n",
      "60000/60000 [==============================] - 6s 99us/step - loss: 0.0092 - accuracy: 0.9973\n",
      "Epoch 15/20\n",
      "60000/60000 [==============================] - 6s 100us/step - loss: 0.0075 - accuracy: 0.9978\n",
      "Epoch 16/20\n",
      "60000/60000 [==============================] - 6s 100us/step - loss: 0.0075 - accuracy: 0.9977\n",
      "Epoch 17/20\n",
      "60000/60000 [==============================] - 6s 105us/step - loss: 0.0069 - accuracy: 0.9978\n",
      "Epoch 18/20\n",
      "60000/60000 [==============================] - 6s 105us/step - loss: 0.0052 - accuracy: 0.9984\n",
      "Epoch 19/20\n",
      "60000/60000 [==============================] - 6s 105us/step - loss: 0.0063 - accuracy: 0.9979\n",
      "Epoch 20/20\n",
      "60000/60000 [==============================] - 6s 103us/step - loss: 0.0061 - accuracy: 0.9979\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train, epochs=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PXA3ke1j0Pu2"
   },
   "source": [
    "As the model trains, the loss and accuracy metrics are displayed. This model reaches an accuracy of about 0.91 (or 91%) on the training data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XUckPnv60Pu2"
   },
   "source": [
    "## Step 5: Evaluate model performance\n",
    "\n",
    "Next, compare how the model performs on the test dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QiKWSNDF0Pu3",
    "outputId": "3f29cf34-c908-46c0-ae0c-1753daef1d80"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000/10000 [==============================] - 0s 44us/step\n",
      "\n",
      "Test accuracy: 0.9786999821662903\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = model.evaluate(x_test, y_test)\n",
    "\n",
    "print('\\nTest accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wD_SfTWZ0Pu3"
   },
   "source": [
    "It turns out that the accuracy on the test dataset is a little less than the accuracy on the training dataset. This gap between training accuracy and test accuracy represents *overfitting*. Overfitting happens when a machine learning model performs worse on new, previously unseen inputs than it does on the training data. An overfitted model \"memorizes\" the noise and details in the training dataset to a point where it negatively impacts the performance of the model on the new data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xYD10B620Pu3"
   },
   "source": [
    "### Make predictions\n",
    "\n",
    "With the model trained, you can use it to make predictions about some images.\n",
    "The model's linear outputs, [logits](https://developers.google.com/machine-learning/glossary#logits). Attach a softmax layer to convert the logits to probabilities, which are easier to interpret. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ve-fVPce0Pu4",
    "outputId": "dd1fc385-3c89-4d40-effb-aa59726cf3cb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.6950527e-15 3.6914318e-16 2.9616297e-14 2.8689981e-11 2.2887978e-21\n",
      " 4.9993353e-18 2.2343933e-24 1.0000000e+00 8.6006672e-16 2.9196732e-12]\n"
     ]
    }
   ],
   "source": [
    "classifications = model.predict(x_test)\n",
    "\n",
    "print(classifications[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Eeqgu1mr0Pu4",
    "outputId": "02f1954d-50d5-4756-ab92-2b46c325c66c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(y_test[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FbNszfqM0Pu4"
   },
   "source": [
    "# Plot the training history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 312
    },
    "id": "EOQfdU1-0Pu4",
    "outputId": "5ba2f4a4-3ee8-481a-840a-33baafa0f532"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(history.history.keys())\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "id": "NfzhOZSW0Pu5",
    "outputId": "328e92c6-f3f3-4066-894b-07ab2d81f9fa"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UFi1zL5_0PvF"
   },
   "source": [
    "And the model predicts a label as expected."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "simple_nn.ipynb",
   "provenance": []
  },
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}