EsmailELBoBDev2/01StudentNotebook.ipynb

## 01StudentNotebook.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Rhyme](https://rhyme.com/assets/img/logo-dark.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 1: Introduction\n",
    "\n",
    "Welcome to Basic Image Classification with TensorFlow.\n",
    "\n",
    "This graph describes the problem that we are trying to solve visually. We want to create and train a model that takes an image of a hand written digit as input and predicts the class of that digit, that is, it predicts the digit or it predicts the class of the input image.\n",
    "\n",
    "![Hand Written Digits Classification](images/1_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import TensorFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already up-to-date: tensorflow in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (2.3.0)\n",
      "Requirement already satisfied, skipping upgrade: google-pasta>=0.1.8 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (0.2.0)\n",
      "Requirement already satisfied, skipping upgrade: keras-preprocessing<1.2,>=1.1.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.1.2)\n",
      "Requirement already satisfied, skipping upgrade: wrapt>=1.11.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.12.1)\n",
      "Requirement already satisfied, skipping upgrade: six>=1.12.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.15.0)\n",
      "Requirement already satisfied, skipping upgrade: scipy==1.4.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.4.1)\n",
      "Requirement already satisfied, skipping upgrade: absl-py>=0.7.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (0.9.0)\n",
      "Requirement already satisfied, skipping upgrade: termcolor>=1.1.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.1.0)\n",
      "Requirement already satisfied, skipping upgrade: gast==0.3.3 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (0.3.3)\n",
      "Requirement already satisfied, skipping upgrade: numpy<1.19.0,>=1.16.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.18.5)\n",
      "Requirement already satisfied, skipping upgrade: h5py<2.11.0,>=2.10.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (2.10.0)\n",
      "Requirement already satisfied, skipping upgrade: grpcio>=1.8.6 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.30.0)\n",
      "Requirement already satisfied, skipping upgrade: wheel>=0.26 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (0.34.2)\n",
      "Requirement already satisfied, skipping upgrade: protobuf>=3.9.2 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (3.12.3)\n",
      "Requirement already satisfied, skipping upgrade: tensorboard<3,>=2.3.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (2.3.0)\n",
      "Requirement already satisfied, skipping upgrade: tensorflow-estimator<2.4.0,>=2.3.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (2.3.0)\n",
      "Requirement already satisfied, skipping upgrade: opt-einsum>=2.3.2 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (3.3.0)\n",
      "Requirement already satisfied, skipping upgrade: astunparse==1.6.3 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorflow) (1.6.3)\n",
      "Requirement already satisfied, skipping upgrade: setuptools in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from protobuf>=3.9.2->tensorflow) (49.2.0.post20200712)\n",
      "Requirement already satisfied, skipping upgrade: werkzeug>=0.11.15 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (1.0.1)\n",
      "Requirement already satisfied, skipping upgrade: requests<3,>=2.21.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (2.24.0)\n",
      "Requirement already satisfied, skipping upgrade: google-auth-oauthlib<0.5,>=0.4.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (0.4.1)\n",
      "Requirement already satisfied, skipping upgrade: google-auth<2,>=1.6.3 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (1.21.1)\n",
      "Requirement already satisfied, skipping upgrade: tensorboard-plugin-wit>=1.6.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (1.7.0)\n",
      "Requirement already satisfied, skipping upgrade: markdown>=2.6.8 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from tensorboard<3,>=2.3.0->tensorflow) (3.2.2)\n",
      "Requirement already satisfied, skipping upgrade: idna<3,>=2.5 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow) (2.10)\n",
      "Requirement already satisfied, skipping upgrade: certifi>=2017.4.17 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow) (2020.6.20)\n",
      "Requirement already satisfied, skipping upgrade: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow) (1.25.10)\n",
      "Requirement already satisfied, skipping upgrade: chardet<4,>=3.0.2 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow) (3.0.4)\n",
      "Requirement already satisfied, skipping upgrade: requests-oauthlib>=0.7.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<3,>=2.3.0->tensorflow) (1.3.0)\n",
      "Requirement already satisfied, skipping upgrade: cachetools<5.0,>=2.0.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow) (4.1.1)\n",
      "Requirement already satisfied, skipping upgrade: pyasn1-modules>=0.2.1 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow) (0.2.8)\n",
      "Requirement already satisfied, skipping upgrade: rsa<5,>=3.1.4; python_version >= \"3.5\" in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow) (4.6)\n",
      "Requirement already satisfied, skipping upgrade: importlib-metadata; python_version < \"3.8\" in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from markdown>=2.6.8->tensorboard<3,>=2.3.0->tensorflow) (1.7.0)\n",
      "Requirement already satisfied, skipping upgrade: oauthlib>=3.0.0 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<3,>=2.3.0->tensorflow) (3.1.0)\n",
      "Requirement already satisfied, skipping upgrade: pyasn1<0.5.0,>=0.4.6 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from pyasn1-modules>=0.2.1->google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow) (0.4.8)\n",
      "Requirement already satisfied, skipping upgrade: zipp>=0.5 in /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<3,>=2.3.0->tensorflow) (3.1.0)\n"
     ]
    }
   ],
   "source": [
    "! pip install tensorflow --upgrade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using TensorFlow version 2.3.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import matplotlib\n",
    "import matplotlib.pyplot\n",
    "\n",
    "print('Using TensorFlow version', tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2: The Dataset\n",
    "### Import MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
      "11493376/11490434 [==============================] - 0s 0us/step\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.datasets import mnist\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shapes of Imported Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28)\n",
      "y_train shape:  (60000,)\n",
      "x_test shape:  (10000, 28, 28)\n",
      "y_test shape:  (10000,)\n"
     ]
    }
   ],
   "source": [
    "print('x_train shape:', x_train.shape)\n",
    "print(\"y_train shape: \", y_train.shape)\n",
    "\n",
    "print('x_test shape: ', x_test.shape)\n",
    "print('y_test shape: ', y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot an Image Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.imshow(x_train[0], cmap='binary')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "print(set(y_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 3: One Hot Encoding\n",
    "After this encoding, every label will be converted to a list with 10 elements and the element at index to the corresponding class will be set to 1, rest will be set to 0:\n",
    "\n",
    "| original label | one-hot encoded label |\n",
    "|------|------|\n",
    "| 5 | [0, 0, 0, 0, 0, 1, 0, 0, 0, 0] |\n",
    "| 7 | [0, 0, 0, 0, 0, 0, 0, 1, 0, 0] |\n",
    "| 1 | [0, 1, 0, 0, 0, 0, 0, 0, 0, 0] |\n",
    "\n",
    "### Encoding Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.utils import to_categorical\n",
    "y_train_encoded = to_categorical(y_train)\n",
    "y_test_encoded = to_categorical(y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validated Shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train_encode shape:  (60000, 10)\n",
      "y_test_encode shape:  (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "print(\"y_train_encode shape: \", y_train_encoded.shape)\n",
    "print(\"y_test_encode shape: \", y_test_encoded.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display Encoded Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_encoded[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 4: Neural Networks\n",
    "\n",
    "### Linear Equations\n",
    "\n",
    "![Single Neuron](images/1_2.png)\n",
    "\n",
    "The above graph simply represents the equation:\n",
    "\n",
    "\\begin{equation}\n",
    "y = w1 * x1 + w2 * x2 + w3 * x3 + b\n",
    "\\end{equation}\n",
    "\n",
    "Where the `w1, w2, w3` are called the weights and `b` is an intercept term called bias. The equation can also be *vectorised* like this:\n",
    "\n",
    "\\begin{equation}\n",
    "y = W . X + b\n",
    "\\end{equation}\n",
    "\n",
    "Where `X = [x1, x2, x3]` and `W = [w1, w2, w3].T`. The .T means *transpose*. This is because we want the dot product to give us the result we want i.e. `w1 * x1 + w2 * x2 + w3 * x3`. This gives us the vectorised version of our linear equation.\n",
    "\n",
    "A simple, linear approach to solving hand-written image classification problem - could it work?\n",
    "\n",
    "![Single Neuron with 784 features](images/1_3.png)\n",
    "\n",
    "### Neural Networks\n",
    "\n",
    "![Neural Network with 2 hidden layers](images/1_4.png)\n",
    "\n",
    "This model is much more likely to solve the problem as it can learn more complex function mapping for the inputs and outputs in our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 5: Preprocessing the Examples\n",
    "\n",
    "### Unrolling N-dimensional Arrays to Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 784)\n",
      "(10000, 784)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x_train_reshaped = np.reshape(x_train, (60000, 784))\n",
    "x_test_reshaped = np.reshape(x_test, (10000, 784))\n",
    "\n",
    "print(x_train_reshaped.shape)\n",
    "print(x_test_reshaped.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display Pixel Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 9, 11, 14, 16, 18, 23, 24, 25, 26, 27, 30, 35, 36, 39, 43, 45, 46, 49, 55, 56, 64, 66, 70, 78, 80, 81, 82, 90, 93, 94, 107, 108, 114, 119, 126, 127, 130, 132, 133, 135, 136, 139, 148, 150, 154, 156, 160, 166, 170, 171, 172, 175, 182, 183, 186, 187, 190, 195, 198, 201, 205, 207, 212, 213, 219, 221, 225, 226, 229, 238, 240, 241, 242, 244, 247, 249, 250, 251, 252, 253, 255}\n"
     ]
    }
   ],
   "source": [
    "print(set(x_train_reshaped[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_mean = np.mean(x_train_reshaped)\n",
    "x_std = np.std(x_train_reshaped)\n",
    "\n",
    "epsilon = 1e-10\n",
    "\n",
    "x_train_norm = (x_train_reshaped - x_mean) / (x_std + epsilon)\n",
    "x_test_norm = (x_test_reshaped - x_mean) / (x_std + epsilon)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display Normalized Pixel Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{-0.38589016215482896, 1.306921966983251, 1.17964285952926, 1.803310486053816, 1.6887592893452241, 2.8215433456857437, 2.719720059722551, 1.1923707702746593, 1.7396709323268205, 2.057868700961798, 2.3633385588513764, 2.096052433197995, 1.7651267538176187, 2.7960875241949457, 2.7451758812133495, 2.45243393406917, 0.02140298169794222, -0.22042732246464067, 1.2305545025108566, 0.2759611966059242, 2.210603629906587, 2.6560805059955555, 2.6051688630139593, -0.4240738943910262, 0.4668798577869107, 0.1486820891519332, 0.3905123933145161, 1.0905474843114664, -0.09314821501064967, 1.4851127174188385, 2.7579037919587486, 1.5360243604004349, 0.07231462467953861, -0.13133194724684696, 1.294194056237852, 0.03413089244334132, 1.3451056992194483, 2.274243183633583, -0.24588314395543887, 0.772349715676489, 0.75962180493109, 0.7214380726948927, 0.1995937321335296, -0.41134598364562713, 0.5687031437501034, 0.5941589652409017, 0.9378125553666773, 0.9505404661120763, 0.6068868759863008, 0.4159682148053143, -0.042236572029053274, 2.7706317027041476, 2.1342361654341926, 0.12322626766113501, -0.08042030426525057, 0.16140999989733232, 1.8924058612716097, 1.2560103240016547, 2.185147808415789, 0.6196147867316999, 1.943317504253206, -0.11860403650144787, -0.30952269768243434, 1.9942291472348024, -0.2840668761916362, 2.6306246845047574, 2.286971094378982, -0.19497150097384247, -0.39861807290022805, 0.2886891073513233, 1.7523988430722195, 2.3887943803421745, 2.681536327486354, 1.4596568959280403, 2.439706023323771, 2.7833596134495466, 2.490617666305367, -0.10587612575604877, 1.5614801818912332, 1.9051337720170087, 1.6123918248728295, 1.268738234747054, 1.9560454149986053, 2.6433525952501564, 1.026907930584471}\n"
     ]
    }
   ],
   "source": [
    "print(set(x_train_norm[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 6: Creating a Model\n",
    "### Creating the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "model = Sequential([\n",
    "    Dense(128, activation='relu', input_shape=(784,)),\n",
    "    Dense(128, activation='relu'),\n",
    "    Dense(10, activation='softmax')\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Activation Functions\n",
    "\n",
    "The first step in the node is the linear sum of the inputs:\n",
    "\\begin{equation}\n",
    "Z = W . X + b\n",
    "\\end{equation}\n",
    "\n",
    "The second step in the node is the activation function output:\n",
    "\n",
    "\\begin{equation}\n",
    "A = f(Z)\n",
    "\\end{equation}\n",
    "\n",
    "Graphical representation of a node where the two operations are performed:\n",
    "\n",
    "![ReLU](images/1_5.png)\n",
    "\n",
    "### Compiling the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 128)               100480    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               16512     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 118,282\n",
      "Trainable params: 118,282\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(\n",
    "    optimizer= 'sgd',\n",
    "    loss='categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 7: Training the Model\n",
    "\n",
    "### Training the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1875/1875 [==============================] - 21s 11ms/step - loss: 0.3751 - accuracy: 0.8912\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f68f6d0c6a0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x_train_norm, y_train_encoded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 2s 6ms/step - loss: 0.2182 - accuracy: 0.9352\n",
      "93.51999759674072\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(x_test_norm, y_test_encoded)\n",
    "print(accuracy*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 8: Predictions\n",
    "\n",
    "### Predictions on Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "preds = model.predict(x_test_norm)\n",
    "print(preds.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 12))\n",
    "start_index = 0\n",
    "\n",
    "for i in range(25):\n",
    "    plt.subplot(5,5,i+1)\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    \n",
    "    pred = np.argmax(preds[start_index+i ])\n",
    "    gt = y_test[start_index+i]\n",
    "    col = 'g'\n",
    "    if pred != gt:\n",
    "        col = 'r'\n",
    "    plt.xlabel(f'i={start_index}, pred= {pred}, gt = {gt}', color=col)\n",
    "    plt.imshow(x_test[start_index+i], cmap='binary')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plt.plot(preds[0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "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.6.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}