05__iCarl_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "05_ iCarl .ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8AlIcK8iKdP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "962ab12e-70f0-4e1f-b849-44ca8716ce95"
      },
      "source": [
        "pip install 'import_ipynb'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting import_ipynb\n",
            "  Downloading https://files.pythonhosted.org/packages/63/35/495e0021bfdcc924c7cdec4e9fbb87c88dd03b9b9b22419444dc370c8a45/import-ipynb-0.1.3.tar.gz\n",
            "Building wheels for collected packages: import-ipynb\n",
            "  Building wheel for import-ipynb (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for import-ipynb: filename=import_ipynb-0.1.3-cp36-none-any.whl size=2976 sha256=110a89f102c3ea3bcc1d7e0d7a2da3bfb33e55ef28a102fc41ab86309d227987\n",
            "  Stored in directory: /root/.cache/pip/wheels/b4/7b/e9/a3a6e496115dffdb4e3085d0ae39ffe8a814eacc44bbf494b5\n",
            "Successfully built import-ipynb\n",
            "Installing collected packages: import-ipynb\n",
            "Successfully installed import-ipynb-0.1.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jNfj-qcxiQPm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "outputId": "3981a02e-af80-4a98-a5db-60cd671b9a2f"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.models as models\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Subset, DataLoader\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.gridspec as gridspec\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import torchvision\n",
        "import math\n",
        "from sklearn.preprocessing import normalize\n",
        "import copy\n",
        "from scipy.special import softmax\n",
        "\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import random\n",
        "import pandas as pd\n",
        "import seaborn as sn\n",
        "from sklearn.metrics import confusion_matrix as s_cm\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "  \n",
        "%cd /content/drive/My\\ Drive/MLDLProjects/Lande_Napolitano_Pipoli/Project_root\n",
        " \n",
        "import import_ipynb\n",
        "from cifar100 import cifar_100\n",
        "from net import resnet32"
      ],
      "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"
        },
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n",
            "/content/drive/My Drive/MLDLProjects/Lande_Napolitano_Pipoli/Project_root\n",
            "importing Jupyter notebook from cifar100.ipynb\n",
            "IMPORT CIFAR DONE Rseed\n",
            "importing Jupyter notebook from net.ipynb\n",
            "IMPORT NET DONE\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZvfpM-WHD5cP",
        "colab_type": "text"
      },
      "source": [
        "iCarl Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeBTHHFrffBg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class iCaRLNet(nn.Module):\n",
        "    def __init__(self, feature_size, n_classes, lr=2.0, momentum=0.9,gamma=0.2, weight_decay=1e-5, milestone=[49, 63], batch_size=128, num_epochs=70):\n",
        "        # Network architecture\n",
        "        super(iCaRLNet, self).__init__()\n",
        "        self.net = resnet32(num_classes=n_classes)\n",
        "        self.feature_extractor = self.net.get_fm_out #Modified\n",
        "        self.lr = lr\n",
        "        self.gamma = gamma\n",
        "        self.momentum=momentum\n",
        "        self.weight_decay = weight_decay\n",
        "        self.milestone = milestone\n",
        "        self.batch_size = batch_size\n",
        "        self.num_epochs = num_epochs\n",
        "        self.n_classes = 0\n",
        "        self.n_known = 0\n",
        "\n",
        "        self.exemplar_sets = []\n",
        "        self.feature_size=feature_size\n",
        "\n",
        "        # Learning method\n",
        "        self.BCEwithL = nn.BCEWithLogitsLoss()\n",
        "\n",
        "        self.compute_means = True\n",
        "        self.exemplar_means = []\n",
        "\n",
        "        self.compute_SVM = True\n",
        "        self.SVM=None\n",
        "        self.compute_feat = True\n",
        "        self.exemplar_feat = []\n",
        "        self.exemplar_lab = []\n",
        "        self.mapper = None\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        self.net = self.net.cuda()\n",
        "        return self.net.forward(x)\n",
        "                                    \n",
        "\n",
        "    def compute_precisions(self,y_true, y_pred, last_classes):\n",
        "        precisions = []\n",
        "        for c in last_classes:\n",
        "            correct = sum(y_pred[y_true == c] == c)\n",
        "            wrong = sum(y_pred[y_true == c] != c)\n",
        "            tot = correct + wrong\n",
        "            prec = correct / tot\n",
        "            precisions.append(prec)\n",
        "        return softmax(precisions)\n",
        "        \n",
        "\n",
        "    def classify(self, x, cif):  \n",
        "        if self.compute_means:\n",
        "            print(\"Computing mean of exemplars...\")\n",
        "            exemplar_means = []\n",
        "            for P_y in self.exemplar_sets:  #P_y list of indices\n",
        "                features = np.zeros((0,64))\n",
        "                sub = Subset(cif, P_y)\n",
        "                dl = torch.utils.data.DataLoader(sub, batch_size=self.batch_size,shuffle=False, num_workers=4)\n",
        "                # Extract feature for each exemplar in P_y\n",
        "                with torch.no_grad():\n",
        "                  for ind, ex, lab in dl:\n",
        "                    ex = Variable(ex).cuda()\n",
        "                    feature = self.feature_extractor(ex).data.cpu().numpy()\n",
        "                    feature = normalize(feature, axis=1, norm='l2')\n",
        "                    features = np.concatenate((features,feature), axis=0)\n",
        "\n",
        "                features = torch.tensor(features)\n",
        "                mu_y = features.mean(0).squeeze()\n",
        "                mu_y.data = mu_y.data / torch.norm(mu_y, p=2)  # L2 Normalize\n",
        "                exemplar_means.append(mu_y)\n",
        "\n",
        "            self.exemplar_means = exemplar_means\n",
        "            self.compute_means = False\n",
        "            print(\"Done\")\n",
        "\n",
        "        exemplar_means = self.exemplar_means\n",
        "        means = torch.stack(exemplar_means)  # (n_classes, feature_size)\n",
        "        means = torch.stack([means] * self.batch_size)  # (batch_size, n_classes, feature_size)\n",
        "        means = means.transpose(1, 2)  # (batch_size, feature_size, n_classes)\n",
        "\n",
        "        feature = self.feature_extractor(x)  # (batch_size, feature_size)\n",
        "        for i in range(feature.size(0)):  # Normalize\n",
        "            feature.data[i] = feature.data[i] / torch.norm(feature.data[i], p=2)\n",
        "        feature = feature.unsqueeze(2)  # (batch_size, feature_size, 1)\n",
        "        feature = feature.expand_as(means)  # (batch_size, feature_size, n_classes)\n",
        "        feature = feature.cuda()\n",
        "        means = means.cuda()\n",
        "\n",
        "        dists = torch.sqrt((feature - means).pow(2).sum(1)).squeeze()  # (batch_size, n_classes)\n",
        "        _, preds = dists.min(1) \n",
        "\n",
        "        return preds\n",
        "\n",
        "\n",
        "    def classify_Cermelli(self, x, cif, rl): \n",
        "        if self.compute_means:\n",
        "            exemplar_means = []\n",
        "            for i,P_y in enumerate(self.exemplar_sets):  #P_y list of indice\n",
        "                \n",
        "                features = np.zeros((0,self.feature_size))\n",
        "                if i<self.n_classes-10:\n",
        "                    #print(\"VECCHIE CLASSI\")\n",
        "                    sub = Subset(cif, P_y)\n",
        "                    #print(len(sub))\n",
        "                    dl = torch.utils.data.DataLoader(sub, batch_size=self.batch_size,shuffle=False, num_workers=4) \n",
        "                    with torch.no_grad():\n",
        "                        for ind, ex, lab in dl:# Extract feature for each exemplar in P_y\n",
        "                            ex = Variable(ex).cuda()\n",
        "                            feature = self.feature_extractor(ex).data.cpu().numpy()\n",
        "                            feature = normalize(feature, axis=1, norm='l2')\n",
        "                            features = np.concatenate((features,feature), axis=0)\n",
        "                else:\n",
        "                    #print(\"NUOVE CLASSI\")\n",
        "                    indexes=cif.getClassIndexes(rl[i])\n",
        "                    sub = Subset(cif, indexes)\n",
        "                    #print(len(sub))\n",
        "                    dl = torch.utils.data.DataLoader(sub, batch_size=self.batch_size,shuffle=False, num_workers=4) \n",
        "                    with torch.no_grad():\n",
        "                        for ind, ex, lab in dl:# Extract feature for each exemplar in P_y\n",
        "                            ex = Variable(ex).cuda()\n",
        "                            feature = self.feature_extractor(ex).data.cpu().numpy()\n",
        "                            feature = normalize(feature, axis=1, norm='l2')\n",
        "                            features = np.concatenate((features,feature), axis=0)\n",
        "\n",
        "                features = torch.tensor(features)\n",
        "                mu_y = features.mean(0).squeeze()\n",
        "                mu_y.data = mu_y.data / torch.norm(mu_y, p=2)  # L2 Normalize\n",
        "                exemplar_means.append(mu_y)\n",
        "                \n",
        "            self.exemplar_means = exemplar_means\n",
        "            self.compute_means = False\n",
        "\n",
        "        exemplar_means = self.exemplar_means\n",
        "        means = torch.stack(exemplar_means)  # (n_classes, feature_size)\n",
        "        means = torch.stack([means] * self.batch_size)  # (batch_size, n_classes, feature_size)\n",
        "        means = means.transpose(1, 2)  # (batch_size, feature_size, n_classes)\n",
        "\n",
        "        feature = self.feature_extractor(x)  # (batch_size, feature_size)\n",
        "        for i in range(feature.size(0)):  # Normalize\n",
        "            feature.data[i] = feature.data[i] / torch.norm(feature.data[i], p=2)\n",
        "        feature = feature.unsqueeze(2)  # (batch_size, feature_size, 1)\n",
        "        feature = feature.expand_as(means)  # (batch_size, feature_size, n_classes)\n",
        "        feature = feature.cuda()\n",
        "        means = means.cuda()\n",
        "\n",
        "        dists = torch.sqrt((feature - means).pow(2).sum(1)).squeeze()  # (batch_size, n_classes)\n",
        "        _, preds = dists.min(1)\n",
        "\n",
        "        return preds\n",
        "\n",
        "\n",
        "    def compute_exemplar_features(self, cif, mapper):\n",
        "        if self.compute_feat:\n",
        "            exemplar_feat = np.zeros((0,self.feature_size))\n",
        "            labs=[]\n",
        "            for exemplar_list in self.exemplar_sets:  #exemplar_list list of exemplar indexes\n",
        "                features = np.zeros((0,self.feature_size))\n",
        "                sub = Subset(cif, exemplar_list)\n",
        "                dl = torch.utils.data.DataLoader(sub, batch_size=self.batch_size,shuffle=False, num_workers=4) \n",
        "\n",
        "                with torch.no_grad():\n",
        "                    for ind, ex, lab in dl:# Extract feature for each exemplar in exemplar_list\n",
        "                        ex = Variable(ex).cuda()\n",
        "                        lab = [mapper[l.item()] for l in lab]\n",
        "                        feature = self.feature_extractor(ex).data.cpu().numpy() #(batch_size, feature_size)\n",
        "                        feature = normalize(feature, axis=1, norm='l2')\n",
        "                        features = np.concatenate((features,feature), axis=0)\n",
        "                        labs.extend(lab)\n",
        "                        \n",
        "                exemplar_feat=np.concatenate((exemplar_feat,features), axis=0)\n",
        "\n",
        "            self.exemplar_lab=labs\n",
        "            self.exemplar_feat = exemplar_feat\n",
        "            self.compute_feat = False\n",
        "\n",
        "    \n",
        "    def classify_SVM(self, x): \n",
        "        if self.compute_SVM:\n",
        "            #TRAIN\n",
        "            x_train = self.exemplar_feat\n",
        "            y_train = self.exemplar_lab\n",
        "            c = 1 \n",
        "            rbf = SVC(kernel='rbf', C=c)\n",
        "            rbf.fit(x_train, y_train)\n",
        "            self.SVM = rbf\n",
        "            self.compute_SVM = False\n",
        "        #TEST\n",
        "        feature = self.feature_extractor(x)  # (batch_size, feature_size)\n",
        "        for i in range(feature.size(0)):  # Normalize\n",
        "            feature.data[i] = feature.data[i] / torch.norm(feature.data[i], p=2)\n",
        "        x_test=feature.detach().cpu().numpy()\n",
        "        y_pred=self.SVM.predict(x_test)\n",
        "        y_pred=torch.Tensor(y_pred)\n",
        "        return y_pred\n",
        "\n",
        "\n",
        "\n",
        "    def construct_exemplar_set(self, images, m):\n",
        "   \n",
        "        # Compute and cache features for each example\n",
        "        features = np.zeros((0,64))\n",
        "        indices = np.zeros((0), dtype=int)\n",
        "        dl = torch.utils.data.DataLoader(images, batch_size=self.batch_size,shuffle=False, num_workers=4)\n",
        "        with torch.no_grad():\n",
        "          for ind, img, lab in dl:\n",
        "            x = Variable(img).cuda()\n",
        "            feature = self.feature_extractor(x).data.cpu().numpy()\n",
        "            feature = normalize(feature, axis=1, norm='l2')\n",
        "            features = np.concatenate((features,feature), axis=0)\n",
        "            indices = np.concatenate((indices,ind), axis=0)\n",
        "\n",
        "        class_mean = np.mean(features, axis=0)\n",
        "        class_mean = class_mean / np.linalg.norm(class_mean)  # Normalize\n",
        "\n",
        "        exemplar_set = []\n",
        "        exemplar_features = np.zeros((0,64))\n",
        "\n",
        "        for k in range(1, int(m)+1):\n",
        "            S = np.sum(exemplar_features, axis=0)\n",
        "            phi = features\n",
        "            mu = class_mean\n",
        "            mu_p = 1.0 / k * (phi + S)\n",
        "            mu_p = normalize(mu_p, axis=1, norm='l2')\n",
        "            i = np.argmin(np.sqrt(np.sum((mu - mu_p) ** 2, axis=1)))\n",
        "            exemplar_set.append(indices[i])\n",
        "            addfeature =  np.expand_dims(features[i], axis=0)\n",
        "            exemplar_features = np.concatenate((exemplar_features,addfeature), axis=0)\n",
        "\n",
        "            #remove duplicates\n",
        "            features = np.delete(features, i, 0)\n",
        "            indices = np.delete(indices, i, 0)\n",
        "\n",
        "        self.exemplar_sets.append(exemplar_set)\n",
        "    \n",
        "\n",
        "    def reduce_exemplar_sets(self, prop):\n",
        "        len_e=[]\n",
        "        for y, P_y in enumerate(self.exemplar_sets):\n",
        "            l=prop*len(P_y)\n",
        "            if l>int(l)+0.5:\n",
        "                l=l+1\n",
        "            self.exemplar_sets[y] = P_y[:int(l)]\n",
        "            len_e.append(len(self.exemplar_sets[y]))\n",
        "\n",
        "    \n",
        "    def delete_last10_exemplar(self):\n",
        "        self.exemplar_sets=self.exemplar_sets[:len(self.exemplar_sets)-10]\n",
        "    \n",
        "\n",
        "    def combine_dataset_with_exemplars(self, cifar):\n",
        "        newindexes = []\n",
        "        for y, P_y in enumerate(self.exemplar_sets):\n",
        "            exemplar_images = P_y\n",
        "            exemplar_labels = [y] * len(P_y)\n",
        "            print(exemplar_images[0].shape)\n",
        "            newindexes+=cifar.data_append(exemplar_images, exemplar_labels)\n",
        "        return newindexes\n",
        "\n",
        "    def exemplarIndexes(self):\n",
        "      Indexes = []\n",
        "      for P_y in self.exemplar_sets:\n",
        "        Indexes += P_y\n",
        "      return Indexes\n",
        "\n",
        "\n",
        "    def update_representation(self, cifar, batchindexes, diz):\n",
        "        prev_model = copy.deepcopy(self)\n",
        "        prev_model = prev_model.eval().cuda()\n",
        "        self.compute_means = True\n",
        "        self.compute_SVM = True\n",
        "        self.compute_feat = True\n",
        "\n",
        "        self.n_classes += 10\n",
        "        print(\"%d new classes\" % (10))\n",
        "        print(len(batchindexes))\n",
        "        # Form combined training set\n",
        "        newindexes = []\n",
        "        if self.n_classes > 10:\n",
        "          newindexes = self.exemplarIndexes()\n",
        "        newindexes += list(batchindexes)\n",
        "        print(len(newindexes))\n",
        "        reprdata = Subset(cifar, newindexes)\n",
        "\n",
        "        loader = torch.utils.data.DataLoader(reprdata, batch_size=self.batch_size,shuffle=True, num_workers=4, drop_last=True)\n",
        "\n",
        "        # Run network training\n",
        "\n",
        "        optimizer = optim.SGD(self.net.parameters(), lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay)\n",
        "        scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=self.milestone, gamma=self.gamma)\n",
        "\n",
        "        print(\"TRAIN\")\n",
        "        for epoch in range(self.num_epochs):\n",
        "            losses = []\n",
        "            classlosses = []\n",
        "            distlosses = []\n",
        "            for indices, images, labels in loader:\n",
        "                labels = torch.tensor([torch.tensor(diz[c.item()]) for c in labels])\n",
        "                images = Variable(torch.FloatTensor(images)).cuda()\n",
        "                labels = Variable(labels).cuda()\n",
        "                optimizer.zero_grad()\n",
        "                g = self.forward(images)\n",
        "                y_hot = F.one_hot(labels, self.n_classes).float().cuda()\n",
        "                ClassScalefactor = ((10)/(self.n_classes))\n",
        "                loss = self.BCEwithL(g[:,self.n_known:self.n_classes], y_hot[:,self.n_known:self.n_classes])*ClassScalefactor\n",
        "            \n",
        "                if self.n_known > 0:\n",
        "                    GammaFactor = 1 - (self.n_classes/(self.n_known+self.n_classes))\n",
        "                    GammaFactor = math.exp(-GammaFactor)\n",
        "                    adjustment = loss * GammaFactor\n",
        "                    loss = loss+adjustment\n",
        "                    classlosses.append(loss.item())\n",
        "                    q = prev_model.forward(images)\n",
        "                    q = torch.sigmoid(q)\n",
        "                    distScaleFactor = (self.n_known)/(self.n_classes)\n",
        "                    distloss = self.BCEwithL(g[:,:self.n_known], q[:,:self.n_known]) * distScaleFactor \n",
        "                    distlosses.append(distloss.item())\n",
        "                    loss += distloss\n",
        "                else:\n",
        "                    classlosses.append(loss.item())\n",
        "                losses.append(loss.item())\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "\n",
        "            if (epoch + 1) % 5 == 0:\n",
        "                if len(distlosses) == 0:\n",
        "                    mean_dist = 0\n",
        "                else:\n",
        "                    mean_dist = np.mean(np.array(distlosses))\n",
        "                print('Epoch [%d/%d], Average_Loss(tot, dist, class): %.4f, %.4f, %.4f' \\\n",
        "                  % (epoch + 1, self.num_epochs, np.mean(np.array(losses)), mean_dist, np.mean(np.array(classlosses))))\n",
        "\n",
        "            scheduler.step()\n",
        "\n",
        "    def set_mapper(self, mapper):\n",
        "        self.mapper = mapper\n",
        "\n",
        "    def get_mapper(self):\n",
        "        if self.mapper is None:\n",
        "            print(\"ERROR: mapper has not been set. Use model.set_mapper(mapper) first.\")\n",
        "            return None\n",
        "        return self.mapper\n",
        "\n",
        "    def compute_confusion_matrix(self, cif, title, plot=False, svm=False):\n",
        "      \n",
        "        cifar_test = cifar_100(100, 'test')\n",
        "        dl = torch.utils.data.DataLoader(cifar_test, batch_size=128,shuffle=True, num_workers=4, drop_last=True)\n",
        "        y_true = []\n",
        "        y_pred = []\n",
        "        for _, images, labels in dl:\n",
        "            images = Variable(images).cuda()\n",
        "            y_true.extend(labels)\n",
        "            if not svm:\n",
        "              y_pred_tmp = self.classify(images, cif)\n",
        "            else:\n",
        "              y_pred_tmp = self.classify_SVM(images)\n",
        "            y_pred_tmp = [p.item() for p in y_pred_tmp]\n",
        "            y_pred.extend(y_pred_tmp)\n",
        "        \n",
        "        y_true = [self.mapper[l.item()] for l in y_true]\n",
        "        acc_matrix = s_cm(y_true, y_pred)\n",
        "\n",
        "        if plot:\n",
        "            plt.figure(figsize=(11,11))\n",
        "            df_cm = pd.DataFrame(acc_matrix)\n",
        "            sn.heatmap(df_cm, square=True, xticklabels=20, yticklabels=20)\n",
        "            plt.title(title)\n",
        "            plt.show()\n",
        "\n",
        "        return acc_matrix\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Lczpe7x_soY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "d7193e94-3f4e-43b6-9a99-ebf512e708cd"
      },
      "source": [
        "total_classes = 100\n",
        "num_classes = 10\n",
        "random_seed = 981\n",
        "cifarTrain = cifar_100(num_classes, 'train',  rand_seed=random_seed)\n",
        "cifarTest = cifar_100(num_classes, 'test', rand_seed=random_seed)\n",
        "randomlist = cifarTrain.get_classes_list()\n",
        "diz = cifarTrain.get_dictionary()\n",
        "def compute_acc(dl, model, mapper, rl):\n",
        "    total = 0.0\n",
        "    correct = 0.0\n",
        "    correct_svm=0.0\n",
        "    for _, images, labels in dl:\n",
        "        labels = torch.tensor([torch.tensor(mapper[c.item()]) for c in labels])\n",
        "        images = Variable(images).cuda()\n",
        "        preds = model.classify_Cermelli(images, cifarTrain,rl)\n",
        "        preds_svm=model.classify_SVM(images) \n",
        "        total = total + len(labels)\n",
        "        correct += (preds.data.cpu() == labels).sum()\n",
        "        correct_svm += (preds_svm.data.cpu() == labels).sum()\n",
        "        \n",
        "    acc = 100 * correct / total\n",
        "    acc_svm = 100 * correct_svm / total\n",
        "    return acc, acc_svm"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bx4wSwCsD8TC",
        "colab_type": "text"
      },
      "source": [
        "Main"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qv4ZVuYviDK1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "097cc0d0-c800-41c9-89c6-f34dbe89e947"
      },
      "source": [
        "torch.cuda.current_device()\n",
        "torch.cuda._initialized = True\n",
        "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "# Initialize CNN\n",
        "K = 3000  # total number of exemplars\n",
        "icarl = iCaRLNet(64, 100, num_epochs=70)\n",
        "icarl = icarl.to(DEVICE)\n",
        "BATCH_SIZE = 128\n",
        "acc_vect = []\n",
        "icarl.set_mapper(diz)\n",
        "\n",
        "for s in range(10):\n",
        "    # Load Datasets\n",
        "    print(\"\\n\\nLoading training examples for classes\", randomlist[s*num_classes:s*num_classes + num_classes])\n",
        "    batchindexes = cifarTrain.getClassIndexes(randomlist[s*num_classes:s*num_classes + num_classes])\n",
        "    batch = Subset(cifarTrain, batchindexes)\n",
        "\n",
        "    print(\"Batch size: {}\".format(len(batch)))\n",
        "    testindexes = cifarTest.getClassIndexes(randomlist[0:s*num_classes + num_classes])\n",
        "    test_set = Subset(cifarTest, testindexes)\n",
        "\n",
        "    train_loader = torch.utils.data.DataLoader(batch, batch_size=BATCH_SIZE,shuffle=True, num_workers=4, drop_last=True)\n",
        "    test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE,shuffle=False, num_workers=4, drop_last=True)\n",
        "\n",
        "    # Update representation via BackProp\n",
        "    icarl.train()\n",
        "    icarl.update_representation(cifarTrain, batchindexes, diz)\n",
        "    icarl.eval()\n",
        "\n",
        "    m = K / icarl.n_classes\n",
        "\n",
        "    # VETTORE DI M\n",
        "    # FARLA IN PERCENTUALE\n",
        "    icarl.reduce_exemplar_sets(s/(s+1))\n",
        "\n",
        "    el_ex={}\n",
        "    tot_len=0\n",
        "    for z,el in enumerate(icarl.exemplar_sets):\n",
        "        el_ex[z]=len(el)\n",
        "        tot_len+=len(el)\n",
        "    print(f\"Total_len exemplars old classes:{tot_len}\")\n",
        "    #if tot_len:\n",
        "        #print(el_ex)\n",
        "\n",
        "    \n",
        "    sum_m_old=0\n",
        "    # Construct exemplar sets for new classes\n",
        "    for y in randomlist[s*num_classes:s*num_classes + num_classes]:\n",
        "        #print(\"Constructing exemplar set for class-%d...\" % (y))\n",
        "        imagesInd = cifarTrain.getClassIndexes([y])\n",
        "        images = Subset(cifarTrain, imagesInd)\n",
        "        # print(imagesInd)\n",
        "        icarl.construct_exemplar_set(images, m)\n",
        "        sum_m_old+=m\n",
        "        #print(\"Done exemplars\")\n",
        "\n",
        "    icarl.n_known = icarl.n_classes\n",
        "    icarl.compute_exemplar_features(cifarTrain, diz)\n",
        "\n",
        "    print(\"iCaRL classes: %d\" % icarl.n_known)\n",
        "\n",
        "    total = 0.0\n",
        "    correct = 0.0\n",
        "    correct_svm=0.0\n",
        "    for indices, images, labels in train_loader:\n",
        "        labels = torch.tensor([torch.tensor(diz[c.item()]) for c in labels])\n",
        "        images = Variable(images).cuda()\n",
        "        preds = icarl.classify_Cermelli(images, cifarTrain, randomlist)\n",
        "        preds_svm=icarl.classify_SVM(images) \n",
        "        total = total + len(labels)\n",
        "        correct += (preds.data.cpu() == labels).sum()\n",
        "        correct_svm += (preds_svm.data.cpu() == labels).sum()\n",
        "    acc = 100 * correct / total\n",
        "    acc_svm = 100 * correct_svm / total\n",
        "    print('Train Accuracy: {:.2f}, SVM Accuracy: {:.2f}'.format(acc, acc_svm).rstrip())\n",
        "\n",
        "    total = 0.0\n",
        "    correct = 0.0\n",
        "    correct_svm=0.0\n",
        "    y_true = np.array(len(test_set))\n",
        "    y_pred = np.array(len(test_set))\n",
        "    for indices, images, labels in test_loader:\n",
        "        labels = torch.tensor([torch.tensor(diz[c.item()]) for c in labels])\n",
        "        images = Variable(images).cuda()\n",
        "        preds = icarl.classify_Cermelli(images, cifarTrain, randomlist)\n",
        "        preds_svm=icarl.classify_SVM(images) \n",
        "        total = total + len(labels)\n",
        "        correct += (preds.data.cpu() == labels).sum()\n",
        "        correct_svm += (preds_svm.data.cpu() == labels).sum()\n",
        "        y_true = np.append(y_true, labels.detach().cpu().numpy())\n",
        "        y_pred = np.append(y_pred, preds.detach().cpu().numpy())\n",
        "    acc = 100 * correct / total\n",
        "    acc_svm = 100 * correct_svm / total\n",
        "    print('Test Accuracy: {:.2f}, SVM Accuracy: {:.2f}'.format(acc, acc_svm).rstrip())\n",
        "    acc_vect.append(100 * correct / total)\n",
        "\n",
        "    w = icarl.compute_precisions(y_true, y_pred, [diz[c] for c in randomlist[s*num_classes:s*num_classes + num_classes]])\n",
        "    w=np.around(w,decimals=4)\n",
        "\n",
        "    mean_w=np.mean(w)\n",
        "\n",
        "    len_prev_ex=len(icarl.exemplar_sets)\n",
        "    icarl.delete_last10_exemplar()\n",
        "    len_new_ex=len(icarl.exemplar_sets)\n",
        "\n",
        "    sum_m_new=0\n",
        "    for z,y in enumerate(randomlist[s*num_classes:s*num_classes + num_classes]):\n",
        "        imagesInd = cifarTrain.getClassIndexes([y])\n",
        "        images = Subset(cifarTrain, imagesInd)\n",
        "        if w[z]==mean_w:\n",
        "            new_m=m\n",
        "        else:\n",
        "            if w[z]>mean_w:\n",
        "                new_m=float(m)-float(m)*w[z]\n",
        "            else:\n",
        "                new_m=float(m)+float(m)*w[z]\n",
        "        sum_m_new+=new_m\n",
        "        old_new_m=new_m\n",
        "        if new_m>int(new_m)+0.5:\n",
        "            new_m=int(new_m)+1\n",
        "        #print(f\"New_m: {new_m} (no int: {old_new_m}) - Peso: {w[z]}\")\n",
        "        icarl.construct_exemplar_set(images, new_m)\n",
        "\n",
        "    print(f\"M_old:{sum_m_old} - M_new:{sum_m_new}\")\n",
        "    el_ex={}\n",
        "    tot_len=0\n",
        "    for z,el in enumerate(icarl.exemplar_sets):\n",
        "        el_ex[z]=len(el)\n",
        "        tot_len+=len(el)\n",
        "    print(f\"Total_len exemplars with new classes:{tot_len}\")\n",
        "    #print(el_ex)\n",
        "\n",
        "    #break\n",
        "    \n",
        "\n",
        "print(acc_vect)\n",
        "cm = icarl.compute_confusion_matrix(cifarTrain, \"our model NME - K=3000\", plot=True)\n",
        "cm2 = icarl.compute_confusion_matrix(cifarTrain, \"our model SVM - K=3000\", plot=True, svm=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Loading training examples for classes [28, 7, 17, 45, 46, 91, 63, 13, 95, 59]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "5000\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.3182, 0.0000, 0.3182\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.2849, 0.0000, 0.2849\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.2529, 0.0000, 0.2529\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.2243, 0.0000, 0.2243\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.2012, 0.0000, 0.2012\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.1805, 0.0000, 0.1805\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.1591, 0.0000, 0.1591\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.1372, 0.0000, 0.1372\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.1230, 0.0000, 0.1230\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0929, 0.0000, 0.0929\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0711, 0.0000, 0.0711\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0615, 0.0000, 0.0615\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0489, 0.0000, 0.0489\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0439, 0.0000, 0.0439\n",
            "Total_len exemplars old classes:0\n",
            "iCaRL classes: 10\n",
            "Train Accuracy: 92.81, SVM Accuracy: 93.41\n",
            "Test Accuracy: 83.59, SVM Accuracy: 83.82\n",
            "M_old:3000.0 - M_new:2922.27\n",
            "Total_len exemplars with new classes:2923\n",
            "\n",
            "\n",
            "Loading training examples for classes [90, 69, 93, 22, 20, 39, 6, 61, 19, 81]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "7923\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.1831, 0.0760, 0.1071\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.1596, 0.0747, 0.0849\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.1432, 0.0750, 0.0682\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.1339, 0.0747, 0.0592\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.1235, 0.0727, 0.0508\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.1174, 0.0731, 0.0443\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.1135, 0.0730, 0.0406\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.1083, 0.0728, 0.0355\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.1041, 0.0724, 0.0316\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0867, 0.0679, 0.0188\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0740, 0.0651, 0.0089\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0708, 0.0641, 0.0068\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0675, 0.0630, 0.0045\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0667, 0.0623, 0.0044\n",
            "Total_len exemplars old classes:1459\n",
            "iCaRL classes: 20\n",
            "Train Accuracy: 95.53, SVM Accuracy: 97.34\n",
            "Test Accuracy: 75.05, SVM Accuracy: 75.00\n",
            "M_old:1500.0 - M_new:1520.9399999999998\n",
            "Total_len exemplars with new classes:2980\n",
            "\n",
            "\n",
            "Loading training examples for classes [96, 37, 76, 40, 43, 8, 1, 83, 2, 49]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "7980\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.1124, 0.0717, 0.0408\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.1011, 0.0725, 0.0286\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0954, 0.0723, 0.0231\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0922, 0.0731, 0.0191\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0908, 0.0734, 0.0174\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0878, 0.0727, 0.0151\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0869, 0.0732, 0.0137\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0855, 0.0729, 0.0125\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0832, 0.0725, 0.0107\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0747, 0.0686, 0.0061\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0683, 0.0657, 0.0026\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0673, 0.0651, 0.0022\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0661, 0.0644, 0.0018\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0655, 0.0638, 0.0017\n",
            "Total_len exemplars old classes:1985\n",
            "iCaRL classes: 30\n",
            "Train Accuracy: 95.63, SVM Accuracy: 97.50\n",
            "Test Accuracy: 71.57, SVM Accuracy: 72.04\n",
            "M_old:1000.0 - M_new:994.77\n",
            "Total_len exemplars with new classes:2979\n",
            "\n",
            "\n",
            "Loading training examples for classes [12, 27, 68, 29, 80, 86, 24, 11, 26, 51]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "7979\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.1070, 0.0715, 0.0355\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.1010, 0.0741, 0.0269\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0956, 0.0745, 0.0211\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0934, 0.0753, 0.0181\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0904, 0.0753, 0.0151\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0876, 0.0750, 0.0126\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0868, 0.0753, 0.0116\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0858, 0.0752, 0.0106\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0847, 0.0746, 0.0101\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0781, 0.0721, 0.0060\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0715, 0.0691, 0.0024\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0704, 0.0685, 0.0019\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0692, 0.0677, 0.0016\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0690, 0.0676, 0.0014\n",
            "Total_len exemplars old classes:2235\n",
            "iCaRL classes: 40\n",
            "Train Accuracy: 91.93, SVM Accuracy: 95.97\n",
            "Test Accuracy: 66.20, SVM Accuracy: 66.33\n",
            "M_old:750.0 - M_new:773.9475\n",
            "Total_len exemplars with new classes:3007\n",
            "\n",
            "\n",
            "Loading training examples for classes [82, 16, 72, 52, 60, 36, 14, 41, 73, 38]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "8007\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0923, 0.0707, 0.0217\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0870, 0.0715, 0.0155\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0846, 0.0726, 0.0120\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0826, 0.0728, 0.0098\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0815, 0.0727, 0.0088\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0803, 0.0730, 0.0073\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0801, 0.0729, 0.0072\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0790, 0.0727, 0.0063\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0798, 0.0731, 0.0067\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0741, 0.0708, 0.0033\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0693, 0.0677, 0.0015\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0687, 0.0674, 0.0013\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0677, 0.0666, 0.0010\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0679, 0.0669, 0.0011\n",
            "Total_len exemplars old classes:2421\n",
            "iCaRL classes: 50\n",
            "Train Accuracy: 91.61, SVM Accuracy: 95.45\n",
            "Test Accuracy: 63.38, SVM Accuracy: 63.74\n",
            "M_old:600.0 - M_new:606.7559999999999\n",
            "Total_len exemplars with new classes:3028\n",
            "\n",
            "\n",
            "Loading training examples for classes [79, 50, 94, 54, 42, 15, 87, 5, 75, 78]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "8028\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0985, 0.0786, 0.0199\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0929, 0.0795, 0.0134\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0899, 0.0799, 0.0100\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0886, 0.0802, 0.0084\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0877, 0.0805, 0.0072\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0861, 0.0801, 0.0060\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0852, 0.0797, 0.0055\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0853, 0.0798, 0.0055\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0854, 0.0801, 0.0053\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0798, 0.0771, 0.0027\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0766, 0.0755, 0.0011\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0758, 0.0748, 0.0010\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0751, 0.0743, 0.0009\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0750, 0.0741, 0.0009\n",
            "Total_len exemplars old classes:2522\n",
            "iCaRL classes: 60\n",
            "Train Accuracy: 90.58, SVM Accuracy: 94.01\n",
            "Test Accuracy: 60.33, SVM Accuracy: 60.97\n",
            "M_old:500.0 - M_new:505.51499999999993\n",
            "Total_len exemplars with new classes:3029\n",
            "\n",
            "\n",
            "Loading training examples for classes [35, 66, 99, 98, 3, 58, 77, 71, 23, 47]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "8029\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0881, 0.0718, 0.0163\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0848, 0.0729, 0.0119\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0841, 0.0738, 0.0103\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0827, 0.0741, 0.0086\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0810, 0.0741, 0.0068\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0809, 0.0742, 0.0067\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0800, 0.0743, 0.0057\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0795, 0.0740, 0.0054\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0784, 0.0738, 0.0046\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0756, 0.0725, 0.0031\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0717, 0.0705, 0.0013\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0708, 0.0697, 0.0011\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0703, 0.0694, 0.0009\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0701, 0.0692, 0.0009\n",
            "Total_len exemplars old classes:2601\n",
            "iCaRL classes: 70\n",
            "Train Accuracy: 87.72, SVM Accuracy: 93.71\n",
            "Test Accuracy: 56.76, SVM Accuracy: 56.92\n",
            "M_old:428.57142857142844 - M_new:424.7271428571429\n",
            "Total_len exemplars with new classes:3026\n",
            "\n",
            "\n",
            "Loading training examples for classes [18, 64, 97, 34, 56, 89, 85, 30, 9, 25]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "8026\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0889, 0.0754, 0.0136\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0862, 0.0766, 0.0096\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0843, 0.0770, 0.0073\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0836, 0.0774, 0.0062\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0828, 0.0774, 0.0054\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0808, 0.0768, 0.0040\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0814, 0.0771, 0.0042\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0813, 0.0774, 0.0039\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0804, 0.0769, 0.0035\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0773, 0.0754, 0.0019\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0748, 0.0739, 0.0009\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0742, 0.0734, 0.0008\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0737, 0.0730, 0.0007\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0736, 0.0729, 0.0007\n",
            "Total_len exemplars old classes:2637\n",
            "iCaRL classes: 80\n",
            "Train Accuracy: 88.28, SVM Accuracy: 91.91\n",
            "Test Accuracy: 53.92, SVM Accuracy: 54.17\n",
            "M_old:375.0 - M_new:372.31500000000005\n",
            "Total_len exemplars with new classes:3009\n",
            "\n",
            "\n",
            "Loading training examples for classes [70, 48, 57, 84, 92, 53, 67, 65, 10, 31]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "8009\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0872, 0.0746, 0.0126\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0845, 0.0756, 0.0089\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0828, 0.0759, 0.0069\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0812, 0.0758, 0.0054\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0809, 0.0763, 0.0046\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0799, 0.0758, 0.0041\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0807, 0.0764, 0.0043\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0790, 0.0757, 0.0033\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0795, 0.0759, 0.0037\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0760, 0.0745, 0.0015\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0736, 0.0728, 0.0008\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0733, 0.0725, 0.0007\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0729, 0.0723, 0.0006\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0729, 0.0723, 0.0006\n",
            "Total_len exemplars old classes:2651\n",
            "iCaRL classes: 90\n",
            "Train Accuracy: 86.72, SVM Accuracy: 92.51\n",
            "Test Accuracy: 50.88, SVM Accuracy: 50.95\n",
            "M_old:333.3333333333333 - M_new:342.5733333333333\n",
            "Total_len exemplars with new classes:2993\n",
            "\n",
            "\n",
            "Loading training examples for classes [88, 33, 4, 21, 74, 32, 62, 0, 55, 44]\n",
            "Batch size: 5000\n",
            "10 new classes\n",
            "5000\n",
            "7993\n",
            "TRAIN\n",
            "Epoch [5/70], Average_Loss(tot, dist, class): 0.0889, 0.0766, 0.0124\n",
            "Epoch [10/70], Average_Loss(tot, dist, class): 0.0868, 0.0777, 0.0091\n",
            "Epoch [15/70], Average_Loss(tot, dist, class): 0.0852, 0.0779, 0.0073\n",
            "Epoch [20/70], Average_Loss(tot, dist, class): 0.0846, 0.0783, 0.0063\n",
            "Epoch [25/70], Average_Loss(tot, dist, class): 0.0832, 0.0782, 0.0050\n",
            "Epoch [30/70], Average_Loss(tot, dist, class): 0.0826, 0.0782, 0.0044\n",
            "Epoch [35/70], Average_Loss(tot, dist, class): 0.0817, 0.0780, 0.0037\n",
            "Epoch [40/70], Average_Loss(tot, dist, class): 0.0822, 0.0781, 0.0040\n",
            "Epoch [45/70], Average_Loss(tot, dist, class): 0.0819, 0.0783, 0.0036\n",
            "Epoch [50/70], Average_Loss(tot, dist, class): 0.0786, 0.0767, 0.0019\n",
            "Epoch [55/70], Average_Loss(tot, dist, class): 0.0764, 0.0755, 0.0008\n",
            "Epoch [60/70], Average_Loss(tot, dist, class): 0.0758, 0.0750, 0.0007\n",
            "Epoch [65/70], Average_Loss(tot, dist, class): 0.0756, 0.0749, 0.0007\n",
            "Epoch [70/70], Average_Loss(tot, dist, class): 0.0754, 0.0748, 0.0006\n",
            "Total_len exemplars old classes:2672\n",
            "iCaRL classes: 100\n",
            "Train Accuracy: 86.44, SVM Accuracy: 90.44\n",
            "Test Accuracy: 47.90, SVM Accuracy: 48.44\n",
            "M_old:300.0 - M_new:302.13599999999997\n",
            "Total_len exemplars with new classes:2975\n",
            "[tensor(83.5938), tensor(75.0521), tensor(71.5693), tensor(66.2046), tensor(63.3814), tensor(60.3261), tensor(56.7564), tensor(53.9188), tensor(50.8817), tensor(47.8966)]\n",
            "Files already downloaded and verified\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 792x792 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Files already downloaded and verified\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 792x792 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}