representation_drift.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "representation_drift.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.5"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "91355f5855ca45a8872695fbdba9a2fa": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_6ad975f6749d4b04b10a9ecb1c0848a7",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_dcabf61958184083811324fedb0c6dbf",
              "IPY_MODEL_7a518094bc2949c8a921fdfbf06bce43"
            ]
          }
        },
        "6ad975f6749d4b04b10a9ecb1c0848a7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "dcabf61958184083811324fedb0c6dbf": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_05bf4572073b4545852efa984782240d",
            "_dom_classes": [],
            "description": "",
            "_model_name": "FloatProgressModel",
            "bar_style": "info",
            "max": 1,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 1,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_65dde3380ab8488a99c47ae3a9ea74d2"
          }
        },
        "7a518094bc2949c8a921fdfbf06bce43": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_c4205bd98fa44fb49909b8ef85b7013f",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 169009152/? [00:20&lt;00:00, 32759731.99it/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_441baa6398b7409c93a6cf47c9a563c5"
          }
        },
        "05bf4572073b4545852efa984782240d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "initial",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "65dde3380ab8488a99c47ae3a9ea74d2": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "c4205bd98fa44fb49909b8ef85b7013f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "441baa6398b7409c93a6cf47c9a563c5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NzqxHIh4OCdW"
      },
      "source": [
        "# Incremental learning on image classification"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HhXSQELY3-pt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 364
        },
        "outputId": "cc7c0d84-3ffe-4e9d-9a0b-acf80496e64f"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tue Jun 30 07:47:16 2020       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 450.36.06    Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   45C    P0    28W / 250W |      0MiB / 16280MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wBHSznCZxpNB"
      },
      "source": [
        "## Libraries and packages\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4eQ6O12jxMFf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 679
        },
        "outputId": "48f6e3aa-1fa4-43b5-a163-e485fad475b8"
      },
      "source": [
        "!pip3 install 'torch==1.4.0'\n",
        "!pip3 install 'torchvision==0.5.0'\n",
        "!pip3 install 'Pillow-SIMD'\n",
        "!pip3 install 'tqdm'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting torch==1.4.0\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/24/19/4804aea17cd136f1705a5e98a00618cb8f6ccc375ad8bfa437408e09d058/torch-1.4.0-cp36-cp36m-manylinux1_x86_64.whl (753.4MB)\n",
            "\u001b[K     |████████████████████████████████| 753.4MB 20kB/s \n",
            "\u001b[31mERROR: torchvision 0.6.1+cu101 has requirement torch==1.5.1, but you'll have torch 1.4.0 which is incompatible.\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: torch\n",
            "  Found existing installation: torch 1.5.1+cu101\n",
            "    Uninstalling torch-1.5.1+cu101:\n",
            "      Successfully uninstalled torch-1.5.1+cu101\n",
            "Successfully installed torch-1.4.0\n",
            "Collecting torchvision==0.5.0\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/7e/90/6141bf41f5655c78e24f40f710fdd4f8a8aff6c8b7c6f0328240f649bdbe/torchvision-0.5.0-cp36-cp36m-manylinux1_x86_64.whl (4.0MB)\n",
            "\u001b[K     |████████████████████████████████| 4.0MB 6.2MB/s \n",
            "\u001b[?25hRequirement already satisfied: pillow>=4.1.1 in /usr/local/lib/python3.6/dist-packages (from torchvision==0.5.0) (7.0.0)\n",
            "Requirement already satisfied: torch==1.4.0 in /usr/local/lib/python3.6/dist-packages (from torchvision==0.5.0) (1.4.0)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchvision==0.5.0) (1.12.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torchvision==0.5.0) (1.18.5)\n",
            "Installing collected packages: torchvision\n",
            "  Found existing installation: torchvision 0.6.1+cu101\n",
            "    Uninstalling torchvision-0.6.1+cu101:\n",
            "      Successfully uninstalled torchvision-0.6.1+cu101\n",
            "Successfully installed torchvision-0.5.0\n",
            "Collecting Pillow-SIMD\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/a0/6a/30d21c886293cca3755b8e55de34137a5068b77eba1c0644d3632080516b/Pillow-SIMD-7.0.0.post3.tar.gz (630kB)\n",
            "\u001b[K     |████████████████████████████████| 634kB 6.4MB/s \n",
            "\u001b[?25hBuilding wheels for collected packages: Pillow-SIMD\n",
            "  Building wheel for Pillow-SIMD (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for Pillow-SIMD: filename=Pillow_SIMD-7.0.0.post3-cp36-cp36m-linux_x86_64.whl size=1110245 sha256=e42b92bc90ea5df0cb2866e42ef7f237d50db318b24fef5a434d336d5f8cbbbe\n",
            "  Stored in directory: /root/.cache/pip/wheels/d3/ac/4f/4cdf8febba528e5f1b09fc58d5181e1c12ed1e8655dcd583b8\n",
            "Successfully built Pillow-SIMD\n",
            "Installing collected packages: Pillow-SIMD\n",
            "Successfully installed Pillow-SIMD-7.0.0.post3\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "PIL"
                ]
              }
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (4.41.1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "xAYXtIdpx0Yy",
        "colab": {}
      },
      "source": [
        "import os\n",
        "import urllib\n",
        "import logging\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.init as init\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, Subset, DataLoader, ConcatDataset\n",
        "from torch.backends import cudnn\n",
        "\n",
        "import torchvision\n",
        "from torchvision import transforms\n",
        "from torchvision.models import resnet34\n",
        "\n",
        "from PIL import Image\n",
        "from tqdm import tqdm\n",
        "\n",
        "from copy import deepcopy\n",
        "\n",
        "from sklearn.metrics import confusion_matrix"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "09iWc_oCotu2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 401
        },
        "outputId": "6f33faab-7bdb-48ab-b93b-8a698ce984c0"
      },
      "source": [
        "!git clone https://github.com/manuelemacchia/incremental-learning-image-classification.git\n",
        "!mv -v incremental-learning-image-classification/* .\n",
        "!rm -rf incremental-learning-image-classification README.md\n",
        "\n",
        "from data.cifar100 import Cifar100\n",
        "from model.resnet_cifar import resnet32\n",
        "from model.manager import Manager\n",
        "from utils import plot"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'incremental-learning-image-classification'...\n",
            "remote: Enumerating objects: 112, done.\u001b[K\n",
            "remote: Counting objects: 100% (112/112), done.\u001b[K\n",
            "remote: Compressing objects: 100% (102/102), done.\u001b[K\n",
            "remote: Total 1001 (delta 58), reused 28 (delta 9), pack-reused 889\u001b[K\n",
            "Receiving objects: 100% (1001/1001), 4.92 MiB | 9.23 MiB/s, done.\n",
            "Resolving deltas: 100% (559/559), done.\n",
            "renamed 'incremental-learning-image-classification/data' -> './data'\n",
            "renamed 'incremental-learning-image-classification/dist_targets_analisys_notebook.ipynb' -> './dist_targets_analisys_notebook.ipynb'\n",
            "renamed 'incremental-learning-image-classification/icarlSVM.ipynb' -> './icarlSVM.ipynb'\n",
            "renamed 'incremental-learning-image-classification/joint_training.ipynb' -> './joint_training.ipynb'\n",
            "renamed 'incremental-learning-image-classification/losses' -> './losses'\n",
            "renamed 'incremental-learning-image-classification/model' -> './model'\n",
            "renamed 'incremental-learning-image-classification/notebook.ipynb' -> './notebook.ipynb'\n",
            "renamed 'incremental-learning-image-classification/point5_notebook.ipynb' -> './point5_notebook.ipynb'\n",
            "renamed 'incremental-learning-image-classification/README.md' -> './README.md'\n",
            "renamed 'incremental-learning-image-classification/report' -> './report'\n",
            "renamed 'incremental-learning-image-classification/results' -> './results'\n",
            "renamed 'incremental-learning-image-classification/studies-classifier.ipynb' -> './studies-classifier.ipynb'\n",
            "renamed 'incremental-learning-image-classification/tsne notebook.ipynb' -> './tsne notebook.ipynb'\n",
            "renamed 'incremental-learning-image-classification/utils' -> './utils'\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "QPLViftqtC3I",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "4f85e260-7e91-41da-b9fe-7254dead3593"
      },
      "source": [
        "from data.cifar100 import Cifar100\n",
        "from model.resnet_cifar import resnet32\n",
        "from model.manager import Manager\n",
        "from model.icarl import Exemplars\n",
        "# from model.icarl import iCaRL\n",
        "from utils import plot"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "km3w4M1jBsp4",
        "colab_type": "text"
      },
      "source": [
        "## Save and Load Functions\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvBFyKFyBs0D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pickle\n",
        "import time\n",
        "from google.colab import files\n",
        "\n",
        "if not os.path.isdir('./obj'):\n",
        "    !mkdir 'obj'\n",
        "\n",
        "def obj_save(obj, name):\n",
        "    with open('obj/'+ name + '.pkl', 'wb') as f:\n",
        "        pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)\n",
        "    \n",
        "    time.sleep(5)\n",
        "\n",
        "    files.download('obj/'+ name + '.pkl') \n",
        "\n",
        "def obj_load(name):\n",
        "    with open('obj/' + name + '.pkl', 'rb') as f:\n",
        "        return pickle.load(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "j12pgffMR6Qv"
      },
      "source": [
        "## Arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "JwE0x8gkSisn",
        "colab": {}
      },
      "source": [
        "# Directories\n",
        "DATA_DIR = 'data'       # Directory where the dataset will be downloaded\n",
        "\n",
        "# Settings\n",
        "DEVICE = 'cuda'\n",
        "\n",
        "# Dataset\n",
        "\n",
        "RANDOM_STATE = None\n",
        "\n",
        "RANDOM_STATES = [658, 423, 422]      # For reproducibility of results                        \n",
        "                                     # Note: different random states give very different\n",
        "                                     # splits and therefore very different results.\n",
        "\n",
        "NUM_CLASSES = 100       # Total number of classes\n",
        "NUM_BATCHES = 10\n",
        "CLASS_BATCH_SIZE = 10   # Size of batch of classes for incremental learning\n",
        "\n",
        "VAL_SIZE = 0.1          # Proportion of validation set with respect to training set (between 0 and 1)\n",
        "\n",
        "# Training\n",
        "BATCH_SIZE = 64         # Batch size (iCaRL sets this to 128)\n",
        "LR = 2                  # Initial learning rate\n",
        "                       \n",
        "MOMENTUM = 0.9          # Momentum for stochastic gradient descent (SGD)\n",
        "WEIGHT_DECAY = 1e-5     # Weight decay from iCaRL\n",
        "\n",
        "NUM_RUNS = 3            # Number of runs of every method\n",
        "                        # Note: this should be at least 3 to have a fair benchmark\n",
        "\n",
        "NUM_EPOCHS = 70         # Total number of training epochs\n",
        "MILESTONES = [49, 63]   # Step down policy from iCaRL (MultiStepLR)\n",
        "                        # Decrease the learning rate by gamma at each milestone\n",
        "GAMMA = 0.2             # Gamma factor from iCaRL"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rF0ypxGognNR",
        "colab_type": "text"
      },
      "source": [
        "## Data preparation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4mf04UjEgmPG",
        "colab": {}
      },
      "source": [
        "# Transformations for Learning Without Forgetting\n",
        "train_transform = transforms.Compose([transforms.RandomCrop(32, padding=4),\n",
        "                                      transforms.RandomHorizontalFlip(),\n",
        "                                      transforms.ToTensor(), # Turn PIL Image to torch.Tensor\n",
        "                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "])\n",
        "\n",
        "test_transform = transforms.Compose([transforms.ToTensor(),\n",
        "                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))                                    \n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Y9Oq44dxgmPN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84,
          "referenced_widgets": [
            "91355f5855ca45a8872695fbdba9a2fa",
            "6ad975f6749d4b04b10a9ecb1c0848a7",
            "dcabf61958184083811324fedb0c6dbf",
            "7a518094bc2949c8a921fdfbf06bce43",
            "05bf4572073b4545852efa984782240d",
            "65dde3380ab8488a99c47ae3a9ea74d2",
            "c4205bd98fa44fb49909b8ef85b7013f",
            "441baa6398b7409c93a6cf47c9a563c5"
          ]
        },
        "outputId": "11a961e6-c47f-4db3-b4a5-9b0abcce6aa6"
      },
      "source": [
        "train_subsets = [[] for i in range(NUM_RUNS)]\n",
        "val_subsets = [[] for i in range(NUM_RUNS)]\n",
        "test_subsets = [[] for i in range(NUM_RUNS)]\n",
        "\n",
        "for run_i in range(NUM_RUNS):\n",
        "    for split_i in range(CLASS_BATCH_SIZE):\n",
        "        if run_i+split_i == 0: # Download dataset only at first instantiation\n",
        "            download = True\n",
        "        else:\n",
        "            download = False\n",
        "\n",
        "        # Create CIFAR100 dataset\n",
        "        train_dataset = Cifar100(DATA_DIR, train=True, download=download, random_state=RANDOM_STATES[run_i], transform=train_transform)\n",
        "        test_dataset = Cifar100(DATA_DIR, train=False, download=False, random_state=RANDOM_STATES[run_i], transform=test_transform)\n",
        "    \n",
        "        # Subspace of CIFAR100 of 10 classes\n",
        "        train_dataset.set_classes_batch(train_dataset.batch_splits[split_i]) \n",
        "        test_dataset.set_classes_batch([test_dataset.batch_splits[i] for i in range(0, split_i+1)])\n",
        "\n",
        "        # Define train and validation indices\n",
        "        train_indices, val_indices = train_dataset.train_val_split(VAL_SIZE, RANDOM_STATES[run_i])\n",
        "\n",
        "        # Define subsets\n",
        "        train_subsets[run_i].append(Subset(train_dataset, train_indices))\n",
        "        val_subsets[run_i].append(Subset(train_dataset, val_indices))\n",
        "        test_subsets[run_i].append(test_dataset)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to data/cifar-100-python.tar.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "91355f5855ca45a8872695fbdba9a2fa",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Extracting data/cifar-100-python.tar.gz to data\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d5aJIio18xnO",
        "colab_type": "text"
      },
      "source": [
        "## iCaRL - Features Drift"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "blz4YxK78ha0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, DataLoader, ConcatDataset\n",
        "from torch.backends import cudnn\n",
        "\n",
        "from math import floor\n",
        "from copy import deepcopy\n",
        "import random\n",
        "\n",
        "sigmoid = nn.Sigmoid() # Sigmoid function\n",
        "NET_PATH = 'net_zero'\n",
        "\n",
        "class Exemplars(torch.utils.data.Dataset):\n",
        "    def __init__(self, exemplars, transform=None):\n",
        "        # exemplars = [\n",
        "        #     [ex0_class0, ex1_class0, ex2_class0, ...],\n",
        "        #     [ex0_class1, ex1_class1, ex2_class1, ...],\n",
        "        #     ...\n",
        "        #     [ex0_classN, ex1_classN, ex2_classN, ...]\n",
        "        # ]\n",
        "\n",
        "        self.dataset = []\n",
        "        self.targets = []\n",
        "\n",
        "        for y, exemplar_y in enumerate(exemplars):\n",
        "            self.dataset.extend(exemplar_y)\n",
        "            self.targets.extend([y] * len(exemplar_y))\n",
        "\n",
        "        self.transform = transform\n",
        "    \n",
        "    def __getitem__(self, index):\n",
        "        image = self.dataset[index]\n",
        "        target = self.targets[index]\n",
        "\n",
        "        if self.transform is not None:\n",
        "            image = self.transform(image)\n",
        "\n",
        "        return image, target\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.targets)\n",
        "\n",
        "class iCaRL:\n",
        "    \"\"\"Implement iCaRL, a strategy for simultaneously learning classifiers and a\n",
        "    feature representation in the class-incremental setting.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, device, net, lr, momentum, weight_decay, milestones, gamma, num_epochs, batch_size, train_transform, test_transform, alpha):\n",
        "        self.device = device\n",
        "        self.net = net\n",
        "\n",
        "        # Set hyper-parameters\n",
        "        self.LR = lr\n",
        "        self.MOMENTUM = momentum\n",
        "        self.WEIGHT_DECAY = weight_decay\n",
        "        self.MILESTONES = milestones\n",
        "        self.GAMMA = gamma\n",
        "        self.NUM_EPOCHS = num_epochs\n",
        "        self.BATCH_SIZE = batch_size\n",
        "        \n",
        "        # Set transformations\n",
        "        self.train_transform = train_transform\n",
        "        self.test_transform = test_transform\n",
        "\n",
        "        # List of exemplar sets. Each set contains memory_size/num_classes exemplars\n",
        "        # with num_classes the number of classes seen until now by the network.\n",
        "        self.exemplars = []\n",
        "\n",
        "        # Initialize the copy of the old network, used to compute outputs of the\n",
        "        # previous network for the distillation loss, to None. This is useful to\n",
        "        # correctly apply the first function when training the network for the\n",
        "        # first time.\n",
        "        self.old_net = None\n",
        "\n",
        "        # For drift analisys and mitigation\n",
        "        self.prototypes = dict() # prototypes representation to study features shift from one task to the other\n",
        "        self.rep_distance = dict() # dictionary with drift value for each label. Drift value is MSE\n",
        "        self.features_criterion = nn.CosineEmbeddingLoss() # loss for drift prevention\n",
        "        self.alpha = alpha # features loss coefficient\n",
        "\n",
        "\n",
        "        # Maximum number of exemplars\n",
        "        self.memory_size = 2000\n",
        "    \n",
        "        # Loss function\n",
        "        self.criterion = nn.BCEWithLogitsLoss()\n",
        "\n",
        "        # If True, test on the best model found (e.g., minimize loss). If False,\n",
        "        # test on the last model build (of the last epoch).\n",
        "        self.VALIDATE = False\n",
        "\n",
        "    def prototype_distance(self):\n",
        "      # measure prototype distance between last 2 learned reprsentations\n",
        "\n",
        "      # criterion = nn.MSELoss(reduction = 'mean')\n",
        "      criterion = nn.MSELoss(reduction = 'none')\n",
        "\n",
        "      num_common_classes = self.output_neurons_count()-10\n",
        "\n",
        "      current_rep = dict()\n",
        "\n",
        "      for label in range(num_common_classes): # consider only class known by both tasks\n",
        "\n",
        "        # for each label, it returns the mean distance between old prototypes and new\n",
        "        # the result is stored in self.rep_distance\n",
        "        \n",
        "        old = self.prototypes[0][label, :]\n",
        "        new = self.prototypes[self.split][label, :]\n",
        "        \n",
        "        current_rep[label] = torch.mean(criterion(old*coef_old,new*coef_old))\n",
        "        \n",
        "      self.rep_distance[self.split] = current_rep\n",
        "        \n",
        "\n",
        "    def classify(self, batch, train_dataset=None):\n",
        "        \"\"\"Mean-of-exemplars classifier used to classify images into the set of\n",
        "        classes observed so far.\n",
        "\n",
        "        Args:\n",
        "            batch (torch.tensor): batch to classify\n",
        "        Returns:\n",
        "            label (int): class label assigned to the image\n",
        "        \"\"\"\n",
        "\n",
        "        batch_features = self.extract_features(batch) # (batch size, 64)\n",
        "        for i in range(batch_features.size(0)):\n",
        "            batch_features[i] = batch_features[i]/batch_features[i].norm() # Normalize sample feature representation\n",
        "        batch_features = batch_features.to(self.device)\n",
        "\n",
        "        if self.cached_means is None:\n",
        "            print(\"Computing mean of exemplars... \", end=\"\")\n",
        "\n",
        "            self.cached_means = []\n",
        "\n",
        "            # Number of known classes\n",
        "            num_classes = len(self.exemplars)\n",
        "\n",
        "            # Compute the means of classes with all the data available,\n",
        "            # including training data which contains samples belonging to\n",
        "            # the latest 10 classes. This will remove noise from the mean\n",
        "            # estimate, improving the results.\n",
        "            if train_dataset is not None:\n",
        "                train_features_list = [[] for _ in range(10)]\n",
        "\n",
        "                for train_sample, label in train_dataset:\n",
        "                    features = self.extract_features(train_sample, batch=False, transform=self.test_transform)\n",
        "                    features = features/features.norm()\n",
        "                    train_features_list[label % 10].append(features)\n",
        "\n",
        "            # Compute means of exemplars for all known classes\n",
        "            for y in range(num_classes):\n",
        "                if (train_dataset is not None) and (y in range(num_classes-10, num_classes)):\n",
        "                    features_list = train_features_list[y % 10]\n",
        "                else:\n",
        "                    features_list = []\n",
        "\n",
        "                for exemplar in self.exemplars[y]:\n",
        "                    features = self.extract_features(exemplar, batch=False, transform=self.test_transform)\n",
        "                    features = features/features.norm() # Normalize the feature representation of the exemplar\n",
        "                    features_list.append(features)\n",
        "                \n",
        "                features_list = torch.stack(features_list)\n",
        "                class_means = features_list.mean(dim=0)\n",
        "                class_means = class_means/class_means.norm() # Normalize the class means\n",
        "\n",
        "                self.cached_means.append(class_means)\n",
        "            \n",
        "            self.cached_means = torch.stack(self.cached_means).to(self.device)\n",
        "            print(\"done\")\n",
        "\n",
        "            self.prototypes[self.split] = deepcopy(self.cached_means)\n",
        "\n",
        "            if self.split in [1, 9]: \n",
        "              self.prototype_distance()\n",
        "\n",
        "        preds = []\n",
        "        for i in range(batch_features.size(0)):\n",
        "            f_arg = torch.norm(batch_features[i] - self.cached_means, dim=1)\n",
        "            preds.append(torch.argmin(f_arg))\n",
        "        \n",
        "        return torch.stack(preds)\n",
        "    \n",
        "    def extract_features(self, sample, batch=True, transform=None):\n",
        "        \"\"\"Extract features from single sample or from batch.\n",
        "        \n",
        "        Args:\n",
        "            sample (PIL image or torch.tensor): sample(s) from which to\n",
        "                extract features\n",
        "            batch (bool): if True, sample is a torch.tensor containing a batch\n",
        "                of images with dimensions (batch_size, 3, 32, 32)\n",
        "            transform: transformations to apply to the PIL image before\n",
        "                processing\n",
        "        Returns:\n",
        "            features: torch.tensor, 1-D of dimension 64 for single samples or\n",
        "                2-D of dimension (batch_size, 64) for batch\n",
        "        \"\"\"\n",
        "\n",
        "        assert not (batch is False and transform is None), \"if a PIL image is passed to extract_features, a transform must be defined\"\n",
        "\n",
        "        self.net.train(False)\n",
        "        if self.best_net is not None: self.best_net.train(False)\n",
        "        if self.old_net is not None: self.old_net.train(False)\n",
        "\n",
        "        if batch is False: # Treat sample as single PIL image\n",
        "            sample = transform(sample)\n",
        "            sample = sample.unsqueeze(0) # https://stackoverflow.com/a/59566009/6486336\n",
        "\n",
        "        sample = sample.to(self.device)\n",
        "\n",
        "        if self.VALIDATE:\n",
        "            features = self.best_net.features(sample)\n",
        "        else:\n",
        "            features = self.net.features(sample)\n",
        "\n",
        "        if batch is False:\n",
        "            features = features[0]\n",
        "\n",
        "        return features\n",
        "\n",
        "    def incremental_train(self, split, train_dataset, val_dataset):\n",
        "        \"\"\"Adjust internal knowledge based on the additional information\n",
        "        available in the new observations.\n",
        "\n",
        "        Args:\n",
        "            split (int): current split number, counting from zero\n",
        "            train_dataset: dataset for training the model\n",
        "            val_dataset: dataset for validating the model\n",
        "        Returns:\n",
        "            train_logs: tuple of four metrics (train_loss, train_accuracy,\n",
        "            val_loss, val_accuracy) obtained during network training\n",
        "        \"\"\"\n",
        "\n",
        "        if split is not 0:\n",
        "            # Increment the number of output nodes for the new network by 10\n",
        "            self.increment_classes(10)\n",
        "\n",
        "        self.split = split\n",
        "\n",
        "        # Improve network parameters upon receiving new classes. Effectively\n",
        "        # train a new network starting from the current network parameters.\n",
        "        train_logs = self.update_representation(train_dataset, val_dataset)\n",
        "\n",
        "        # Compute the number of exemplars per class\n",
        "        num_classes = self.output_neurons_count()\n",
        "        m = floor(self.memory_size / num_classes)\n",
        "\n",
        "        print(f\"Target number of exemplars per class: {m}\")\n",
        "        print(f\"Target total number of exemplars: {m*num_classes}\")\n",
        "\n",
        "        # Reduce pre-existing exemplar sets in order to fit new exemplars\n",
        "        for y in range(len(self.exemplars)):\n",
        "            self.exemplars[y] = self.reduce_exemplar_set(self.exemplars[y], m)\n",
        "\n",
        "        # Construct exemplar set for new classes\n",
        "        new_exemplars = self.construct_exemplar_set_rand(train_dataset, m)\n",
        "        self.exemplars.extend(new_exemplars)\n",
        "\n",
        "        return train_logs\n",
        "\n",
        "    def update_representation(self, train_dataset, val_dataset):\n",
        "        \"\"\"Update the parameters of the network.\n",
        "\n",
        "        Args:\n",
        "            train_dataset: dataset for training the model\n",
        "            val_dataset: dataset for validating the model\n",
        "        Returns:\n",
        "            train_logs: tuple of four metrics (train_loss, train_accuracy,\n",
        "            val_loss, val_accuracy) obtained during network training\n",
        "        \"\"\"\n",
        "\n",
        "        # Combine the new training data with existing exemplars.\n",
        "        print(f\"Length of exemplars set: {sum([len(self.exemplars[y]) for y in range(len(self.exemplars))])}\")\n",
        "        exemplars_dataset = Exemplars(self.exemplars, self.train_transform)\n",
        "        train_dataset_with_exemplars = ConcatDataset([exemplars_dataset, train_dataset])\n",
        "\n",
        "        # Train the network on combined dataset\n",
        "        train_logs = self.train(train_dataset_with_exemplars, val_dataset) # @todo: include exemplars in validation set?\n",
        "\n",
        "        # Keep a copy of the current network in order to compute its outputs for\n",
        "        # the distillation loss while the new network is being trained.\n",
        "        self.old_net = deepcopy(self.net)\n",
        "\n",
        "        if self.split == 0:\n",
        "          torch.save(net.state_dict(), NET_PATH)\n",
        "          print(\"### Current net saved\")\n",
        "\n",
        "        return train_logs\n",
        "\n",
        "    def construct_exemplar_set_rand(self, dataset, m):\n",
        "        \"\"\"Randomly sample m elements from a dataset without replacement.\n",
        "\n",
        "        Args:\n",
        "            dataset: dataset containing a split (samples from 10 classes) from\n",
        "                which to take exemplars\n",
        "            m (int): target number of exemplars per class\n",
        "        Returns:\n",
        "            exemplars: list of samples extracted from the dataset\n",
        "        \"\"\"\n",
        "\n",
        "        dataset.dataset.disable_transform()\n",
        "\n",
        "        samples = [[] for _ in range(10)]\n",
        "        for image, label in dataset:\n",
        "            label = label % 10 # Map labels to 0-9 range\n",
        "            samples[label].append(image)\n",
        "\n",
        "        dataset.dataset.enable_transform()\n",
        "\n",
        "        exemplars = [[] for _ in range(10)]\n",
        "\n",
        "        for y in range(10):\n",
        "            print(f\"Randomly extracting exemplars from class {y} of current split... \", end=\"\")\n",
        "\n",
        "            # Randomly choose m samples from samples[y] without replacement\n",
        "            exemplars[y] = random.sample(samples[y], m)\n",
        "\n",
        "            print(f\"Extracted {len(exemplars[y])} exemplars.\")\n",
        "\n",
        "        return exemplars\n",
        "\n",
        "    def reduce_exemplar_set(self, exemplar_set, m):\n",
        "        \"\"\"Procedure for removing exemplars from a given set.\n",
        "\n",
        "        Args:\n",
        "            exemplar_set (set): set of exemplars belonging to a certain class\n",
        "            m (int): target number of exemplars\n",
        "        Returns:\n",
        "            exemplar_set: reduced exemplar set\n",
        "        \"\"\"\n",
        "\n",
        "        return exemplar_set[:m]\n",
        "\n",
        "    def train(self, train_dataset, val_dataset):\n",
        "        \"\"\"Train the network for a specified number of epochs, and save\n",
        "        the best performing model on the validation set.\n",
        "        \n",
        "        Args:\n",
        "            train_dataset: dataset for training the model\n",
        "            val_dataset: dataset for validating the model\n",
        "        Returns: train_logs: tuple of four metrics (train_loss, train_accuracy,\n",
        "            val_loss, val_accuracy) obtained during network training. If\n",
        "            validation is enabled, return scores of the best epoch, otherwise\n",
        "            return scores of the last epoch.\n",
        "        \"\"\"\n",
        "\n",
        "        # Define the optimization algorithm\n",
        "        parameters_to_optimize = self.net.parameters()\n",
        "        self.optimizer = optim.SGD(parameters_to_optimize, \n",
        "                                   lr=self.LR,\n",
        "                                   momentum=self.MOMENTUM,\n",
        "                                   weight_decay=self.WEIGHT_DECAY)\n",
        "        \n",
        "        # Define the learning rate decaying policy\n",
        "        self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer,\n",
        "                                                        milestones=self.MILESTONES,\n",
        "                                                        gamma=self.GAMMA)\n",
        "\n",
        "        # Create DataLoaders for training and validation\n",
        "        self.train_dataloader = DataLoader(train_dataset, batch_size=self.BATCH_SIZE, shuffle=True, num_workers=4, drop_last=True)\n",
        "        self.val_dataloader = DataLoader(val_dataset, batch_size=self.BATCH_SIZE, shuffle=True, num_workers=4, drop_last=True)\n",
        "\n",
        "        # Send networks to chosen device\n",
        "        self.net = self.net.to(self.device)\n",
        "        if self.old_net is not None: self.old_net = self.old_net.to(self.device)\n",
        "\n",
        "        cudnn.benchmark  # Calling this optimizes runtime\n",
        "\n",
        "        self.best_val_loss = float('inf')\n",
        "        self.best_val_accuracy = 0\n",
        "        self.best_train_loss = float('inf')\n",
        "        self.best_train_accuracy = 0\n",
        "        \n",
        "        self.best_net = None\n",
        "        self.best_epoch = -1\n",
        "\n",
        "        for epoch in range(self.NUM_EPOCHS):\n",
        "            # Run an epoch (start counting form 1)\n",
        "            train_loss, train_accuracy = self.do_epoch(epoch+1)\n",
        "        \n",
        "            # Validate after each epoch \n",
        "            val_loss, val_accuracy = self.validate()    \n",
        "\n",
        "            # Validation criterion: best net is the one that minimizes the loss\n",
        "            # on the validation set.\n",
        "            if self.VALIDATE and val_loss < self.best_val_loss:\n",
        "                self.best_val_loss = val_loss\n",
        "                self.best_val_accuracy = val_accuracy\n",
        "                self.best_train_loss = train_loss\n",
        "                self.best_train_accuracy = train_accuracy\n",
        "\n",
        "                self.best_net = deepcopy(self.net)\n",
        "                self.best_epoch = epoch\n",
        "                print(\"Best model updated\")\n",
        "\n",
        "        if self.VALIDATE:\n",
        "            val_loss = self.best_val_loss\n",
        "            val_accuracy = self.best_val_accuracy\n",
        "            train_loss = self.best_train_loss\n",
        "            train_accuracy = self.best_train_accuracy\n",
        "\n",
        "            print(f\"Best model found at epoch {self.best_epoch+1}\")\n",
        "\n",
        "        return train_loss, train_accuracy, val_loss, val_accuracy\n",
        "    \n",
        "    def do_epoch(self, current_epoch):\n",
        "        \"\"\"Trains model for one epoch.\n",
        "        \n",
        "        Args:\n",
        "            current_epoch (int): current epoch number (begins from 1)\n",
        "        Returns:\n",
        "            train_loss: average training loss over all batches of the\n",
        "                current epoch.\n",
        "            train_accuracy: training accuracy of the current epoch over\n",
        "                all samples.\n",
        "        \"\"\"\n",
        "\n",
        "        # Set the current network in training mode\n",
        "        self.net.train()\n",
        "        if self.old_net is not None: self.old_net.train(False)\n",
        "        if self.best_net is not None: self.best_net.train(False)\n",
        "\n",
        "        running_train_loss = 0\n",
        "        running_corrects = 0\n",
        "        total = 0\n",
        "        batch_idx = 0\n",
        "\n",
        "        print(f\"Epoch: {current_epoch}, LR: {self.scheduler.get_last_lr()}\")\n",
        "\n",
        "        for images, labels in self.train_dataloader:\n",
        "            loss, corrects = self.do_batch(images, labels)\n",
        "\n",
        "            running_train_loss += loss.item()\n",
        "            running_corrects += corrects\n",
        "            total += labels.size(0)\n",
        "            batch_idx += 1\n",
        "\n",
        "        self.scheduler.step()\n",
        "\n",
        "        # Calculate average scores\n",
        "        train_loss = running_train_loss / batch_idx # Average over all batches\n",
        "        train_accuracy = running_corrects / float(total) # Average over all samples\n",
        "\n",
        "        print(f\"Train loss: {train_loss}, Train accuracy: {train_accuracy}\")\n",
        "\n",
        "        return train_loss, train_accuracy\n",
        "\n",
        "    def do_batch(self, batch, labels):\n",
        "        \"\"\"Train network for a batch. Loss is applied here.\n",
        "\n",
        "        Args:\n",
        "            batch: batch of data used for training the network\n",
        "            labels: targets of the batch\n",
        "        Returns:\n",
        "            loss: output of the criterion applied\n",
        "            running_corrects: number of correctly classified elements\n",
        "        \"\"\"\n",
        "        batch = batch.to(self.device)\n",
        "        labels = labels.to(self.device)\n",
        "\n",
        "        # Zero-ing the gradients\n",
        "        self.optimizer.zero_grad()\n",
        "        \n",
        "        # One-hot encoding of labels of the new training data (new classes)\n",
        "        # Size: batch size (rows) by number of classes seen until now (columns)\n",
        "        #\n",
        "        # e.g., suppose we have four images in a batch, and each incremental\n",
        "        #   step adds three new classes. At the second step, the one-hot\n",
        "        #   encoding may return the following tensor:\n",
        "        #\n",
        "        #       tensor([[0., 0., 0., 1., 0., 0.],   # image 0 (label 3)\n",
        "        #               [0., 0., 0., 0., 1., 0.],   # image 1 (label 4)\n",
        "        #               [0., 0., 0., 0., 0., 1.],   # image 2 (label 5)\n",
        "        #               [0., 0., 0., 0., 1., 0.]])  # image 3 (label 4)\n",
        "        #\n",
        "        #   The first three elements of each vector will always be 0, as the\n",
        "        #   new training batch does not contain images belonging to classes\n",
        "        #   already seen in previous steps.\n",
        "        #\n",
        "        #   The last three elements of each vector will contain the actual\n",
        "        #   information about the class of each image (one-hot encoding of the\n",
        "        #   label). Therefore, we slice the tensor and remove the columns \n",
        "        #   related to old classes (all zeros).\n",
        "        num_classes = self.output_neurons_count() # Number of classes seen until now, including new classes\n",
        "        one_hot_labels = self.to_onehot(labels)[:, num_classes-10:num_classes]\n",
        "\n",
        "        if self.old_net is None:\n",
        "            # Network is training for the first time, so we only apply the\n",
        "            # classification loss.\n",
        "            targets = one_hot_labels\n",
        "\n",
        "            # Forward pass\n",
        "            outputs = self.net(batch)\n",
        "            loss = self.criterion(outputs, targets)\n",
        "\n",
        "        else:\n",
        "            # Old net forward pass. We compute the outputs of the old network\n",
        "            # and apply a sigmoid function. These are used in the distillation\n",
        "            # loss. We discard the output of the new neurons, as they are not\n",
        "            # considered in the distillation loss.\n",
        "            old_net_outputs = sigmoid(self.old_net(batch))[:, :num_classes-10]\n",
        "\n",
        "            # Concatenate the outputs of the old network and the one-hot encoded\n",
        "            # labels along dimension 1 (columns).\n",
        "            # \n",
        "            # Each row refers to an image in the training set, and contains:\n",
        "            # - the output of the old network for that image, used by the\n",
        "            #   distillation loss\n",
        "            # - the one-hot label of the image, used by the classification loss\n",
        "            targets = torch.cat((old_net_outputs, one_hot_labels), dim=1)\n",
        "\n",
        "            # Introduce loss contribute to mitigate features drift from old task  \n",
        "            #representation to new one\n",
        "            # As target we use the prototypes saved for each class  on previous task\n",
        "            new_representation = self.extract_features(batch) # [batch_size, 64]\n",
        "            # for i in range(new_representation.size(0)):\n",
        "            #   new_representation[i] = new_representation[i]/new_representation[i].norm()\n",
        "            mask = [] # mask for the features representation\n",
        "            label_mask = [] # mask for the correspndent labels\n",
        "            labels_index = []\n",
        "\n",
        "            # initialize features loss\n",
        "            features_loss = 0\n",
        "\n",
        "            # for loop to select only old classes labels\n",
        "            # since this is the implementation of a distillation loss\n",
        "            for label in labels.to('cpu').numpy():\n",
        "              \n",
        "              if label >= num_classes-10:\n",
        "                mask.append(torch.tensor([False]))\n",
        "                label_mask.append(torch.tensor(False))\n",
        "              else:\n",
        "                mask.append(torch.tensor([True]))\n",
        "                label_mask.append(torch.tensor(True))\n",
        "                labels_index.append(torch.tensor(label))\n",
        "\n",
        "            \n",
        "            tensor_labels_index = torch.stack(labels_index).to(self.device)\n",
        "            selected_labels = torch.masked_select(labels, torch.stack(label_mask).to(self.device)) # apply mask\n",
        "            selected_new_rep = torch.stack([torch.masked_select(new_representation,\n",
        "                                                    torch.stack(mask).to(self.device))[i*64 : 64*(i+1)] for i in range(selected_labels.size(0))]) # apply mask\n",
        "\n",
        "            # Normalize the features \n",
        "            for i in range(selected_new_rep.size(0)):\n",
        "              \n",
        "              selected_new_rep[i] = selected_new_rep[i]/selected_new_rep[i].norm().detach()\n",
        "              \n",
        "            selected_new_rep = selected_new_rep.cuda()\n",
        "            \n",
        "            # filter prototypes by labels selected\n",
        "            features_targets = torch.index_select(self.prototypes[self.split-1], dim = 0, index = tensor_labels_index)\n",
        "            \n",
        "            features_loss = self.features_criterion(selected_new_rep, features_targets, torch.ones(selected_new_rep.size(0)).cuda())\n",
        "\n",
        "\n",
        "            # Forward pass\n",
        "            outputs = self.net(batch)\n",
        "            loss = self.criterion(outputs, targets) + features_loss\n",
        "\n",
        "      \n",
        "        # Get predictions\n",
        "        _, preds = torch.max(outputs.data, 1)\n",
        "\n",
        "        # Accuracy over NEW IMAGES, not over all images\n",
        "        running_corrects = torch.sum(preds == labels.data).data.item() \n",
        "\n",
        "        torch.autograd.set_detect_anomaly(True)\n",
        "\n",
        "        # Backward pass: computes gradients\n",
        "        loss.backward()\n",
        "\n",
        "        self.optimizer.step()\n",
        "\n",
        "        return loss, running_corrects\n",
        "\n",
        "    def validate(self):\n",
        "        \"\"\"Validate the model.\n",
        "        \n",
        "        Returns:\n",
        "            val_loss: average loss function computed on the network outputs\n",
        "                of the validation set (val_dataloader).\n",
        "            val_accuracy: accuracy computed on the validation set.\n",
        "        \"\"\"\n",
        "\n",
        "        self.net.train(False)\n",
        "        if self.old_net is not None: self.old_net.train(False)\n",
        "        if self.best_net is not None: self.best_net.train(False)\n",
        "\n",
        "        running_val_loss = 0\n",
        "        running_corrects = 0\n",
        "        total = 0\n",
        "        batch_idx = 0\n",
        "\n",
        "        for images, labels in self.val_dataloader:\n",
        "            images = images.to(self.device)\n",
        "            labels = labels.to(self.device)\n",
        "            total += labels.size(0)\n",
        "\n",
        "            # One hot encoding of new task labels \n",
        "            one_hot_labels = self.to_onehot(labels)\n",
        "\n",
        "            # New net forward pass\n",
        "            outputs = self.net(images)  \n",
        "            loss = self.criterion(outputs, one_hot_labels) # BCE Loss with sigmoids over outputs\n",
        "\n",
        "            running_val_loss += loss.item()\n",
        "\n",
        "            # Get predictions\n",
        "            _, preds = torch.max(outputs.data, 1)\n",
        "\n",
        "            # Update the number of correctly classified validation samples\n",
        "            running_corrects += torch.sum(preds == labels.data).data.item()\n",
        "\n",
        "            batch_idx += 1\n",
        "\n",
        "        # Calculate scores\n",
        "        val_loss = running_val_loss / batch_idx\n",
        "        val_accuracy = running_corrects / float(total)\n",
        "\n",
        "        print(f\"Validation loss: {val_loss}, Validation accuracy: {val_accuracy}\")\n",
        "\n",
        "        return val_loss, val_accuracy\n",
        "\n",
        "    def test(self, test_dataset, train_dataset=None):\n",
        "        \"\"\"Test the model.\n",
        "\n",
        "        Args:\n",
        "            test_dataset: dataset on which to test the network\n",
        "            train_dataset: training set used to train the last split, if\n",
        "                available\n",
        "        Returns:\n",
        "            accuracy (float): accuracy of the model on the test set\n",
        "        \"\"\"\n",
        "\n",
        "        self.net.train(False)\n",
        "        if self.best_net is not None: self.best_net.train(False)  # Set Network to evaluation mode\n",
        "        if self.old_net is not None: self.old_net.train(False)\n",
        "\n",
        "        self.test_dataloader = DataLoader(test_dataset, batch_size=self.BATCH_SIZE, shuffle=True, num_workers=4)\n",
        "\n",
        "        running_corrects = 0\n",
        "        total = 0\n",
        "\n",
        "        # To store all predictions\n",
        "        all_preds = torch.tensor([])\n",
        "        all_preds = all_preds.type(torch.LongTensor)\n",
        "        all_targets = torch.tensor([])\n",
        "        all_targets = all_targets.type(torch.LongTensor)\n",
        "\n",
        "        # Clear mean of exemplars cache\n",
        "        self.cached_means = None\n",
        "        \n",
        "        # Disable transformations for train_dataset, if available, as we will\n",
        "        # need original PIL images from which to extract features.\n",
        "        if train_dataset is not None: train_dataset.dataset.disable_transform()\n",
        "\n",
        "        for images, labels in self.test_dataloader:\n",
        "            images = images.to(self.device)\n",
        "            labels = labels.to(self.device)\n",
        "\n",
        "            total += labels.size(0)\n",
        "            \n",
        "            with torch.no_grad():\n",
        "                preds = self.classify(images, train_dataset)\n",
        "\n",
        "            running_corrects += torch.sum(preds == labels.data).data.item()\n",
        "\n",
        "            all_targets = torch.cat(\n",
        "                (all_targets.to(self.device), labels.to(self.device)), dim=0\n",
        "            )\n",
        "\n",
        "            all_preds = torch.cat(\n",
        "                (all_preds.to(self.device), preds.to(self.device)), dim=0\n",
        "            )\n",
        "\n",
        "        if train_dataset is not None: train_dataset.dataset.enable_transform()\n",
        "\n",
        "        # Calculate accuracy\n",
        "        accuracy = running_corrects / float(total)  \n",
        "\n",
        "        print(f\"Test accuracy (iCaRL): {accuracy} \", end=\"\")\n",
        "\n",
        "        if train_dataset is None:\n",
        "            print(\"(only exemplars)\")\n",
        "        else:\n",
        "            print(\"(exemplars and training data)\")\n",
        "\n",
        "        return accuracy, all_targets, all_preds\n",
        "\n",
        "    def test_without_classifier(self, test_dataset):\n",
        "        \"\"\"Test the model without classifier, using the outputs of the\n",
        "        network instead.\n",
        "\n",
        "        Args:\n",
        "            test_dataset: dataset on which to test the network\n",
        "        Returns:\n",
        "            accuracy (float): accuracy of the model on the test set\n",
        "        \"\"\"\n",
        "\n",
        "        self.net.train(False)\n",
        "        if self.best_net is not None: self.best_net.train(False) # Set Network to evaluation mode\n",
        "        if self.old_net is not None: self.old_net.train(False)\n",
        "\n",
        "        self.test_dataloader = DataLoader(test_dataset, batch_size=self.BATCH_SIZE, shuffle=True, num_workers=4)\n",
        "\n",
        "        running_corrects = 0\n",
        "        total = 0\n",
        "\n",
        "        all_preds = torch.tensor([]) # to store all predictions\n",
        "        all_preds = all_preds.type(torch.LongTensor)\n",
        "        all_targets = torch.tensor([])\n",
        "        all_targets = all_targets.type(torch.LongTensor)\n",
        "        \n",
        "        for images, labels in self.test_dataloader:\n",
        "            images = images.to(self.device)\n",
        "            labels = labels.to(self.device)\n",
        "            total += labels.size(0)\n",
        "\n",
        "            # Forward Pass\n",
        "            with torch.no_grad():\n",
        "                if self.VALIDATE:\n",
        "                    outputs = self.best_net(images)\n",
        "                else:\n",
        "                    outputs = self.net(images)\n",
        "\n",
        "            # Get predictions\n",
        "            _, preds = torch.max(outputs.data, 1)\n",
        "\n",
        "            # Update Corrects\n",
        "            running_corrects += torch.sum(preds == labels.data).data.item()\n",
        "\n",
        "            all_targets = torch.cat(\n",
        "                (all_targets.to(self.device), labels.to(self.device)), dim=0\n",
        "            )\n",
        "\n",
        "            # Append batch predictions\n",
        "            all_preds = torch.cat(\n",
        "                (all_preds.to(self.device), preds.to(self.device)), dim=0\n",
        "            )\n",
        "\n",
        "        # Calculate accuracy\n",
        "        accuracy = running_corrects / float(total)  \n",
        "\n",
        "        print(f\"Test accuracy (hybrid1): {accuracy}\")\n",
        "\n",
        "        return accuracy, all_targets, all_preds\n",
        "    \n",
        "    def increment_classes(self, n=10):\n",
        "        \"\"\"Add n classes in the final fully connected layer.\"\"\"\n",
        "\n",
        "        in_features = self.net.fc.in_features  # size of each input sample\n",
        "        out_features = self.net.fc.out_features  # size of each output sample\n",
        "        weight = self.net.fc.weight.data\n",
        "        bias = self.net.fc.bias.data\n",
        "\n",
        "        self.net.fc = nn.Linear(in_features, out_features+n)\n",
        "        self.net.fc.weight.data[:out_features] = weight\n",
        "        self.net.fc.bias.data[:out_features] = bias\n",
        "    \n",
        "    def output_neurons_count(self):\n",
        "        \"\"\"Return the number of output neurons of the current network.\"\"\"\n",
        "\n",
        "        return self.net.fc.out_features\n",
        "    \n",
        "    def feature_neurons_count(self):\n",
        "        \"\"\"Return the number of neurons of the last layer of the feature extractor.\"\"\"\n",
        "\n",
        "        return self.net.fc.in_features\n",
        "    \n",
        "    def to_onehot(self, targets):\n",
        "        \"\"\"Convert targets to one-hot encoding (for BCE loss).\n",
        "\n",
        "        Args:\n",
        "            targets: dataloader.dataset.targets of the new task images\n",
        "        \"\"\"\n",
        "        num_classes = self.net.fc.out_features\n",
        "        one_hot_targets = torch.eye(num_classes)[targets]\n",
        "\n",
        "        return one_hot_targets.to(self.device)\n",
        "\n",
        "    def network_params(self):\n",
        "        weight = self.net.fc.weight.data\n",
        "        bias = self.net.fc.bias.data\n",
        "\n",
        "        return weight, bias\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cmCpRMBKgvDB",
        "colab_type": "text"
      },
      "source": [
        "### Execution"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-nRU--zYjmZT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# iCaRL hyperparameters\n",
        "LR = 0.3\n",
        "MOMENTUM = 0.9\n",
        "WEIGHT_DECAY = 0.00001\n",
        "MILESTONES = [60, 73] \n",
        "GAMMA = 0.2\n",
        "NUM_EPOCHS = 80\n",
        "BATCH_SIZE = 64\n",
        "ALPHA = 0.00001"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1mcTQUN7VLPF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "4372c5fb-e5d1-45b2-9514-392f6ed1b191"
      },
      "source": [
        "# Define what tests to run\n",
        "TEST_ICARL = True # Run test with iCaRL (exemplars + train dataset)\n",
        "TEST_HYBRID1 = False # Run test with hybrid1\n",
        "\n",
        "# Initialize logs\n",
        "logs_icarl = [[] for _ in range(NUM_RUNS)]\n",
        "logs_icarl_rand = [[] for _ in range(NUM_RUNS)] # @DEBUG\n",
        "logs_hybrid1 = [[] for _ in range(NUM_RUNS)]\n",
        "logs_analisys = [[] for _ in range(NUM_RUNS)]\n",
        "logs_analisys_split = [dict() for _ in range(NUM_RUNS)]\n",
        "\n",
        "\n",
        "for run_i in range(NUM_RUNS-2):\n",
        "    net = resnet32()\n",
        "    icarl = iCaRL(DEVICE, net, LR, MOMENTUM, WEIGHT_DECAY, MILESTONES, GAMMA, NUM_EPOCHS, BATCH_SIZE, train_transform,\n",
        "                  test_transform, ALPHA)\n",
        "\n",
        "    for split_i in range(2):\n",
        "        print(f\"## Split {split_i} of run {run_i} ##\")\n",
        "        \n",
        "        train_logs = icarl.incremental_train(split_i, train_subsets[run_i][split_i], val_subsets[run_i][split_i])\n",
        "\n",
        "        all_targets = torch.stack([label[0] for _, label in DataLoader(test_subsets[run_i][split_i])])\n",
        "\n",
        "        if TEST_ICARL:\n",
        "            logs_icarl[run_i].append({})\n",
        "            logs_icarl_rand[run_i].append({}) \n",
        "\n",
        "            \n",
        "            print(\"Random:\") \n",
        "            acc_rand, all_targets, all_preds = icarl.test(test_subsets[run_i][split_i], train_subsets[run_i][split_i]) # @DEBUG\n",
        "\n",
        "            logs_icarl_rand[run_i][split_i]['accuracy'] = acc_rand \n",
        "            \n",
        "\n",
        "            logs_icarl[run_i][split_i]['accuracy'] = acc_rand\n",
        "            logs_icarl[run_i][split_i]['conf_mat'] = confusion_matrix(all_targets.to('cpu'), all_preds.to('cpu'))\n",
        "\n",
        "            logs_icarl[run_i][split_i]['train_loss'] = train_logs[0]\n",
        "            logs_icarl[run_i][split_i]['train_accuracy'] = train_logs[1]\n",
        "\n",
        "\n",
        "        if TEST_HYBRID1:\n",
        "            logs_hybrid1[run_i].append({})\n",
        "\n",
        "            acc, all_preds = icarl.test_without_classifier(test_subsets[run_i][split_i])\n",
        "\n",
        "            logs_hybrid1[run_i][split_i]['accuracy'] = acc\n",
        "\n",
        "\n",
        "# Possibili modifiche\n",
        "# 1. Alzare LR e alpha e rimuovere distillation, spostando a tutti gli effetti la distillation loss un layer prima\n",
        "#    in corrispondenza del layer che usiamo per la classificazione\n",
        "# 2. Se non impara le nuove  classi: alzo Lr e contemporaneamente abbasso alpha fino a che non trovo combinazione\n",
        "#    perfetta\n",
        "# 3. Posso anche variare la loss, anche se  nel setup attuale e anche logicamente secondo i nostri obbiettivi\n",
        "#    questa mi sembra appropriata. (Nostri obbiettivi e migliorare anche di uno 0.1 per ceto, qunidi non dev'essere una roba invasiva)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "## Split 0 of run 0 ##\n",
            "Length of exemplars set: 0\n",
            "Epoch: 1, LR: [0.3]\n",
            "Train loss: 0.3206946896655219, Train accuracy: 0.24129464285714286\n",
            "Validation loss: 0.29257429923330036, Validation accuracy: 0.28125\n",
            "Epoch: 2, LR: [0.3]\n",
            "Train loss: 0.26511538177728655, Train accuracy: 0.3861607142857143\n",
            "Validation loss: 0.26031827500888277, Validation accuracy: 0.38169642857142855\n",
            "Epoch: 3, LR: [0.3]\n",
            "Train loss: 0.24201933358396802, Train accuracy: 0.4575892857142857\n",
            "Validation loss: 0.235696371112551, Validation accuracy: 0.4888392857142857\n",
            "Epoch: 4, LR: [0.3]\n",
            "Train loss: 0.21946560804333007, Train accuracy: 0.5301339285714286\n",
            "Validation loss: 0.2678577516760145, Validation accuracy: 0.40848214285714285\n",
            "Epoch: 5, LR: [0.3]\n",
            "Train loss: 0.19995238610676358, Train accuracy: 0.5696428571428571\n",
            "Validation loss: 0.23322430465902602, Validation accuracy: 0.5223214285714286\n",
            "Epoch: 6, LR: [0.3]\n",
            "Train loss: 0.18291927405766079, Train accuracy: 0.6113839285714285\n",
            "Validation loss: 0.16565977675574167, Validation accuracy: 0.6316964285714286\n",
            "Epoch: 7, LR: [0.3]\n",
            "Train loss: 0.1621407595063959, Train accuracy: 0.6620535714285715\n",
            "Validation loss: 0.16856584804398672, Validation accuracy: 0.6651785714285714\n",
            "Epoch: 8, LR: [0.3]\n",
            "Train loss: 0.14839366461549486, Train accuracy: 0.6957589285714286\n",
            "Validation loss: 0.14347888848611287, Validation accuracy: 0.7142857142857143\n",
            "Epoch: 9, LR: [0.3]\n",
            "Train loss: 0.13128245355827467, Train accuracy: 0.7345982142857143\n",
            "Validation loss: 0.13729707151651382, Validation accuracy: 0.7254464285714286\n",
            "Epoch: 10, LR: [0.3]\n",
            "Train loss: 0.12480162094746317, Train accuracy: 0.7600446428571429\n",
            "Validation loss: 0.20012518337794713, Validation accuracy: 0.5848214285714286\n",
            "Epoch: 11, LR: [0.3]\n",
            "Train loss: 0.12123831191233227, Train accuracy: 0.7622767857142857\n",
            "Validation loss: 0.1259488718850272, Validation accuracy: 0.7611607142857143\n",
            "Epoch: 12, LR: [0.3]\n",
            "Train loss: 0.11136852055788041, Train accuracy: 0.7803571428571429\n",
            "Validation loss: 0.12374641107661384, Validation accuracy: 0.7723214285714286\n",
            "Epoch: 13, LR: [0.3]\n",
            "Train loss: 0.10790727638772556, Train accuracy: 0.7919642857142857\n",
            "Validation loss: 0.13065104080098017, Validation accuracy: 0.7410714285714286\n",
            "Epoch: 14, LR: [0.3]\n",
            "Train loss: 0.096669015660882, Train accuracy: 0.8033482142857142\n",
            "Validation loss: 0.14847250069890702, Validation accuracy: 0.7455357142857143\n",
            "Epoch: 15, LR: [0.3]\n",
            "Train loss: 0.09461388811469078, Train accuracy: 0.8125\n",
            "Validation loss: 0.13404846723590577, Validation accuracy: 0.7433035714285714\n",
            "Epoch: 16, LR: [0.3]\n",
            "Train loss: 0.08859549569232124, Train accuracy: 0.8292410714285714\n",
            "Validation loss: 0.16369095976863587, Validation accuracy: 0.7232142857142857\n",
            "Epoch: 17, LR: [0.3]\n",
            "Train loss: 0.0874769457748958, Train accuracy: 0.8325892857142857\n",
            "Validation loss: 0.10335649656397956, Validation accuracy: 0.8191964285714286\n",
            "Epoch: 18, LR: [0.3]\n",
            "Train loss: 0.08341367920594556, Train accuracy: 0.8424107142857142\n",
            "Validation loss: 0.11985474612031664, Validation accuracy: 0.7589285714285714\n",
            "Epoch: 19, LR: [0.3]\n",
            "Train loss: 0.07964303259338651, Train accuracy: 0.846875\n",
            "Validation loss: 0.10313731857708522, Validation accuracy: 0.8102678571428571\n",
            "Epoch: 20, LR: [0.3]\n",
            "Train loss: 0.07558239645191601, Train accuracy: 0.8609375\n",
            "Validation loss: 0.12807476094790868, Validation accuracy: 0.78125\n",
            "Epoch: 21, LR: [0.3]\n",
            "Train loss: 0.06988303783748831, Train accuracy: 0.8700892857142857\n",
            "Validation loss: 0.1128445001585143, Validation accuracy: 0.8035714285714286\n",
            "Epoch: 22, LR: [0.3]\n",
            "Train loss: 0.06957737095654011, Train accuracy: 0.8662946428571429\n",
            "Validation loss: 0.09115556840385709, Validation accuracy: 0.8459821428571429\n",
            "Epoch: 23, LR: [0.3]\n",
            "Train loss: 0.06310458670237235, Train accuracy: 0.8823660714285714\n",
            "Validation loss: 0.12729801131146296, Validation accuracy: 0.7834821428571429\n",
            "Epoch: 24, LR: [0.3]\n",
            "Train loss: 0.06083167086222342, Train accuracy: 0.8834821428571429\n",
            "Validation loss: 0.1005983618753297, Validation accuracy: 0.8035714285714286\n",
            "Epoch: 25, LR: [0.3]\n",
            "Train loss: 0.06381459475627967, Train accuracy: 0.8832589285714286\n",
            "Validation loss: 0.09031110576220922, Validation accuracy: 0.8325892857142857\n",
            "Epoch: 26, LR: [0.3]\n",
            "Train loss: 0.06044445567365204, Train accuracy: 0.8854910714285714\n",
            "Validation loss: 0.0934696186866079, Validation accuracy: 0.8214285714285714\n",
            "Epoch: 27, LR: [0.3]\n",
            "Train loss: 0.05724818765052727, Train accuracy: 0.8910714285714286\n",
            "Validation loss: 0.0927305519580841, Validation accuracy: 0.8147321428571429\n",
            "Epoch: 28, LR: [0.3]\n",
            "Train loss: 0.05509424206933805, Train accuracy: 0.896875\n",
            "Validation loss: 0.08592428479875837, Validation accuracy: 0.8392857142857143\n",
            "Epoch: 29, LR: [0.3]\n",
            "Train loss: 0.056789848022162914, Train accuracy: 0.8977678571428571\n",
            "Validation loss: 0.08391429377453667, Validation accuracy: 0.8258928571428571\n",
            "Epoch: 30, LR: [0.3]\n",
            "Train loss: 0.0502039180004171, Train accuracy: 0.9089285714285714\n",
            "Validation loss: 0.09324975205319268, Validation accuracy: 0.8504464285714286\n",
            "Epoch: 31, LR: [0.3]\n",
            "Train loss: 0.04832616208919457, Train accuracy: 0.9142857142857143\n",
            "Validation loss: 0.061316971800157, Validation accuracy: 0.8883928571428571\n",
            "Epoch: 32, LR: [0.3]\n",
            "Train loss: 0.04329971559345722, Train accuracy: 0.9178571428571428\n",
            "Validation loss: 0.10897317102977208, Validation accuracy: 0.796875\n",
            "Epoch: 33, LR: [0.3]\n",
            "Train loss: 0.04707830508372613, Train accuracy: 0.9116071428571428\n",
            "Validation loss: 0.09057300005640302, Validation accuracy: 0.8415178571428571\n",
            "Epoch: 34, LR: [0.3]\n",
            "Train loss: 0.04133786000311375, Train accuracy: 0.9265625\n",
            "Validation loss: 0.14141591957637242, Validation accuracy: 0.7700892857142857\n",
            "Epoch: 35, LR: [0.3]\n",
            "Train loss: 0.04397073718053954, Train accuracy: 0.9200892857142857\n",
            "Validation loss: 0.07230001847658839, Validation accuracy: 0.8705357142857143\n",
            "Epoch: 36, LR: [0.3]\n",
            "Train loss: 0.04187105932672109, Train accuracy: 0.9296875\n",
            "Validation loss: 0.10148206033876964, Validation accuracy: 0.8080357142857143\n",
            "Epoch: 37, LR: [0.3]\n",
            "Train loss: 0.04304063909554056, Train accuracy: 0.9276785714285715\n",
            "Validation loss: 0.08824348556143898, Validation accuracy: 0.8370535714285714\n",
            "Epoch: 38, LR: [0.3]\n",
            "Train loss: 0.03682433505143438, Train accuracy: 0.9345982142857143\n",
            "Validation loss: 0.0844743022961276, Validation accuracy: 0.8660714285714286\n",
            "Epoch: 39, LR: [0.3]\n",
            "Train loss: 0.036411933427942654, Train accuracy: 0.9352678571428571\n",
            "Validation loss: 0.0827257079737527, Validation accuracy: 0.8526785714285714\n",
            "Epoch: 40, LR: [0.3]\n",
            "Train loss: 0.03871819249221257, Train accuracy: 0.9332589285714286\n",
            "Validation loss: 0.0821100649024759, Validation accuracy: 0.8683035714285714\n",
            "Epoch: 41, LR: [0.3]\n",
            "Train loss: 0.03612222168594599, Train accuracy: 0.9390625\n",
            "Validation loss: 0.0693255995533296, Validation accuracy: 0.8772321428571429\n",
            "Epoch: 42, LR: [0.3]\n",
            "Train loss: 0.029183320867429887, Train accuracy: 0.9511160714285715\n",
            "Validation loss: 0.09516420853989464, Validation accuracy: 0.8392857142857143\n",
            "Epoch: 43, LR: [0.3]\n",
            "Train loss: 0.033259574816163096, Train accuracy: 0.9421875\n",
            "Validation loss: 0.08662160858511925, Validation accuracy: 0.8571428571428571\n",
            "Epoch: 44, LR: [0.3]\n",
            "Train loss: 0.032731125064726384, Train accuracy: 0.9419642857142857\n",
            "Validation loss: 0.0648414779986654, Validation accuracy: 0.8839285714285714\n",
            "Epoch: 45, LR: [0.3]\n",
            "Train loss: 0.030960479751229286, Train accuracy: 0.9448660714285714\n",
            "Validation loss: 0.07740035919206482, Validation accuracy: 0.8660714285714286\n",
            "Epoch: 46, LR: [0.3]\n",
            "Train loss: 0.02877648223989776, Train accuracy: 0.9488839285714286\n",
            "Validation loss: 0.07878848484584264, Validation accuracy: 0.8839285714285714\n",
            "Epoch: 47, LR: [0.3]\n",
            "Train loss: 0.033449402997004135, Train accuracy: 0.9426339285714286\n",
            "Validation loss: 0.08060114458203316, Validation accuracy: 0.8705357142857143\n",
            "Epoch: 48, LR: [0.3]\n",
            "Train loss: 0.029062387320612157, Train accuracy: 0.95\n",
            "Validation loss: 0.08814146210040365, Validation accuracy: 0.8772321428571429\n",
            "Epoch: 49, LR: [0.3]\n",
            "Train loss: 0.030518154986202715, Train accuracy: 0.9450892857142857\n",
            "Validation loss: 0.07376411770071302, Validation accuracy: 0.8794642857142857\n",
            "Epoch: 50, LR: [0.3]\n",
            "Train loss: 0.027768255344458988, Train accuracy: 0.9506696428571428\n",
            "Validation loss: 0.1239183736698968, Validation accuracy: 0.828125\n",
            "Epoch: 51, LR: [0.3]\n",
            "Train loss: 0.030204832700214217, Train accuracy: 0.9493303571428572\n",
            "Validation loss: 0.07932232746056148, Validation accuracy: 0.8727678571428571\n",
            "Epoch: 52, LR: [0.3]\n",
            "Train loss: 0.02577830284301724, Train accuracy: 0.9571428571428572\n",
            "Validation loss: 0.08129886324916567, Validation accuracy: 0.875\n",
            "Epoch: 53, LR: [0.3]\n",
            "Train loss: 0.022436654501195464, Train accuracy: 0.9622767857142858\n",
            "Validation loss: 0.08624990763408798, Validation accuracy: 0.8705357142857143\n",
            "Epoch: 54, LR: [0.3]\n",
            "Train loss: 0.0263409427699766, Train accuracy: 0.9564732142857143\n",
            "Validation loss: 0.07511536244835172, Validation accuracy: 0.8883928571428571\n",
            "Epoch: 55, LR: [0.3]\n",
            "Train loss: 0.024205579621983424, Train accuracy: 0.9598214285714286\n",
            "Validation loss: 0.09915680597935404, Validation accuracy: 0.8370535714285714\n",
            "Epoch: 56, LR: [0.3]\n",
            "Train loss: 0.0262715530049588, Train accuracy: 0.9513392857142857\n",
            "Validation loss: 0.07873335267816271, Validation accuracy: 0.8660714285714286\n",
            "Epoch: 57, LR: [0.3]\n",
            "Train loss: 0.025940003731687155, Train accuracy: 0.9529017857142857\n",
            "Validation loss: 0.05887786565082414, Validation accuracy: 0.9084821428571429\n",
            "Epoch: 58, LR: [0.3]\n",
            "Train loss: 0.02089916292711028, Train accuracy: 0.9627232142857143\n",
            "Validation loss: 0.07478813747210163, Validation accuracy: 0.8928571428571429\n",
            "Epoch: 59, LR: [0.3]\n",
            "Train loss: 0.021586839016526936, Train accuracy: 0.9647321428571428\n",
            "Validation loss: 0.08414598341499056, Validation accuracy: 0.859375\n",
            "Epoch: 60, LR: [0.3]\n",
            "Train loss: 0.02235647268327219, Train accuracy: 0.9629464285714285\n",
            "Validation loss: 0.08814462753278869, Validation accuracy: 0.8526785714285714\n",
            "Epoch: 61, LR: [0.06]\n",
            "Train loss: 0.013272130392890956, Train accuracy: 0.9785714285714285\n",
            "Validation loss: 0.06676727054374558, Validation accuracy: 0.8861607142857143\n",
            "Epoch: 62, LR: [0.06]\n",
            "Train loss: 0.008880561505377825, Train accuracy: 0.9870535714285714\n",
            "Validation loss: 0.05828055313655308, Validation accuracy: 0.9017857142857143\n",
            "Epoch: 63, LR: [0.06]\n",
            "Train loss: 0.008270801490704928, Train accuracy: 0.9895089285714286\n",
            "Validation loss: 0.06248161835329873, Validation accuracy: 0.90625\n",
            "Epoch: 64, LR: [0.06]\n",
            "Train loss: 0.007922007504384964, Train accuracy: 0.9879464285714286\n",
            "Validation loss: 0.05063797666558197, Validation accuracy: 0.9129464285714286\n",
            "Epoch: 65, LR: [0.06]\n",
            "Train loss: 0.0073034321606558344, Train accuracy: 0.9917410714285714\n",
            "Validation loss: 0.05947922170162201, Validation accuracy: 0.9196428571428571\n",
            "Epoch: 66, LR: [0.06]\n",
            "Train loss: 0.006821597936297102, Train accuracy: 0.9917410714285714\n",
            "Validation loss: 0.05655776895582676, Validation accuracy: 0.90625\n",
            "Epoch: 67, LR: [0.06]\n",
            "Train loss: 0.0061626421686794075, Train accuracy: 0.9917410714285714\n",
            "Validation loss: 0.056349264191729684, Validation accuracy: 0.9129464285714286\n",
            "Epoch: 68, LR: [0.06]\n",
            "Train loss: 0.005601217292548556, Train accuracy: 0.9935267857142858\n",
            "Validation loss: 0.052026860149843354, Validation accuracy: 0.9196428571428571\n",
            "Epoch: 69, LR: [0.06]\n",
            "Train loss: 0.006010247215661886, Train accuracy: 0.9919642857142857\n",
            "Validation loss: 0.053034999540873935, Validation accuracy: 0.9285714285714286\n",
            "Epoch: 70, LR: [0.06]\n",
            "Train loss: 0.005683724751829037, Train accuracy: 0.9928571428571429\n",
            "Validation loss: 0.05994780361652374, Validation accuracy: 0.9151785714285714\n",
            "Epoch: 71, LR: [0.06]\n",
            "Train loss: 0.005431765386102987, Train accuracy: 0.9935267857142858\n",
            "Validation loss: 0.05427118683499949, Validation accuracy: 0.921875\n",
            "Epoch: 72, LR: [0.06]\n",
            "Train loss: 0.005030218160910798, Train accuracy: 0.9941964285714285\n",
            "Validation loss: 0.05216367995100362, Validation accuracy: 0.9174107142857143\n",
            "Epoch: 73, LR: [0.06]\n",
            "Train loss: 0.004867490930649053, Train accuracy: 0.99375\n",
            "Validation loss: 0.0646965993302209, Validation accuracy: 0.9040178571428571\n",
            "Epoch: 74, LR: [0.012]\n",
            "Train loss: 0.004840206005610526, Train accuracy: 0.9935267857142858\n",
            "Validation loss: 0.05653121215956552, Validation accuracy: 0.9084821428571429\n",
            "Epoch: 75, LR: [0.012]\n",
            "Train loss: 0.004121018869669309, Train accuracy: 0.996875\n",
            "Validation loss: 0.05133647099137306, Validation accuracy: 0.9241071428571429\n",
            "Epoch: 76, LR: [0.012]\n",
            "Train loss: 0.004124742989162249, Train accuracy: 0.9962053571428572\n",
            "Validation loss: 0.05347225069999695, Validation accuracy: 0.9263392857142857\n",
            "Epoch: 77, LR: [0.012]\n",
            "Train loss: 0.0046232805013590094, Train accuracy: 0.9946428571428572\n",
            "Validation loss: 0.06087292278451579, Validation accuracy: 0.9174107142857143\n",
            "Epoch: 78, LR: [0.012]\n",
            "Train loss: 0.0035589270850843084, Train accuracy: 0.9964285714285714\n",
            "Validation loss: 0.0540723092854023, Validation accuracy: 0.9151785714285714\n",
            "Epoch: 79, LR: [0.012]\n",
            "Train loss: 0.004108347639807367, Train accuracy: 0.9957589285714286\n",
            "Validation loss: 0.05476728454232216, Validation accuracy: 0.921875\n",
            "Epoch: 80, LR: [0.012]\n",
            "Train loss: 0.0039353119691700805, Train accuracy: 0.9957589285714286\n",
            "Validation loss: 0.0634374948484557, Validation accuracy: 0.90625\n",
            "### Current net saved\n",
            "Target number of exemplars per class: 200\n",
            "Target total number of exemplars: 2000\n",
            "Randomly extracting exemplars from class 0 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 1 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 2 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 3 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 4 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 5 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 6 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 7 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 8 of current split... Extracted 200 exemplars.\n",
            "Randomly extracting exemplars from class 9 of current split... Extracted 200 exemplars.\n",
            "Random:\n",
            "Computing mean of exemplars... "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJCtZaA_X03n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "obj_save(icarl.rep_distance, 'reduced_rep_distance')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wuDM6Ydokv05",
        "colab_type": "text"
      },
      "source": [
        "### Plots"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nEn9P6usbwYa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_loss = [[logs_icarl[run_i][i]['train_loss'] for i in range(10)] for run_i in range(NUM_RUNS)]\n",
        "train_accuracy = [[logs_icarl[run_i][i]['train_accuracy'] for i in range(10)] for run_i in range(NUM_RUNS)]\n",
        "val_loss = [[logs_icarl[run_i][i]['val_loss'] for i in range(10)] for run_i in range(NUM_RUNS)]\n",
        "val_accuracy = [[logs_icarl[run_i][i]['val_accuracy'] for i in range(10)] for run_i in range(NUM_RUNS)]\n",
        "test_accuracy = [[logs_icarl[run_i][i]['accuracy'] for i in range(10)] for run_i in range(NUM_RUNS)]\n",
        "\n",
        "train_loss = np.array(train_loss)\n",
        "train_accuracy = np.array(train_accuracy)\n",
        "val_loss = np.array(val_loss)\n",
        "val_accuracy = np.array(val_accuracy)\n",
        "test_accuracy = np.array(test_accuracy)\n",
        "\n",
        "train_loss_stats = np.array([train_loss.mean(0), train_loss.std(0)]).transpose()\n",
        "train_accuracy_stats = np.array([train_accuracy.mean(0), train_accuracy.std(0)]).transpose()\n",
        "val_loss_stats = np.array([val_loss.mean(0), val_loss.std(0)]).transpose()\n",
        "val_accuracy_stats = np.array([val_accuracy.mean(0), val_accuracy.std(0)]).transpose()\n",
        "test_accuracy_stats = np.array([test_accuracy.mean(0), test_accuracy.std(0)]).transpose()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-GmiU4BfhVht",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plot.train_val_scores(train_loss_stats, train_accuracy_stats, val_loss_stats, val_accuracy_stats)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PAWPfif3j7pK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plot.test_scores(test_accuracy_stats)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Ezv8lUG7DsQw"
      },
      "source": [
        "### T-SNE"
      ]
    }
  ]
}