notebooks/CL_via_simple_rehearsal.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "CL_via_simple_rehearsal.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQeST5MvlcaF"
      },
      "source": [
        "Although current machine learning algorithms have acquired a good reputation in terms of achieving the goals they are trained to do, they are prone to foregtting old data. If one takes a trained model and fine-tunes it on different data, its performance on the old data deteriorates. This is what the community calls **Catastrophic Forgetting**. There are many questions that rotates around this concept, but in this notebook we are going to introduce the most basic ones.\n",
        "\n",
        "1- How the performance is affected when we train our models in a temporal fashion.\n",
        "\n",
        "2- What are the basic remedies to avoid deterioration over time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FaQ1pwRvujrg"
      },
      "source": [
        "**Data**\n",
        "\n",
        "First, we need to simulate a dataset that mimic the temporal nature of the problem we have in hand. One way to achieve that is splitting up already exisiting datasets into smaller sets of tasks that change over time.\n",
        "\n",
        "To keep everything simple we will use MNIST as our source dataset and split it over 5 smaller datasets where each one recognizes 2 numbers. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VoJa5cY1aMga"
      },
      "source": [
        "There are two ways to treat the 5 splitted tasks:\n",
        "\n",
        "\n",
        "**1- Multi-head setting** \n",
        "\n",
        "&emsp; &emsp; Where for every single task we have a common hidden representation and a head specific to that task. When a new task comes, we use the same hidden representation and create a unique head. At test time, we should keep track of which task the test data belongs to. For example, for MNIST data, we first train the model to identify 0 & 1 images then, when the second task comes, the model fine-tunes the hidden representation and creates a new head to identify 2 & 3 images. In the previous example, the model will keep track that 2 & 3 data belong to task #2 and it will expect to receive this information at test time to acquire the right head.\n",
        "This has the negative side effect of needing knowledge about what task a datapoint belongs to. This is particularly unrealistic in real-world scenarios.\n",
        " \n",
        "**2- Single-head setting**\n",
        "\n",
        "&emsp; &emsp; In this setting, one unified model shall be used across all tasks. The number of output units will grow as the number of the encountered classes increases. When known in advance, the total number of tasks can be used from the beginning. For MNIST, 10 output units will be used. Despite the fact that 0 and 2 images might not be directly compared in the same task, the model should still be capable of distinguishing them without any additional information. At test time, we can process the data whitout keeping track of what task this data occured in, which is a more realistic setting.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7aXbQlylnyx"
      },
      "source": [
        "*The performance will be evaluated as the average accuracy over all seen tasks.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k7Z8f35aee1E"
      },
      "source": [
        "**Using MNIST data for CL: Split MNIST benchmark**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sWSZmaW-ef-q"
      },
      "source": [
        "# some initial imports\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as datasets\n",
        "import torchvision.transforms as transforms\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bWXs3Fy9b-Pu"
      },
      "source": [
        "# switch to False to use CPU\n",
        "use_cuda = True\n",
        "\n",
        "use_cuda = use_cuda and torch.cuda.is_available()\n",
        "device = torch.device(\"cuda\" if use_cuda else \"cpu\");\n",
        "torch.manual_seed(1);"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kyob1mpgui_j",
        "outputId": "0cd13fed-117b-4cc5-fa3e-98595e63181e"
      },
      "source": [
        "# Get MNIST data\n",
        "!git clone https://github.com/ContinualAI/colab.git continualai/colab\n",
        "\n",
        "from continualai.colab.scripts import mnist\n",
        "mnist.init()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'continualai/colab'...\n",
            "remote: Enumerating objects: 37, done.\u001b[K\n",
            "remote: Counting objects: 100% (37/37), done.\u001b[K\n",
            "remote: Compressing objects: 100% (26/26), done.\u001b[K\n",
            "remote: Total 157 (delta 15), reused 24 (delta 8), pack-reused 120\u001b[K\n",
            "Receiving objects: 100% (157/157), 10.09 MiB | 49.67 MiB/s, done.\n",
            "Resolving deltas: 100% (57/57), done.\n",
            "Downloading train-images-idx3-ubyte.gz...\n",
            "Downloading t10k-images-idx3-ubyte.gz...\n",
            "Downloading train-labels-idx1-ubyte.gz...\n",
            "Downloading t10k-labels-idx1-ubyte.gz...\n",
            "Download complete.\n",
            "Save complete.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ooruQrvHlb1S",
        "outputId": "5977ddf7-9f14-4aaa-9820-3aac37857009"
      },
      "source": [
        "# print some MNIST info\n",
        "x_train, t_train, x_test, t_test = mnist.load()\n",
        "\n",
        "print(f'Size of training data is: {t_train.shape[0]}, size of test data: {t_test.shape[0]}')\n",
        "\n",
        "for i in range(10):\n",
        "  print(f'Size of label {i} in training : {len(t_train[t_train == i])}')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Size of training data is: 60000, size of test data: 10000\n",
            "Size of label 0 in training : 5923\n",
            "Size of label 1 in training : 6742\n",
            "Size of label 2 in training : 5958\n",
            "Size of label 3 in training : 6131\n",
            "Size of label 4 in training : 5842\n",
            "Size of label 5 in training : 5421\n",
            "Size of label 6 in training : 5918\n",
            "Size of label 7 in training : 6265\n",
            "Size of label 8 in training : 5851\n",
            "Size of label 9 in training : 5949\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CsLkDNQ9UHQM"
      },
      "source": [
        "*We* can start by splitting the data into 5 tasks according to their labels. Since the setting with multiple-head will always classify between two classes, we will modify the labels to be always Class 0 or Class 1. We call this `task_data_with_overlap` since the classes overlap. The single-head naturally supports 10 classes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "id": "3PYIvkASeFfn",
        "outputId": "dfd82c87-13e2-4581-ac80-24146e49466e"
      },
      "source": [
        "# tasks to use\n",
        "task_classes_arr = [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]\n",
        "tasks_num = len(task_classes_arr) # 5\n",
        "\n",
        "task_data = []\n",
        "task_data_with_overlap = []\n",
        "for i, task_classes in enumerate(task_classes_arr):\n",
        "  train_mask = np.isin(t_train, task_classes)\n",
        "  test_mask = np.isin(t_test, task_classes)\n",
        "  x_train_task, t_train_task = x_train[train_mask], t_train[train_mask]\n",
        "  x_test_task, t_test_task = x_test[test_mask], t_test[test_mask]\n",
        "  \n",
        "  task_data.append((x_train_task, t_train_task, x_test_task, t_test_task))\n",
        "  task_data_with_overlap.append((x_train_task, t_train_task - (i * 2),\n",
        "                                 x_test_task, t_test_task - (i * 2)))\n",
        "\n",
        "# Display tasks\n",
        "def plot_task(axs, data, samples_num):\n",
        "  for sample in range(samples_num):\n",
        "    axs[sample].imshow(data[sample][0], cmap=\"gray\")\n",
        "    # np.vectorize(lambda ax:ax.axis('off'))(axs[sample]);\n",
        "    axs[sample].xaxis.set_ticks([])\n",
        "    axs[sample].yaxis.set_ticks([])\n",
        "\n",
        "n_tasks, samples = 3, 5\n",
        "_, axs = plt.subplots(n_tasks, samples, figsize=(5, 3))\n",
        "for task in range(n_tasks):\n",
        "  axs[task, 0].set_ylabel(f'Task {task}', rotation=0)\n",
        "  axs[task, 0].yaxis.set_label_coords(-0.5,1)\n",
        "  plot_task(axs[task], task_data[task][0], samples)\n",
        "plt.tight_layout()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x216 with 15 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNjo4B2rq41H"
      },
      "source": [
        "**Naive strategy with Single Head**\n",
        "\n",
        "We will first explore continual learning and forgetting by using a single head, \n",
        "then by using multiple heads.\n",
        "\n",
        "The **Naive** strategy simply finetunes the model on the new data, without applying any CL strategies."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "awLQn1AqkqgZ"
      },
      "source": [
        "# A basic feedforward net\n",
        "class FNet(nn.Module):\n",
        "  def __init__(self, hsize=512):\n",
        "    super(FNet, self).__init__()\n",
        "\n",
        "    self.l1 = nn.Linear(784, hsize)\n",
        "    self.l2 = nn.Linear(hsize, 10)\n",
        "    \n",
        "  def forward(self, x):\n",
        "      x = x.view(x.size(0), -1)\n",
        "      x = F.relu(self.l1(x))\n",
        "      x = self.l2(x)\n",
        "      return x"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxkFzfnlriSA"
      },
      "source": [
        "def train(model, device, x_train, t_train, optimizer, epochs=10, log_training=False):\n",
        "    for epoch in range(epochs):\n",
        "      model.train()\n",
        "      \n",
        "      for start in range(0, len(t_train)-1, 256):\n",
        "        end = start + 256\n",
        "        x, y = torch.from_numpy(x_train[start:end]), torch.from_numpy(t_train[start:end]).long()\n",
        "        x, y = x.to(device), y.to(device)\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        output = model(x)\n",
        "        loss = F.cross_entropy(output, y)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        if log_training:\n",
        "          print('Train Epoch: {} \\tLoss: {:.6f}'.format(epoch, loss.item()))\n",
        "\n",
        "def test(model, device, x_test, t_test):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "    correct = 0\n",
        "    for start in range(0, len(t_test)-1, 256):\n",
        "      end = start + 256\n",
        "      with torch.no_grad():\n",
        "        x, y = torch.from_numpy(x_test[start:end]), torch.from_numpy(t_test[start:end]).long()\n",
        "        x, y = x.to(device), y.to(device)\n",
        "        output = model(x)\n",
        "        test_loss += F.cross_entropy(output, y).item() # sum up batch loss\n",
        "        pred = output.max(1, keepdim=True)[1] # get the index of the max logit\n",
        "        correct += pred.eq(y.view_as(pred)).sum().item()\n",
        "\n",
        "    test_loss /= len(t_test)\n",
        "    return test_loss, 100. * correct / len(t_test)"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bx9KWVBaaavl"
      },
      "source": [
        "We will train the functions above on task 1 and fine-tune on task 2 to see how additional data affect the performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tvpaBTeDuHQq",
        "outputId": "cba267fe-39ce-4875-8382-5a8a6301f00d"
      },
      "source": [
        "model = FNet().to(device)\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "x_train_1, t_train_1, x_test_1, t_test_1 = task_data[0]\n",
        "x_train_2, t_train_2, x_test_2, t_test_2 = task_data[1]\n",
        "\n",
        "print('Training on Task 1')\n",
        "train(model, device, x_train_1, t_train_1, optimizer, epochs=3)\n",
        "\n",
        "loss, acc = test(model, device, x_test_1, t_test_1)\n",
        "print(f'Testing on Task 1: loss -> {loss}, acc -> {acc}')\n",
        "\n",
        "print('------------')\n",
        "print('Training on Task 2')\n",
        "train(model, device, x_train_2, t_train_2, optimizer, epochs=3)\n",
        "\n",
        "loss, acc = test(model, device, x_test_1, t_test_1)\n",
        "print(f'Testing on Task 1: loss -> {loss}, acc -> {acc}')\n",
        "loss, acc = test(model, device, x_test_2, t_test_2)\n",
        "print(f'Testing on Task 2: loss -> {loss}, acc -> {acc}')"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training on Task 1\n",
            "Testing on Task 1: loss -> 1.707715103424751e-05, acc -> 99.90543735224587\n",
            "------------\n",
            "Training on Task 2\n",
            "Testing on Task 1: loss -> 0.0674293324175174, acc -> 0.0\n",
            "Testing on Task 2: loss -> 0.00029021617477571814, acc -> 97.20861900097943\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h4tEgfAOfKBV"
      },
      "source": [
        "As we can see, the progress we achieved on Task #1 is lost once we fine-tune to Task #2. \n",
        "\n",
        "In CL, we talk about **Catastrophic Forgetting**.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wyN6t_xjcGDr"
      },
      "source": [
        "**Continual Learning via Rehearsal / Replay:**\n",
        "\n",
        "One way to mitigate Catastrophic Forgetting is to keep a portion of the old data to be interleaved with the data from the current task, so that the network does not forget. An ideal scenario is to keep all the old data, however, this is not practical in real applications with memory constraints. Therefore, it is preferrable to keep a limited number of old patterns to be replayed.\n",
        "\n",
        "In the next section we will use the Rehearsal strategy and compare it to the previously seen Naive strategy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQOI4lrwQG9h"
      },
      "source": [
        "# We will use this function to shuffle the union of old data with the new task data.\n",
        "def shuffle_in_unison(dataset, seed, in_place=False):\n",
        "    \"\"\" Shuffle two (or more) list in unison. \"\"\"\n",
        "\n",
        "    np.random.seed(seed)\n",
        "    rng_state = np.random.get_state()\n",
        "    new_dataset = []\n",
        "    for x in dataset:\n",
        "        if in_place:\n",
        "            np.random.shuffle(x)\n",
        "        else:\n",
        "            new_dataset.append(np.random.permutation(x))\n",
        "        np.random.set_state(rng_state)\n",
        "\n",
        "    if not in_place:\n",
        "        return new_dataset"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dqfVgV8oQIdm"
      },
      "source": [
        "# we can use this function to train the model on all tasks for a percentage of \n",
        "# old data to rehearse. 0% means naive with expected catastrophic forgetting\n",
        "def train_singlehead(past_examples_percentage=0, epochs=15):\n",
        "  model = FNet().to(device)\n",
        "  optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "  accs_fine_grid = []\n",
        "  for i in range(tasks_num):\n",
        "    x_train, t_train, _, _ = task_data[i]\n",
        "\n",
        "    # concatenate previous tasks\n",
        "    for j in range(0, i + 1):\n",
        "      past_x_train, past_t_train, _, _ = task_data[j]\n",
        "      example_num = int(past_examples_percentage * len(past_t_train))\n",
        "      x_train = np.concatenate((x_train, past_x_train[:example_num]))\n",
        "      t_train = np.concatenate((t_train, past_t_train[:example_num]))\n",
        "\n",
        "    x_train, t_train = shuffle_in_unison([x_train, t_train], 0)\n",
        "    train(model, device, x_train, t_train, optimizer, epochs)\n",
        "\n",
        "    # test on tasks seen so far\n",
        "    accs_subset = []\n",
        "    for j in range(0, i + 1):\n",
        "      _, _, x_test, t_test = task_data[j]\n",
        "      _, test_acc = test(model, device, x_test, t_test)\n",
        "      accs_subset.append(test_acc)\n",
        "    \n",
        "    if i < (tasks_num - 1):\n",
        "      accs_subset.extend([np.nan] * (4 - i))\n",
        "\n",
        "    accs_fine_grid.append(accs_subset)\n",
        "\n",
        "  return accs_fine_grid\n",
        "\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8UWsLgfpLqQn"
      },
      "source": [
        "accs_naive = train_singlehead() # naive: 0%\n",
        "accs_rehearsal_all = train_singlehead(1) # regural supervised fashion: 100% \n",
        "accs_rehearsal_5 = train_singlehead(0.05) # 5%, about 100 example per task"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 339
        },
        "id": "9Ihe0z7IBTdI",
        "outputId": "cb405de9-7295-4b85-cf72-97a909b060a3"
      },
      "source": [
        "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n",
        "accs_fine_grid = np.array(accs_naive)\n",
        "nan_mask = np.isnan(accs_naive)\n",
        "\n",
        "sns.heatmap(accs_naive, vmin=0, vmax=100, mask=nan_mask, annot=True,fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[0], cbar=False)\n",
        "sns.heatmap(accs_rehearsal_5, vmin=0, vmax=100, mask=nan_mask, annot=True,fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[1], cbar=False)\n",
        "sns.heatmap(accs_rehearsal_all, vmin=0, vmax=100, mask=nan_mask, annot=True,  fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[2], cbar=False)\n",
        "\n",
        "axes[0].set_ylabel('Tested on Task')\n",
        "\n",
        "axes[0].set_xlabel('Naive')\n",
        "axes[1].set_xlabel('Rehearsal 5 %')\n",
        "axes[2].set_xlabel('Rehearsal 100 %')\n",
        "\n",
        "\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_naive, axis=1))\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_rehearsal_all, axis=1))\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_rehearsal_5, axis=1))\n",
        "axes[3].legend(['Naive', 'Rehearsal 100%', 'Rehearsal 5%'])\n",
        "axes[3].set_ylabel('Accumulated Accuracy for Seen Tasks')\n",
        "axes[3].set_xlabel('Task Number')"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 24.0, 'Task Number')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bO8hIenJkXeZ"
      },
      "source": [
        "In the above graph, we saw that accuracy improves by adding 5% of previous data (~50 example per class). Even if forgetting is not completely defeated, it definitely is a step forward from the Naive strategy."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wPH3X0z4XjFf"
      },
      "source": [
        "**Multi-Head setting**\n",
        "\n",
        "In the following section we will move to the multi-head setting and reproduce what we have done with the single-head setting. We will create a `BaseNet` that holds the shared hidden representation to be fine-tuned and a `HeadNet` which holds the separate heads for every task and takes the shared representation as an input. At test time, there will be an oracle that informs us of the task from which each data-point comes from. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uePOLKthknWb"
      },
      "source": [
        "class FBaseNet(nn.Module):\n",
        "  def __init__(self, hsize=512):\n",
        "    super(FBaseNet, self).__init__()\n",
        "    self.l1 = nn.Linear(784, hsize)\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = x.view(x.size(0), -1)\n",
        "    x = F.relu(self.l1(x))\n",
        "    return x\n",
        "\n",
        "\n",
        "class FHeadNet(nn.Module):\n",
        "  def __init__(self, base_net, input_size=512):\n",
        "    super(FHeadNet, self).__init__()\n",
        "\n",
        "    self.base_net = base_net\n",
        "\n",
        "    self.l1 = nn.Linear(input_size, 2)\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.base_net.forward(x)\n",
        "    x = self.l1(x)\n",
        "    return x"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CasFhjYXOQMw"
      },
      "source": [
        "def train_multihead(past_examples_percentage=0, epochs=15):\n",
        "  base = FBaseNet().to(device)\n",
        "  heads = []\n",
        "\n",
        "  accs_fine_grid = []\n",
        "\n",
        "  for i in range(tasks_num):\n",
        "    x_train, t_train, _, _ = task_data_with_overlap[i]\n",
        "    model = FHeadNet(base).to(device)\n",
        "    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "    heads.append(model)\n",
        "\n",
        "    # concatenate previous tasks\n",
        "    for j in range(0, i + 1):\n",
        "      past_x_train, past_t_train, _, _ = task_data_with_overlap[j]\n",
        "      example_num = int(past_examples_percentage * len(past_t_train))\n",
        "      x_train = np.concatenate((x_train, past_x_train[:example_num]))\n",
        "      t_train = np.concatenate((t_train, past_t_train[:example_num]))\n",
        "\n",
        "    x_train, t_train = shuffle_in_unison([x_train, t_train], 0)\n",
        "\n",
        "    train(model, device, x_train, t_train, optimizer, epochs)\n",
        "    # test on tasks seen so far\n",
        "    accs_subset = []\n",
        "    for j in range(0, i + 1):\n",
        "      _, _, x_test, t_test = task_data_with_overlap[j]\n",
        "      _, test_acc = test(heads[j], device, x_test, t_test)\n",
        "      accs_subset.append(test_acc)\n",
        "\n",
        "    if i < (tasks_num - 1):\n",
        "      accs_subset.extend([np.nan] * (4 - i))\n",
        "    \n",
        "    accs_fine_grid.append(accs_subset)\n",
        "\n",
        "  return accs_fine_grid\n"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wgD2x6xIQbyu"
      },
      "source": [
        "accs_naive = train_multihead(epochs=15)\n",
        "accs_rehearsal_all = train_multihead(1, epochs=15)\n",
        "accs_rehearsal_5 = train_multihead(0.05, epochs=15)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 339
        },
        "id": "BhcV7UoNQgqD",
        "outputId": "0d555fe9-1312-4ce5-e7b8-ed264d0db392"
      },
      "source": [
        "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n",
        "accs_fine_grid = np.array(accs_fine_grid)\n",
        "\n",
        "nan_mask = np.isnan(accs_fine_grid)\n",
        "\n",
        "sns.heatmap(accs_naive, vmin=0, vmax=100, mask=nan_mask, annot=True,fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[0], cbar=False)\n",
        "sns.heatmap(accs_rehearsal_5, vmin=0, vmax=100, mask=nan_mask, annot=True,fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[1], cbar=False)\n",
        "sns.heatmap(accs_rehearsal_all, vmin=0, vmax=100, mask=nan_mask, annot=True,  fmt='g',\n",
        "            yticklabels=range(1, 6), xticklabels=range(1, 6), ax=axes[2], cbar=False)\n",
        "\n",
        "axes[0].set_ylabel('Tested on Task')\n",
        "\n",
        "axes[0].set_xlabel('Naive')\n",
        "axes[1].set_xlabel('Rehearsal 5 %')\n",
        "axes[2].set_xlabel('Rehearsal 100 %')\n",
        "\n",
        "\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_naive, axis=1))\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_rehearsal_all, axis=1))\n",
        "axes[3].plot(range(1, 6), np.nanmean(accs_rehearsal_5, axis=1))\n",
        "\n",
        "axes[3].legend(['Naive', 'Rehearsal 100%', 'Rehearsal 5%'])\n",
        "axes[3].set_ylabel('Accumulated Accuracy for Seen Tasks')\n",
        "axes[3].set_xlabel('Task Number')\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 24.0, 'Task Number')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IXnA-mOtnCUi"
      },
      "source": [
        "With the multi-head setting all the strategies maintains a good performance on previous tasks, especially using a simple network. This highlights the unrealistic assumptions behind Multi-Head, which is able to tackle catastrophic forgetting effectively even without any CL strategy. As we already explained, however, multi-head setting is a very unrealistic CL scenario."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tILhVRu19yTd"
      },
      "source": [
        ""
      ],
      "execution_count": 16,
      "outputs": []
    }
  ]
}