{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keras tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of this tutorial is to very quickly present keras, the high-level API of tensorflow, as it has already been seen in the Neurocomputing exercises. We will train a small fully-connected network on MNIST and observe what happens when the inputs or outputs are correlated, by training successively on the 0 digits, then the 1, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keras\n",
    "\n",
    "The first step is to install tensorflow. The easiest way is to use pip:\n",
    "    \n",
    "```bash\n",
    "pip install tensorflow\n",
    "```\n",
    "\n",
    "`keras` is now available as a submodule of tensorflow (you can also install it as a separate package):\n",
    "\n",
    "```python\n",
    "import tensorflow as tf\n",
    "```\n",
    "\n",
    "Keras provides a lot of ready-made layer types, activation functions, optimizers and so on. Do not hesitate to read its documentation on <https://keras.io>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most important object in keras is `Sequential`. It is a container where you sequentially add layers of neurons (fully-connected, convolutional, recurrent, etc) and other stuff. It represents your model, i.e. the neural network itself.\n",
    "\n",
    "```python\n",
    "model = tf.keras.models.Sequential()\n",
    "```\n",
    "\n",
    "You can then `add()` layers to the model. A fully-connected layer is called `Dense` in keras. \n",
    "\n",
    "Let's create a MLP with 10 input neurons, two hidden layers with 100 hidden neurons each and 3 output neurons. \n",
    "\n",
    "The input layer is represented by the `Input` layer:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Input((10,)))\n",
    "```\n",
    "\n",
    "The first hidden layer can be added to the model with:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(100, activation=\"relu\"))\n",
    "```\n",
    "\n",
    "The layer has 100 neurons and uses the ReLU activation function. One could optionally define the activation function as an additional \"layer\", but it is usually not needed:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(100))\n",
    "model.add(tf.keras.layers.Activation('relu'))\n",
    "```\n",
    "\n",
    "Adding more layers is straightforward:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(100, activation=\"relu\"))\n",
    "```\n",
    "\n",
    "Finally, we can add the output layer. The activation function depends on the problem:\n",
    "\n",
    "* For regression problems, a linear activation function should be used when the targets can take any value (e.g. Q-values):\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(3, activation=\"linear\"))\n",
    "```\n",
    "\n",
    "If the targets are bounded between 0 and 1, a logistic/sigmoid function can be used:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(3, activation=\"sigmoid\"))\n",
    "```\n",
    "\n",
    "* For multi-class classification problems, a softmax activation function should be used:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dense(3, activation=\"softmax\"))\n",
    "```\n",
    "\n",
    "This defines fully the structure of your desired neural network.\n",
    "\n",
    "**Q:** Implement a neural network for classification with 10 input neurons, two hidden layers with 100 neurons each (using ReLU) and 3 output neurons.\n",
    "\n",
    "*Hint:* `print(model.summary())` gives you a summary of the architecture of your model. Note in particular the number of trainable parameters (weights and biases)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1 Pro\n",
      "\n",
      "systemMemory: 16.00 GB\n",
      "maxCacheSize: 5.33 GB\n",
      "\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 100)               1100      \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 100)               10100     \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 3)                 303       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 11,503\n",
      "Trainable params: 11,503\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:31:35.132826: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:306] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-11-24 18:31:35.133149: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:272] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.models.Sequential()\n",
    "model.add(tf.keras.layers.Input((10,)))\n",
    "model.add(tf.keras.layers.Dense(100, activation=\"relu\"))\n",
    "model.add(tf.keras.layers.Dense(100, activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(3, activation='softmax'))\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to choose an **optimizer** for the neural network, i.e. a variant of gradient descent that will be used to iteratively modify the parameters.\n",
    "\n",
    "`keras` provides an extensive list of optimizers: <https://keras.io/optimizers/>. The most useful in practice are:\n",
    "\n",
    "* `SGD`, the vanilla stochastic gradient descent.\n",
    "\n",
    "```python\n",
    "optimizer = tf.keras.optimizers.SGD(learning_rate=0.001, momentum=0.9, nesterov=True)\n",
    "```\n",
    "\n",
    "* `RMSprop`, using second moments:\n",
    "\n",
    "```python\n",
    "optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.001)\n",
    "```\n",
    "\n",
    "* `Adam`:\n",
    "\n",
    "```python\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "```\n",
    "\n",
    "Choosing a optimizer is a matter of taste and trial-and-error. In deep RL, a good choice is Adam: the default values for its other parameters are usually good, it converges well, so your only job is to find the right learning rate.\n",
    "\n",
    "Finally, the model must be **compiled** by defining:\n",
    "\n",
    "* A loss function. For multi-class classification, it should be `'categorical_crossentropy'`. For regression, it can be `'mse'`. See the list of built-in loss functions here: <https://keras.io/losses/> but know that you can also simply define your own.\n",
    "\n",
    "* The chosen optimizer.\n",
    "\n",
    "* The metrics, i.e. what you want tensorflow to print during training. By default it only prints the current value of the loss function. For classification tasks, it usually makes more sense to also print the `accuracy`.\n",
    "\n",
    "```python\n",
    "model.compile(\n",
    "    loss='categorical_crossentropy', \n",
    "    optimizer=optimizer,\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "```\n",
    "\n",
    "**Q:** Compile the model for classification, using the Adam optimizer and a learning rate of 0.01."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)\n",
    "\n",
    "model.compile(\n",
    "    loss='categorical_crossentropy', \n",
    "    optimizer=optimizer,\n",
    "    metrics=['accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now train the model on some dummy data. To show the power of deep neural networks, we will try to learn noise by heart.\n",
    "\n",
    "The following cell creates an input tensor `X` with 1000 random vectors of 10 elements, with values sampled between -1 and 1. The targets (desired outputs) `t` are class indices (0, 1 or 2), also randomly selected.  \n",
    "\n",
    "However, neural networks expect **one-hot encoded vectors** for the target, i.e. (1, 0, 0), (0, 1, 0), (0, 0, 1) instead of 0, 1, 2. The method `tf.keras.utils.to_categorical` allows you to do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.uniform(-1.0, 1.0, (1000, 10))\n",
    "t = np.random.randint(0, 3, (1000, ))\n",
    "T = tf.keras.utils.to_categorical(t, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's learn it. The `Sequential` model has a method called `fit()` where you simply pass the training data `(X, T)` and some other parameters, such as:\n",
    "\n",
    "* the batch size,\n",
    "* the total number of epochs,\n",
    "* the proportion of training examples to keep in order to compute the validation loss/accuracy (optional but recommmended).\n",
    "\n",
    "```python\n",
    "# Training\n",
    "history = tf.keras.callbacks.History()\n",
    "\n",
    "model.fit(\n",
    "    X, T,\n",
    "    batch_size=100, \n",
    "    epochs=50,\n",
    "    validation_split=0.1,\n",
    "    callbacks=[history]\n",
    ")\n",
    "```\n",
    "\n",
    "**Q:** Train the model on the data, using a batch size of 100 for 50 epochs. Explain why you obtained this result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:31:37.930309: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n",
      "2022-11-24 18:31:38.157447: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9/9 - 1s - loss: 1.1183 - accuracy: 0.3244 - val_loss: 1.1404 - val_accuracy: 0.3300 - 1s/epoch - 162ms/step\n",
      "Epoch 2/50\n",
      "9/9 - 0s - loss: 1.0802 - accuracy: 0.3878 - val_loss: 1.1295 - val_accuracy: 0.2700 - 96ms/epoch - 11ms/step\n",
      "Epoch 3/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:31:39.375487: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9/9 - 0s - loss: 1.0632 - accuracy: 0.4667 - val_loss: 1.1320 - val_accuracy: 0.2500 - 93ms/epoch - 10ms/step\n",
      "Epoch 4/50\n",
      "9/9 - 0s - loss: 1.0375 - accuracy: 0.4767 - val_loss: 1.1671 - val_accuracy: 0.2500 - 89ms/epoch - 10ms/step\n",
      "Epoch 5/50\n",
      "9/9 - 0s - loss: 1.0111 - accuracy: 0.5111 - val_loss: 1.1752 - val_accuracy: 0.3100 - 89ms/epoch - 10ms/step\n",
      "Epoch 6/50\n",
      "9/9 - 0s - loss: 0.9863 - accuracy: 0.5033 - val_loss: 1.2184 - val_accuracy: 0.2800 - 90ms/epoch - 10ms/step\n",
      "Epoch 7/50\n",
      "9/9 - 0s - loss: 0.9553 - accuracy: 0.5433 - val_loss: 1.2167 - val_accuracy: 0.2800 - 89ms/epoch - 10ms/step\n",
      "Epoch 8/50\n",
      "9/9 - 0s - loss: 0.9197 - accuracy: 0.5678 - val_loss: 1.3535 - val_accuracy: 0.3000 - 90ms/epoch - 10ms/step\n",
      "Epoch 9/50\n",
      "9/9 - 0s - loss: 0.8824 - accuracy: 0.5900 - val_loss: 1.3571 - val_accuracy: 0.3200 - 88ms/epoch - 10ms/step\n",
      "Epoch 10/50\n",
      "9/9 - 0s - loss: 0.8560 - accuracy: 0.6267 - val_loss: 1.3682 - val_accuracy: 0.2400 - 90ms/epoch - 10ms/step\n",
      "Epoch 11/50\n",
      "9/9 - 0s - loss: 0.8125 - accuracy: 0.6467 - val_loss: 1.4521 - val_accuracy: 0.2900 - 89ms/epoch - 10ms/step\n",
      "Epoch 12/50\n",
      "9/9 - 0s - loss: 0.7604 - accuracy: 0.6667 - val_loss: 1.4538 - val_accuracy: 0.2700 - 88ms/epoch - 10ms/step\n",
      "Epoch 13/50\n",
      "9/9 - 0s - loss: 0.6953 - accuracy: 0.7289 - val_loss: 1.5755 - val_accuracy: 0.2900 - 87ms/epoch - 10ms/step\n",
      "Epoch 14/50\n",
      "9/9 - 0s - loss: 0.6484 - accuracy: 0.7500 - val_loss: 1.6463 - val_accuracy: 0.3000 - 88ms/epoch - 10ms/step\n",
      "Epoch 15/50\n",
      "9/9 - 0s - loss: 0.6264 - accuracy: 0.7433 - val_loss: 1.7369 - val_accuracy: 0.2800 - 89ms/epoch - 10ms/step\n",
      "Epoch 16/50\n",
      "9/9 - 0s - loss: 0.5558 - accuracy: 0.8022 - val_loss: 1.8089 - val_accuracy: 0.2600 - 88ms/epoch - 10ms/step\n",
      "Epoch 17/50\n",
      "9/9 - 0s - loss: 0.4886 - accuracy: 0.8300 - val_loss: 1.9365 - val_accuracy: 0.2700 - 93ms/epoch - 10ms/step\n",
      "Epoch 18/50\n",
      "9/9 - 0s - loss: 0.4341 - accuracy: 0.8644 - val_loss: 2.0011 - val_accuracy: 0.3100 - 101ms/epoch - 11ms/step\n",
      "Epoch 19/50\n",
      "9/9 - 0s - loss: 0.3999 - accuracy: 0.8700 - val_loss: 2.1024 - val_accuracy: 0.2900 - 106ms/epoch - 12ms/step\n",
      "Epoch 20/50\n",
      "9/9 - 0s - loss: 0.3671 - accuracy: 0.8833 - val_loss: 2.3319 - val_accuracy: 0.3400 - 99ms/epoch - 11ms/step\n",
      "Epoch 21/50\n",
      "9/9 - 0s - loss: 0.3761 - accuracy: 0.8667 - val_loss: 2.4605 - val_accuracy: 0.2700 - 100ms/epoch - 11ms/step\n",
      "Epoch 22/50\n",
      "9/9 - 0s - loss: 0.3324 - accuracy: 0.8822 - val_loss: 2.4886 - val_accuracy: 0.3200 - 97ms/epoch - 11ms/step\n",
      "Epoch 23/50\n",
      "9/9 - 0s - loss: 0.2755 - accuracy: 0.9100 - val_loss: 2.5855 - val_accuracy: 0.3200 - 98ms/epoch - 11ms/step\n",
      "Epoch 24/50\n",
      "9/9 - 0s - loss: 0.2489 - accuracy: 0.9256 - val_loss: 2.7775 - val_accuracy: 0.3400 - 98ms/epoch - 11ms/step\n",
      "Epoch 25/50\n",
      "9/9 - 0s - loss: 0.2084 - accuracy: 0.9489 - val_loss: 2.7613 - val_accuracy: 0.2900 - 93ms/epoch - 10ms/step\n",
      "Epoch 26/50\n",
      "9/9 - 0s - loss: 0.1561 - accuracy: 0.9744 - val_loss: 3.0682 - val_accuracy: 0.3000 - 97ms/epoch - 11ms/step\n",
      "Epoch 27/50\n",
      "9/9 - 0s - loss: 0.1364 - accuracy: 0.9756 - val_loss: 3.0417 - val_accuracy: 0.2900 - 91ms/epoch - 10ms/step\n",
      "Epoch 28/50\n",
      "9/9 - 0s - loss: 0.1177 - accuracy: 0.9833 - val_loss: 3.2456 - val_accuracy: 0.2900 - 92ms/epoch - 10ms/step\n",
      "Epoch 29/50\n",
      "9/9 - 0s - loss: 0.0996 - accuracy: 0.9933 - val_loss: 3.3559 - val_accuracy: 0.3000 - 90ms/epoch - 10ms/step\n",
      "Epoch 30/50\n",
      "9/9 - 0s - loss: 0.0882 - accuracy: 0.9911 - val_loss: 3.4259 - val_accuracy: 0.3000 - 90ms/epoch - 10ms/step\n",
      "Epoch 31/50\n",
      "9/9 - 0s - loss: 0.0788 - accuracy: 0.9944 - val_loss: 3.6843 - val_accuracy: 0.2800 - 90ms/epoch - 10ms/step\n",
      "Epoch 32/50\n",
      "9/9 - 0s - loss: 0.0636 - accuracy: 0.9978 - val_loss: 3.6871 - val_accuracy: 0.3000 - 89ms/epoch - 10ms/step\n",
      "Epoch 33/50\n",
      "9/9 - 0s - loss: 0.0502 - accuracy: 1.0000 - val_loss: 3.8740 - val_accuracy: 0.3000 - 87ms/epoch - 10ms/step\n",
      "Epoch 34/50\n",
      "9/9 - 0s - loss: 0.0451 - accuracy: 0.9989 - val_loss: 3.7788 - val_accuracy: 0.3100 - 87ms/epoch - 10ms/step\n",
      "Epoch 35/50\n",
      "9/9 - 0s - loss: 0.0377 - accuracy: 1.0000 - val_loss: 4.1327 - val_accuracy: 0.2900 - 89ms/epoch - 10ms/step\n",
      "Epoch 36/50\n",
      "9/9 - 0s - loss: 0.0320 - accuracy: 1.0000 - val_loss: 3.9984 - val_accuracy: 0.2900 - 91ms/epoch - 10ms/step\n",
      "Epoch 37/50\n",
      "9/9 - 0s - loss: 0.0261 - accuracy: 1.0000 - val_loss: 4.1676 - val_accuracy: 0.2900 - 88ms/epoch - 10ms/step\n",
      "Epoch 38/50\n",
      "9/9 - 0s - loss: 0.0223 - accuracy: 1.0000 - val_loss: 4.2871 - val_accuracy: 0.2800 - 91ms/epoch - 10ms/step\n",
      "Epoch 39/50\n",
      "9/9 - 0s - loss: 0.0198 - accuracy: 1.0000 - val_loss: 4.3003 - val_accuracy: 0.2900 - 89ms/epoch - 10ms/step\n",
      "Epoch 40/50\n",
      "9/9 - 0s - loss: 0.0175 - accuracy: 1.0000 - val_loss: 4.4379 - val_accuracy: 0.2800 - 90ms/epoch - 10ms/step\n",
      "Epoch 41/50\n",
      "9/9 - 0s - loss: 0.0164 - accuracy: 1.0000 - val_loss: 4.4096 - val_accuracy: 0.2800 - 89ms/epoch - 10ms/step\n",
      "Epoch 42/50\n",
      "9/9 - 0s - loss: 0.0145 - accuracy: 1.0000 - val_loss: 4.5412 - val_accuracy: 0.2900 - 90ms/epoch - 10ms/step\n",
      "Epoch 43/50\n",
      "9/9 - 0s - loss: 0.0134 - accuracy: 1.0000 - val_loss: 4.5190 - val_accuracy: 0.2900 - 89ms/epoch - 10ms/step\n",
      "Epoch 44/50\n",
      "9/9 - 0s - loss: 0.0124 - accuracy: 1.0000 - val_loss: 4.6218 - val_accuracy: 0.2900 - 89ms/epoch - 10ms/step\n",
      "Epoch 45/50\n",
      "9/9 - 0s - loss: 0.0115 - accuracy: 1.0000 - val_loss: 4.6663 - val_accuracy: 0.2800 - 87ms/epoch - 10ms/step\n",
      "Epoch 46/50\n",
      "9/9 - 0s - loss: 0.0108 - accuracy: 1.0000 - val_loss: 4.6790 - val_accuracy: 0.3000 - 91ms/epoch - 10ms/step\n",
      "Epoch 47/50\n",
      "9/9 - 0s - loss: 0.0101 - accuracy: 1.0000 - val_loss: 4.7649 - val_accuracy: 0.2900 - 87ms/epoch - 10ms/step\n",
      "Epoch 48/50\n",
      "9/9 - 0s - loss: 0.0096 - accuracy: 1.0000 - val_loss: 4.8301 - val_accuracy: 0.2900 - 95ms/epoch - 11ms/step\n",
      "Epoch 49/50\n",
      "9/9 - 0s - loss: 0.0089 - accuracy: 1.0000 - val_loss: 4.8164 - val_accuracy: 0.2900 - 90ms/epoch - 10ms/step\n",
      "Epoch 50/50\n",
      "9/9 - 0s - loss: 0.0084 - accuracy: 1.0000 - val_loss: 4.9097 - val_accuracy: 0.2900 - 88ms/epoch - 10ms/step\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    X, T,\n",
    "    batch_size=100, \n",
    "    epochs=50,\n",
    "    validation_split=0.1,\n",
    "    verbose=2\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** The final training is 100%, the validation accuracy is 33% (may vary depending on initialization). The network has learned the training examples by heart, although they are totally random, but totally fails to generalize.\n",
    "\n",
    "The main is reason is that we have only 1000 training examples, with a total number of free parameters (VC dimension) around 11500. By definition, the model can learn this training set perfectly, although it is totally random. Its VC dimension is however way to high to generalize anything. It is even worse here: as the data is random, there is nothing to generalize. A nice example to understand why NN overfit..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a MLP on MNIST\n",
    "\n",
    "Let's now try to learn something a bit more serious, the MNIST dataset. The following cell load the MNIST data (training set 60000 28x28 monochrome images, test set of 10000 images), normalizes it (values betwen 0 and 1 for each pixel), removes the mean image from the training set and transforms the targets to one-hot encoded vectors for the 10 classes. See the neurocomputing exercise for more details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data: (60000, 28, 28) (60000,)\n",
      "Test data: (10000, 28, 28) (10000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the MNIST dataset\n",
    "(X_train, t_train), (X_test, t_test) = tf.keras.datasets.mnist.load_data()\n",
    "print(\"Training data:\", X_train.shape, t_train.shape)\n",
    "print(\"Test data:\", X_test.shape, t_test.shape)\n",
    "\n",
    "# Reshape the images to vectors and normalize\n",
    "X_train = X_train.reshape(X_train.shape[0], 784).astype('float32') / 255.\n",
    "X_test = X_test.reshape(X_test.shape[0], 784).astype('float32') / 255.\n",
    "\n",
    "# Mean removal\n",
    "X_mean = np.mean(X_train, axis=0)\n",
    "X_train -= X_mean\n",
    "X_test -= X_mean\n",
    "\n",
    "# One-hot encoded outputs\n",
    "T_train = tf.keras.utils.to_categorical(t_train, 10)\n",
    "T_test = tf.keras.utils.to_categorical(t_test, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Create a fully connected neural network with 784 input neurons (one per pixel), 10 softmax output neurons and whatever you want in the middle, so that it can reach around 98% validation accuracy after **20 epochs**.\n",
    "\n",
    "* Put the network creation (including `compile()`) in a method `create_model()`, so that you can create a model multiple times.\n",
    "* Choose a good value for the learning rate.\n",
    "* Do not exagerate with the number of layers and neurons. Two or there hidden layers with 100 to 300 neurons are more than enough.\n",
    "* You will quickly observe that the network overfits: the training accuracy is higher than the validation accuracy. The training accuracy actually goes to 100% if your network is too big. In that case, feel free to add a dropout layer after each fully-connected layer:\n",
    "\n",
    "```python\n",
    "model.add(tf.keras.layers.Dropout(0.5))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    # Create the model\n",
    "    model = tf.keras.models.Sequential()\n",
    "    \n",
    "    # Input layer with 784 pixels\n",
    "    model.add(tf.keras.layers.Input((784,)))\n",
    "\n",
    "    # Hidden layer with 150 neurons\n",
    "    model.add(tf.keras.layers.Dense(150, activation=\"relu\"))\n",
    "    model.add(tf.keras.layers.Dropout(0.5))\n",
    "\n",
    "    # Second hidden layer with 100 neurons\n",
    "    model.add(tf.keras.layers.Dense(100, activation=\"relu\"))\n",
    "    model.add(tf.keras.layers.Dropout(0.5))\n",
    "\n",
    "    # Softmax output layer with 10 neurons\n",
    "    model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n",
    "\n",
    "    # Learning rule\n",
    "    optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "\n",
    "    # Loss function\n",
    "    model.compile(\n",
    "        loss='categorical_crossentropy', # loss\n",
    "        optimizer=optimizer, # learning rule\n",
    "        metrics=['accuracy'] # show accuracy\n",
    "    )\n",
    "    print(model.summary())\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_3 (Dense)             (None, 150)               117750    \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 150)               0         \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 100)               15100     \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 100)               0         \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 10)                1010      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 133,860\n",
      "Trainable params: 133,860\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "Epoch 1/20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:31:53.203907: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "538/540 [============================>.] - ETA: 0s - loss: 0.5194 - accuracy: 0.8409"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:31:58.951897: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "540/540 [==============================] - 6s 11ms/step - loss: 0.5185 - accuracy: 0.8411 - val_loss: 0.1482 - val_accuracy: 0.9577\n",
      "Epoch 2/20\n",
      "540/540 [==============================] - 6s 10ms/step - loss: 0.2497 - accuracy: 0.9261 - val_loss: 0.1195 - val_accuracy: 0.9637\n",
      "Epoch 3/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.2007 - accuracy: 0.9414 - val_loss: 0.0993 - val_accuracy: 0.9705\n",
      "Epoch 4/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1732 - accuracy: 0.9485 - val_loss: 0.0932 - val_accuracy: 0.9718\n",
      "Epoch 5/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1580 - accuracy: 0.9530 - val_loss: 0.0823 - val_accuracy: 0.9747\n",
      "Epoch 6/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1453 - accuracy: 0.9562 - val_loss: 0.0819 - val_accuracy: 0.9752\n",
      "Epoch 7/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1319 - accuracy: 0.9602 - val_loss: 0.0800 - val_accuracy: 0.9747\n",
      "Epoch 8/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1238 - accuracy: 0.9616 - val_loss: 0.0740 - val_accuracy: 0.9780\n",
      "Epoch 9/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1178 - accuracy: 0.9639 - val_loss: 0.0726 - val_accuracy: 0.9772\n",
      "Epoch 10/20\n",
      "540/540 [==============================] - 6s 10ms/step - loss: 0.1109 - accuracy: 0.9657 - val_loss: 0.0719 - val_accuracy: 0.9785\n",
      "Epoch 11/20\n",
      "540/540 [==============================] - 6s 10ms/step - loss: 0.1055 - accuracy: 0.9670 - val_loss: 0.0729 - val_accuracy: 0.9772\n",
      "Epoch 12/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.1029 - accuracy: 0.9681 - val_loss: 0.0718 - val_accuracy: 0.9777\n",
      "Epoch 13/20\n",
      "540/540 [==============================] - 6s 10ms/step - loss: 0.1007 - accuracy: 0.9683 - val_loss: 0.0664 - val_accuracy: 0.9803\n",
      "Epoch 14/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0939 - accuracy: 0.9701 - val_loss: 0.0688 - val_accuracy: 0.9778\n",
      "Epoch 15/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0916 - accuracy: 0.9716 - val_loss: 0.0684 - val_accuracy: 0.9793\n",
      "Epoch 16/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0889 - accuracy: 0.9723 - val_loss: 0.0661 - val_accuracy: 0.9822\n",
      "Epoch 17/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0845 - accuracy: 0.9740 - val_loss: 0.0687 - val_accuracy: 0.9807\n",
      "Epoch 18/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0840 - accuracy: 0.9733 - val_loss: 0.0685 - val_accuracy: 0.9812\n",
      "Epoch 19/20\n",
      "540/540 [==============================] - 6s 11ms/step - loss: 0.0791 - accuracy: 0.9755 - val_loss: 0.0717 - val_accuracy: 0.9808\n",
      "Epoch 20/20\n",
      "540/540 [==============================] - 5s 10ms/step - loss: 0.0817 - accuracy: 0.9740 - val_loss: 0.0669 - val_accuracy: 0.9815\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x16579a610>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = create_model()\n",
    "\n",
    "# Training\n",
    "history = tf.keras.callbacks.History()\n",
    "\n",
    "model.fit(\n",
    "    X_train, T_train,\n",
    "    batch_size=100, \n",
    "    epochs=20,\n",
    "    validation_split=0.1,\n",
    "    callbacks=[history]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training, one should evaluate the model on the test set. `keras` provides an `evaluate()` method that computes the different metrics (in our case the loss) on the data:\n",
    "\n",
    "```python\n",
    "score = model.evaluate(X_test, T_test)\n",
    "```\n",
    "\n",
    "Another solution would be to `predict()` labels on the test set and manually compare them to the ground truth:\n",
    "\n",
    "```python\n",
    "Y = model.predict(X_test)\n",
    "loss = - np.mean(T_test * np.log(Y))\n",
    "predicted_classes = np.argmax(Y, axis=1)\n",
    "accuracy = 1.0 - np.sum(predicted_classes != t_test)/t_test.shape[0]\n",
    "```\n",
    "\n",
    "Another important thing to visualize after training is how the training and validation loss (or accuracy) evolved during training. The `fit()` method updates a `History` object which contains the history of your metrics (loss and accuracy) after each epoch of training. These are simple numpy arrays, accessible with:\n",
    "\n",
    "```python\n",
    "history.history['loss']\n",
    "history.history['val_loss']\n",
    "history.history['accuracy']\n",
    "history.history['val_accuracy']\n",
    "```\n",
    "\n",
    "**Q:** Compute the test loss and accuracy of your model. Plot the history of the training and validation loss/accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 14/313 [>.............................] - ETA: 2s - loss: 0.0518 - accuracy: 0.9866"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:33:42.354208: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 3s 9ms/step - loss: 0.0763 - accuracy: 0.9782\n",
      "Test loss: 0.07633379101753235\n",
      "Test accuracy: 0.9782000184059143\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Testing\n",
    "score = model.evaluate(X_test, T_test)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "plt.figure(figsize=(15, 6))\n",
    "plt.subplot(121)\n",
    "plt.plot(history.history['loss'], '-r', label=\"Training\")\n",
    "plt.plot(history.history['val_loss'], '-b', label=\"Validation\")\n",
    "plt.xlabel('Epoch #')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.subplot(122)\n",
    "plt.plot(history.history['accuracy'], '-r', label=\"Training\")\n",
    "plt.plot(history.history['val_accuracy'], '-b', label=\"Validation\")\n",
    "plt.xlabel('Epoch #')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Correlated inputs\n",
    "\n",
    "Now that we have a basic NN working on MNIST, let's investigate why deep NN hate sequentially correlated inputs (which is the main justification for the experience replay memory in DQN). Is that really true, or is just some mathematical assumption that does not matter in practice?\n",
    "\n",
    "The idea of this part is the following: we will train the same network as before for 20 epochs, but each epoch will train the network on all the 0s first, then all the 1s, etc. Each epoch will contain the same number of training examples as before, but the order of presentation will simply be different.\n",
    "\n",
    "To get all examples of the training set which have the target 3 (for example), you just have to slice the matrices accordingly:\n",
    "\n",
    "```python\n",
    "X = X_train[t_train==3, :]\n",
    "T = T_train[t_train==3]\n",
    "```\n",
    "\n",
    "**Q:** Train the same network as before (but reinitialize it!) for 20 epochs, with each epoch sequentially iterating over the classes 0, 1, 2, 3, etc. Plot the loss and accurary during training. What do you observe?\n",
    "\n",
    "*Hint:* you will have two for loops to write: one over the epochs, one over the digits.\n",
    "\n",
    "```python\n",
    "for e in range(20):\n",
    "    for c in range(10):\n",
    "        model.fit(...)\n",
    "```\n",
    "\n",
    "You should only do one epoch for each call to `fit()`. Set `verbose=0` in `fit()` to avoid printing too much info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_6 (Dense)             (None, 150)               117750    \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 150)               0         \n",
      "                                                                 \n",
      " dense_7 (Dense)             (None, 100)               15100     \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 100)               0         \n",
      "                                                                 \n",
      " dense_8 (Dense)             (None, 10)                1010      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 133,860\n",
      "Trainable params: 133,860\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "Epoch:  1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-24 18:33:52.698762: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n",
      "2022-11-24 18:33:53.547791: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Training loss: 2.1789441108703613\n",
      " Training accuracy: 0.4577885866165161\n",
      " Validation loss: 0.06307889521121979\n",
      " Validation accuracy: 0.9831932783126831\n",
      "Epoch:  2\n",
      " Training loss: 1.1442071199417114\n",
      " Training accuracy: 0.7080687284469604\n",
      " Validation loss: 0.027842853218317032\n",
      " Validation accuracy: 0.9899159669876099\n",
      "Epoch:  3\n",
      " Training loss: 0.8554081320762634\n",
      " Training accuracy: 0.7674636244773865\n",
      " Validation loss: 0.06736434251070023\n",
      " Validation accuracy: 0.9831932783126831\n",
      "Epoch:  4\n",
      " Training loss: 0.6917049288749695\n",
      " Training accuracy: 0.7822189331054688\n",
      " Validation loss: 0.052796363830566406\n",
      " Validation accuracy: 0.9865546226501465\n",
      "Epoch:  5\n",
      " Training loss: 0.5919428467750549\n",
      " Training accuracy: 0.8147180080413818\n",
      " Validation loss: 0.04681151360273361\n",
      " Validation accuracy: 0.9831932783126831\n",
      "Epoch:  6\n",
      " Training loss: 0.4891780614852905\n",
      " Training accuracy: 0.8408666849136353\n",
      " Validation loss: 0.043771397322416306\n",
      " Validation accuracy: 0.9882352948188782\n",
      "Epoch:  7\n",
      " Training loss: 0.44778183102607727\n",
      " Training accuracy: 0.8599178194999695\n",
      " Validation loss: 0.03981785476207733\n",
      " Validation accuracy: 0.9882352948188782\n",
      "Epoch:  8\n",
      " Training loss: 0.48525184392929077\n",
      " Training accuracy: 0.8421741127967834\n",
      " Validation loss: 0.038229942321777344\n",
      " Validation accuracy: 0.9882352948188782\n",
      "Epoch:  9\n",
      " Training loss: 0.4880279004573822\n",
      " Training accuracy: 0.8502054810523987\n",
      " Validation loss: 0.04261568561196327\n",
      " Validation accuracy: 0.9899159669876099\n",
      "Epoch:  10\n",
      " Training loss: 0.41330939531326294\n",
      " Training accuracy: 0.86720210313797\n",
      " Validation loss: 0.043336544185876846\n",
      " Validation accuracy: 0.9865546226501465\n",
      "Epoch:  11\n",
      " Training loss: 0.42511239647865295\n",
      " Training accuracy: 0.8647740483283997\n",
      " Validation loss: 0.042776186019182205\n",
      " Validation accuracy: 0.9865546226501465\n",
      "Epoch:  12\n",
      " Training loss: 0.43565788865089417\n",
      " Training accuracy: 0.8683227896690369\n",
      " Validation loss: 0.037856556475162506\n",
      " Validation accuracy: 0.9865546226501465\n",
      "Epoch:  13\n",
      " Training loss: 0.4058941900730133\n",
      " Training accuracy: 0.8754202723503113\n",
      " Validation loss: 0.033589139580726624\n",
      " Validation accuracy: 0.9882352948188782\n",
      "Epoch:  14\n",
      " Training loss: 0.4229739308357239\n",
      " Training accuracy: 0.8685095310211182\n",
      " Validation loss: 0.04102521017193794\n",
      " Validation accuracy: 0.9848739504814148\n",
      "Epoch:  15\n",
      " Training loss: 0.40655088424682617\n",
      " Training accuracy: 0.8804632425308228\n",
      " Validation loss: 0.03230886533856392\n",
      " Validation accuracy: 0.9899159669876099\n",
      "Epoch:  16\n",
      " Training loss: 0.40451598167419434\n",
      " Training accuracy: 0.8726186156272888\n",
      " Validation loss: 0.035236991941928864\n",
      " Validation accuracy: 0.9848739504814148\n",
      "Epoch:  17\n",
      " Training loss: 0.3949117362499237\n",
      " Training accuracy: 0.8808367848396301\n",
      " Validation loss: 0.03679860755801201\n",
      " Validation accuracy: 0.9882352948188782\n",
      "Epoch:  18\n",
      " Training loss: 0.377407431602478\n",
      " Training accuracy: 0.8825177550315857\n",
      " Validation loss: 0.04177376627922058\n",
      " Validation accuracy: 0.9848739504814148\n",
      "Epoch:  19\n",
      " Training loss: 0.35344383120536804\n",
      " Training accuracy: 0.8911094665527344\n",
      " Validation loss: 0.03944191709160805\n",
      " Validation accuracy: 0.9865546226501465\n",
      "Epoch:  20\n",
      " Training loss: 0.3501055836677551\n",
      " Training accuracy: 0.8866268396377563\n",
      " Validation loss: 0.03972172364592552\n",
      " Validation accuracy: 0.9848739504814148\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = create_model()\n",
    "\n",
    "history = tf.keras.callbacks.History()\n",
    "\n",
    "for e in range(20):\n",
    "    print(\"Epoch: \", e+1)\n",
    "    for c in range(10):\n",
    "        # Training\n",
    "        model.fit(\n",
    "            X_train[t_train==c, :], T_train[t_train==c, :],\n",
    "            batch_size=100, \n",
    "            epochs=1,\n",
    "            validation_split=0.1,\n",
    "            verbose = 0,\n",
    "            callbacks=[history]\n",
    "        )\n",
    "    print(\" Training loss:\", history.history[\"loss\"][-1])\n",
    "    print(\" Training accuracy:\", history.history[\"accuracy\"][-1])\n",
    "    print(\" Validation loss:\", history.history[\"val_loss\"][-1])\n",
    "    print(\" Validation accuracy:\", history.history[\"val_accuracy\"][-1])\n",
    "        \n",
    "plt.figure(figsize=(15, 6))\n",
    "plt.subplot(121)\n",
    "plt.plot(history.history['loss'], '-r', label=\"Training\")\n",
    "plt.plot(history.history['val_loss'], '-b', label=\"Validation\")\n",
    "plt.xlabel('Epoch #')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.subplot(122)\n",
    "plt.plot(history.history['accuracy'], '-r', label=\"Training\")\n",
    "plt.plot(history.history['val_accuracy'], '-b', label=\"Validation\")\n",
    "plt.xlabel('Epoch #')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** The training accuracy slowly increases (with some oscillations, some numbers are harder to learn than others), but the validation accuracy is suspiciously high right from the start..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Evaluate the model after training on the whole test set. What happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.7852121591567993\n",
      "Test accuracy: 0.778700053691864\n"
     ]
    }
   ],
   "source": [
    "# Testing\n",
    "score = model.evaluate(X_test, T_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** Horror! The test accuracy is now awful, although the training and validation accuracies were fine after 20 epochs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** To better understand what happened, compute the test accuracy of the network on each class of the test set individually: all the 0s of the test set, then all the 1s, etc. What happens? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class 0\n",
      "Test loss: 0.41480857133865356\n",
      "Test accuracy: 0.9061225056648254\n",
      "Class 1\n",
      "Test loss: 0.5983759164810181\n",
      "Test accuracy: 0.882819414138794\n",
      "Class 2\n",
      "Test loss: 0.9812650084495544\n",
      "Test accuracy: 0.7490310072898865\n",
      "Class 3\n",
      "Test loss: 1.302044153213501\n",
      "Test accuracy: 0.5524752736091614\n",
      "Class 4\n",
      "Test loss: 1.409988284111023\n",
      "Test accuracy: 0.5346232652664185\n",
      "Class 5\n",
      "Test loss: 1.21005380153656\n",
      "Test accuracy: 0.6838565468788147\n",
      "Class 6\n",
      "Test loss: 0.16447730362415314\n",
      "Test accuracy: 0.9530271887779236\n",
      "Class 7\n",
      "Test loss: 1.548042893409729\n",
      "Test accuracy: 0.5661478638648987\n",
      "Class 8\n",
      "Test loss: 0.17124219238758087\n",
      "Test accuracy: 0.9691992402076721\n",
      "Class 9\n",
      "Test loss: 0.05847443267703056\n",
      "Test accuracy: 0.9831516742706299\n"
     ]
    }
   ],
   "source": [
    "for c in range(10):\n",
    "    score = model.evaluate(X_test[t_test==c, :], T_test[t_test==c, :], verbose=0)\n",
    "    print(\"Class\", c)\n",
    "    print('Test loss:', score[0])\n",
    "    print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** The last digits to be seen during training are the 9s: they have a good test accuracy. The 8s were seen not too long ago, they are also OK. But the other digits have been forgotten! The memory has been erased. This explains why you cannot train a deep network on-policy: the last episode would be remembered, but all the previous ones would be erased (catastrophic forgetting).\n",
    "\n",
    "A notable exception is for the 6s, which look like 9s, and the 0s, which look like 8s: they share features with the digits which are well recognized, so they perform OK."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Increase and decrease the learning rate of the optimizer. What do you observe? Is there a solution to this problem? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** Increasing the learning rate worsens the problem. Decreasing does help, but then learning is very slow. This is classical example of catastrophic forgetting: learning a new task erases the previous ones. There is no solution to this problem for now, apart from taking **i.i.d** samples in each minibatch."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "deeprl",
   "language": "python",
   "name": "deeprl"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}