modelzoo_minimal.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ModelZoo_minimal.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyN7SfFN0GhHqYClXUecIH6q",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rahul13ramesh/modelzoo_continual/blob/main/modelzoo_minimal.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# A minimal implementation of Model Zoo:\n",
        "\n",
        "This notebook is a minimal working example of [Model Zoo](https://arxiv.org/abs/2106.03027). It trains the Zoo in under 10 mins on 20 tasks from CIFAR100 constructed using the super-classes. Thanks to Ashwin (https://laknath1996.github.io/) for helping me with coding up this notebook."
      ],
      "metadata": {
        "id": "FQkdsVoRCwZA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XcE8vqqrYm8j"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import tqdm\n",
        "import torch.nn as nn\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.optim as optim\n",
        "\n",
        "from torch.utils.data import DataLoader\n",
        "from tqdm import tqdm\n",
        "from tabulate import tabulate"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dev = 'cuda'\n",
        "EPISODES = 15"
      ],
      "metadata": {
        "id": "NgReWbR2zP4r"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Constructing Tasks from CIFAR100"
      ],
      "metadata": {
        "id": "XYB2UV95IClP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We first create the dataloaders for each from Coarse-CIFAR100 benchmark."
      ],
      "metadata": {
        "id": "qYGPaj_nEzUy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Download dataset\n",
        "_ = torchvision.datasets.CIFAR100(root='./data', train=True, download=True)\n",
        "_ = torchvision.datasets.CIFAR100(root='./data', train=False, download=True)\n",
        "\n",
        "coarse_cifar100 = [[4, 30, 55, 72, 95],  [1, 32, 67, 73, 91],\n",
        "                   [54, 62, 70, 82, 92], [9, 10, 16, 28, 61],\n",
        "                   [0, 51, 53, 57, 83],  [22, 39, 40, 86, 87],\n",
        "                   [5, 20, 25, 84, 94],  [6, 7, 14, 18, 24],\n",
        "                   [3, 42, 43, 88, 97],  [12, 17, 37, 68, 76],\n",
        "                   [23, 33, 49, 60, 71], [15, 19, 21, 31, 38],\n",
        "                   [34, 63, 64, 66, 75], [26, 45, 77, 79, 99],\n",
        "                   [2, 11, 35, 46, 98],  [27, 29, 44, 78, 93],\n",
        "                   [36, 50, 65, 74, 80], [47, 52, 56, 59, 96],\n",
        "                   [8, 13, 48, 58, 90],  [41, 69, 81, 85, 89]]\n",
        "\n",
        "task_names = [\"Aq. Mammals\", \"Fish\",\n",
        "              \"Flowers\", \"Food Container\",\n",
        "              \"Fruits and Veggies\", \"Electrical Devices\",\n",
        "              \"Household Furniture\", \"Insects\", \n",
        "              \"Large Carnivores\", \"Man-made Outdoor\",\n",
        "              \"Natural Outdoor\", \"Omni-Herbivores\",\n",
        "              \"Med. Mammals\", \"Invertebrates\",\n",
        "              \"People\", \"Reptiles\",\n",
        "              \"Small Mammals\", \"Trees\",\n",
        "              \"Vehicles 1\", \"Vehicles 2\"]\n",
        "\n",
        "# Map each cifar100 label -> (task, task-label)\n",
        "tmap, cmap = {}, {}\n",
        "for tid, task in enumerate(coarse_cifar100):\n",
        "    for lid, lab in enumerate(task):\n",
        "        tmap[lab], cmap[lab] = tid, lid\n",
        "\n",
        "def create_cifar100_task(tasks, train=True, shuffle=False, bs=256):\n",
        "    # Don't use CIFAR10 mean/std to avoid leaking info \n",
        "    # Instead use (mean, std) of (0.5, 0.25)\n",
        "    transform = transforms.Compose([\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.5, 0.5, 0.5], [0.25, 0.25, 0.25]),\n",
        "    ])\n",
        "    dataset = torchvision.datasets.CIFAR100(\n",
        "        root='./data', train=train, download=False, transform=transform)\n",
        " \n",
        "    # Select a subset of the data-points, depending on the task\n",
        "    task_labels = []\n",
        "    for task_id in tasks:\n",
        "        task_labels += coarse_cifar100[task_id]\n",
        "    idx = np.where(np.isin(dataset.targets, task_labels))[0]\n",
        "    \n",
        "    dataset.targets = [(tmap[dataset.targets[j]], cmap[dataset.targets[j]]) for j in idx]\n",
        "    dataset.data = dataset.data[idx]\n",
        "    \n",
        "    # Create dataloader. Set workers to 0, since too few batches\n",
        "    dataloader = DataLoader(\n",
        "        dataset, batch_size=bs, shuffle=shuffle,\n",
        "        num_workers=0, pin_memory=True)\n",
        "    \n",
        "    return dataloader\n",
        "\n",
        "# Create dataloaders for each task\n",
        "train_loaders = []\n",
        "test_loaders = []\n",
        "\n",
        "for i in range(20):\n",
        "    train_loaders.append(create_cifar100_task([i], train=True))\n",
        "    test_loaders.append(create_cifar100_task([i], train=False))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ulHAExPBijRj",
        "outputId": "e5218987-5ca9-4c25-9ee0-6b9c5e922900"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We store the output_label for every task into one matrix. This makes is easier later on to compute the loss/accuracy on all tasks."
      ],
      "metadata": {
        "id": "Fx4GrVE-FWRL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "all_targets = []\n",
        "\n",
        "for i in range(20):\n",
        "    all_targets.append([])\n",
        "    for loader in [train_loaders[i], test_loaders[i]]:\n",
        "        task_targets = []\n",
        "        for dat, target in loader:\n",
        "            task_targets.append(target[1].numpy())\n",
        "        task_targets = np.concatenate(task_targets)\n",
        "        all_targets[i].append(task_targets)      "
      ],
      "metadata": {
        "id": "MSNUmTXzi6L3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Building the Model Zoo"
      ],
      "metadata": {
        "id": "LoGzK8n8H5BW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Every model in the Model Zoo is a small convolution network with 0.1M parameters. Even this sufficies for SOTA performance on continual learning benchmarks. "
      ],
      "metadata": {
        "id": "VWOdj_SDF1HF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SmallConv(nn.Module):\n",
        "    # Small convolution network\n",
        "    def __init__(self, channels=3, avg_pool=2, lin_size=320):\n",
        "        super(SmallConv, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(channels, 80, kernel_size=3, bias=False)\n",
        "        self.conv2 = nn.Conv2d(80, 80, kernel_size=3)\n",
        "        self.bn2 = nn.BatchNorm2d(80)\n",
        "        self.conv3 = nn.Conv2d(80, 80, kernel_size=3)\n",
        "        self.bn3 = nn.BatchNorm2d(80)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.maxpool = nn.MaxPool2d(avg_pool)\n",
        "        self.fc = nn.Linear(lin_size, 100)\n",
        "        self.linsize = lin_size\n",
        "\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Linear):\n",
        "                m.bias.data.zero_()\n",
        "\n",
        "    def forward(self, x, tasks):\n",
        "        x = self.conv1(x)\n",
        "        x = self.maxpool(self.relu(x))\n",
        "        x = self.conv2(x)\n",
        "        x = self.maxpool(self.relu(self.bn2(x)))\n",
        "        x = self.conv3(x)\n",
        "        x = self.maxpool(self.relu(self.bn3(x)))\n",
        "        x = x.view(-1, self.linsize)\n",
        "        logits = self.fc(x)\n",
        "        logits = logits.reshape(-1, 20, 5)\n",
        "        # Select only relevant logits based on task\n",
        "        logits = logits[torch.arange(logits.size(0)), list(tasks), :]\n",
        "        return logits"
      ],
      "metadata": {
        "id": "RRGXJLInik7B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "We define the following functions that help us construct the Model Zoo:\n",
        "\n",
        "1. Sample a set of tasks with high training loss\n",
        "2. Train a model on these tasks\n",
        "3. Add model to the zoo\n",
        "4. Evaluate the zoo and compute the training loss of each task for the next iteration"
      ],
      "metadata": {
        "id": "0OcbOimfGGjj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def process_dat(dat, target):\n",
        "    # Helper function to push data to gpu\n",
        "    dat = dat.to(dev)\n",
        "    tasks, labels = target\n",
        "    labels = labels.long().to(dev)\n",
        "    tasks = tasks.long().to(dev)\n",
        "    return dat, labels, tasks\n",
        "\n",
        "\n",
        "def sample_task(train_losses, episode, bb):\n",
        "    # Samples \"bb\" tasks to train on\n",
        "    bb = min(bb, episode+1)\n",
        "\n",
        "    if episode == 0:\n",
        "        return [0]\n",
        "\n",
        "    prob = (train_losses - np.mean(train_losses)) / np.mean(train_losses)\n",
        "    prob = np.exp(prob).clip(0.0001, 1000)\n",
        "    prob = prob / np.sum(prob)\n",
        "\n",
        "    tasks = list(np.random.choice(episode, bb-1, replace=False, p=prob))\n",
        "    tasks.append(episode) # Add the newest task to the list\n",
        "    tasks = [int(t) for t in tasks]\n",
        "    return tasks\n",
        "\n",
        "def train_model(tasks, epochs):\n",
        "    # Train a single model on the Model Zoo\n",
        "    net = SmallConv()\n",
        "    if dev != 'cpu':\n",
        "        net.cuda()\n",
        "    \n",
        "    # No cosine-annlealing, fp16, small batch-size\n",
        "    # This leads to worse accuracies, but leads to simpler/faster code\n",
        "    mttask_loader = create_cifar100_task(tasks, shuffle=True, bs=32)\n",
        "    optimizer = optim.SGD(net.parameters(), lr=0.01,momentum=0.9,\n",
        "                          nesterov=True,weight_decay=0.00001)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "    net.train()\n",
        "    for ep in tqdm(range(epochs)):\n",
        "        for dat, target in mttask_loader:\n",
        "            optimizer.zero_grad()\n",
        "            dat, labels, tasks = process_dat(dat, target)\n",
        "            out = net(dat, tasks)\n",
        "            loss = criterion(out, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "    return net\n",
        "\n",
        "\n",
        "def update_zoo(net, tasks, zoo_outputs):\n",
        "    # Instead of storing the new network into the model zoo, we store all\n",
        "    # outputs of the network for faster run-times\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    net.eval()\n",
        "\n",
        "    with torch.inference_mode():\n",
        "        for tid in tasks:\n",
        "            for idx, dataloader in enumerate([train_loaders[tid], test_loaders[tid]]):\n",
        "                outputs = []\n",
        "                for dat, target in dataloader:\n",
        "                    dat, labels, tasks = process_dat(dat, target)\n",
        "                    out = net(dat, tasks)\n",
        "                    out = nn.functional.softmax(out, dim=1)\n",
        "                    out = out.cpu().detach().numpy()\n",
        "                    outputs.append(out)\n",
        "                outputs = np.concatenate(outputs)\n",
        "                zoo_outputs[tid][idx].append(outputs)\n",
        "\n",
        "\n",
        "def evaluate_zoo(episode, zoo_outputs):\n",
        "    # Evaluate the entire model zoo and all tasks seen until current episode\n",
        "    criterion = nn.NLLLoss()\n",
        "    met = {\"train_loss\": [], \"test_loss\": [], \"train_acc\": [], \"test_acc\":[]}\n",
        "\n",
        "    for tid in range(episode+1):\n",
        "        train_preds = np.mean(zoo_outputs[tid][0], axis=0)\n",
        "        test_preds = np.mean(zoo_outputs[tid][1], axis=0)\n",
        "\n",
        "        tr_loss = criterion(torch.Tensor(train_preds).log(),\n",
        "                            torch.Tensor(all_targets[tid][0]).long())\n",
        "        te_loss = criterion(torch.Tensor(test_preds).log(),\n",
        "                            torch.Tensor(all_targets[tid][1]).long())\n",
        " \n",
        "        met[\"train_loss\"].append(tr_loss.item())\n",
        "        met[\"test_loss\"].append(te_loss.item())\n",
        "        met[\"train_acc\"].append((train_preds.argmax(1) == all_targets[tid][0]).mean())\n",
        "        met[\"test_acc\"].append((test_preds.argmax(1) == all_targets[tid][1]).mean())\n",
        "\n",
        "    return met\n",
        "\n"
      ],
      "metadata": {
        "id": "cW6HbaiwmHlR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def run_zoo(bb=5, epochs=50):\n",
        "    zoo_outputs = {}\n",
        "    zoo_log = {}\n",
        "    train_losses = []\n",
        "    for ep in range(EPISODES):\n",
        "        print(\"Epsisode \" + str(ep))\n",
        "        zoo_outputs[ep] = [[], []]  \n",
        "        tasks = sample_task(train_losses, ep, bb)\n",
        "    \n",
        "        print(\"Training model on tasks: \" + str(tasks))\n",
        "        model = train_model(tasks, epochs)\n",
        "        update_zoo(model, tasks, zoo_outputs)\n",
        "        zoo_log[ep] = evaluate_zoo(ep, zoo_outputs)\n",
        "        train_losses = zoo_log[ep][\"train_loss\"]\n",
        "        print(\"Test Accuracies of the zoo:\\n  %s\\n\" % str(zoo_log[ep]['test_acc']))\n",
        "    return zoo_log"
      ],
      "metadata": {
        "id": "NKFrZnt_1zWL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, we train Model Zoo and Isolated. 5 epochs of training leads to under-trained models but it is sufficient to demonstrate the efficacy of Model Zoo. "
      ],
      "metadata": {
        "id": "hP7CS-BQHY-K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zoo_log = run_zoo(bb=5, epochs=5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xbqlqw9Br0qr",
        "outputId": "29e138e2-a506-4729-8476-9164bad1508e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epsisode 0\n",
            "Training model on tasks: [0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.29s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.524]\n",
            "\n",
            "Epsisode 1\n",
            "Training model on tasks: [0, 1]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:13<00:00,  2.60s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.556, 0.7]\n",
            "\n",
            "Epsisode 2\n",
            "Training model on tasks: [1, 0, 2]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:19<00:00,  3.86s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.544, 0.714, 0.576]\n",
            "\n",
            "Epsisode 3\n",
            "Training model on tasks: [1, 2, 0, 3]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:26<00:00,  5.36s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.568, 0.732, 0.662, 0.666]\n",
            "\n",
            "Epsisode 4\n",
            "Training model on tasks: [2, 1, 0, 3, 4]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.54s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.578, 0.734, 0.698, 0.704, 0.714]\n",
            "\n",
            "Epsisode 5\n",
            "Training model on tasks: [0, 1, 4, 3, 5]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.52s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.578, 0.736, 0.698, 0.724, 0.754, 0.692]\n",
            "\n",
            "Epsisode 6\n",
            "Training model on tasks: [5, 2, 3, 4, 6]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.48s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.578, 0.736, 0.68, 0.74, 0.764, 0.724, 0.658]\n",
            "\n",
            "Epsisode 7\n",
            "Training model on tasks: [5, 6, 4, 0, 7]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.59s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.58, 0.736, 0.68, 0.74, 0.77, 0.724, 0.702, 0.718]\n",
            "\n",
            "Epsisode 8\n",
            "Training model on tasks: [1, 6, 0, 3, 8]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.50s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.58, 0.742, 0.68, 0.736, 0.77, 0.724, 0.68, 0.718, 0.692]\n",
            "\n",
            "Epsisode 9\n",
            "Training model on tasks: [0, 5, 2, 6, 9]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.49s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.59, 0.742, 0.694, 0.736, 0.77, 0.726, 0.69, 0.718, 0.692, 0.722]\n",
            "\n",
            "Epsisode 10\n",
            "Training model on tasks: [0, 2, 3, 8, 10]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.42s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.588, 0.742, 0.706, 0.742, 0.77, 0.726, 0.69, 0.718, 0.708, 0.722, 0.766]\n",
            "\n",
            "Epsisode 11\n",
            "Training model on tasks: [0, 6, 10, 3, 11]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.42s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.59, 0.742, 0.706, 0.738, 0.77, 0.726, 0.704, 0.718, 0.708, 0.722, 0.794, 0.64]\n",
            "\n",
            "Epsisode 12\n",
            "Training model on tasks: [3, 11, 0, 8, 12]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.41s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.594, 0.742, 0.706, 0.746, 0.77, 0.726, 0.704, 0.718, 0.73, 0.722, 0.794, 0.676, 0.728]\n",
            "\n",
            "Epsisode 13\n",
            "Training model on tasks: [0, 5, 6, 2, 13]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.45s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.596, 0.742, 0.702, 0.746, 0.77, 0.72, 0.702, 0.718, 0.73, 0.722, 0.794, 0.676, 0.728, 0.656]\n",
            "\n",
            "Epsisode 14\n",
            "Training model on tasks: [1, 0, 11, 12, 14]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:32<00:00,  6.44s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.582, 0.74, 0.702, 0.746, 0.77, 0.72, 0.702, 0.718, 0.73, 0.722, 0.794, 0.672, 0.72, 0.656, 0.388]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "isolated_log = run_zoo(bb=1, epochs=5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fZ5Rt6pRzp0s",
        "outputId": "f3e319ac-d9ad-4de7-f8be-b05c2de8e6fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epsisode 0\n",
            "Training model on tasks: [0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55]\n",
            "\n",
            "Epsisode 1\n",
            "Training model on tasks: [1]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.32s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704]\n",
            "\n",
            "Epsisode 2\n",
            "Training model on tasks: [2]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.31s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608]\n",
            "\n",
            "Epsisode 3\n",
            "Training model on tasks: [3]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.32s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688]\n",
            "\n",
            "Epsisode 4\n",
            "Training model on tasks: [4]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.31s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688]\n",
            "\n",
            "Epsisode 5\n",
            "Training model on tasks: [5]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69]\n",
            "\n",
            "Epsisode 6\n",
            "Training model on tasks: [6]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586]\n",
            "\n",
            "Epsisode 7\n",
            "Training model on tasks: [7]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.31s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708]\n",
            "\n",
            "Epsisode 8\n",
            "Training model on tasks: [8]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69]\n",
            "\n",
            "Epsisode 9\n",
            "Training model on tasks: [9]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.31s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724]\n",
            "\n",
            "Epsisode 10\n",
            "Training model on tasks: [10]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.31s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724, 0.694]\n",
            "\n",
            "Epsisode 11\n",
            "Training model on tasks: [11]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724, 0.694, 0.614]\n",
            "\n",
            "Epsisode 12\n",
            "Training model on tasks: [12]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724, 0.694, 0.614, 0.704]\n",
            "\n",
            "Epsisode 13\n",
            "Training model on tasks: [13]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.32s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724, 0.694, 0.614, 0.704, 0.658]\n",
            "\n",
            "Epsisode 14\n",
            "Training model on tasks: [14]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:06<00:00,  1.30s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracies of the zoo:\n",
            "  [0.55, 0.704, 0.608, 0.688, 0.688, 0.69, 0.586, 0.708, 0.69, 0.724, 0.694, 0.614, 0.704, 0.658, 0.354]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Evaluating Model Zoo"
      ],
      "metadata": {
        "id": "-a-9sXZ3GS-I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_avg(run_log):\n",
        "    # Avg. Accuracy at the end of all episodes\n",
        "    return np.mean(run_log[EPISODES-1]['test_acc'])\n",
        "\n",
        "def get_fwd(run_log):\n",
        "    # Compute the learning accuracy (Reimer et al.) -- the accuracy when task \n",
        "    # is first seen.\n",
        "    learning_acc = []\n",
        "    for ep in range(EPISODES):\n",
        "        learning_acc.append(run_log[ep]['test_acc'][-1])\n",
        "    return np.mean(learning_acc), learning_acc\n",
        "\n",
        "def get_bwd(run_log):\n",
        "    # Compute the forgetting (max_acc - final acc)\n",
        "    max_acc = []\n",
        "    for task in range(EPISODES):\n",
        "        maxval = 0.0\n",
        "        for ep in range(task, EPISODES):\n",
        "            maxval = max(run_log[ep]['test_acc'][task], maxval)\n",
        "        max_acc.append(maxval)\n",
        "    return np.mean(np.array(max_acc) - np.array(run_log[EPISODES-1]['test_acc']))"
      ],
      "metadata": {
        "id": "5oaqTx4pGR--"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Model Zoo shows forward and backward transfer while showing minimal forgetting on all tasks. "
      ],
      "metadata": {
        "id": "yG75KTsUUJ6h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "table = []\n",
        "table.append([\"Avg task Acc at the end\", get_avg(isolated_log), get_avg(zoo_log)])\n",
        "table.append([\"Learning accuracy (forward transfer)\", get_fwd(isolated_log)[0], get_fwd(zoo_log)[0]])\n",
        "table.append([\"Forgetting (backward transfer)\", get_bwd(isolated_log), get_bwd(zoo_log)])\n",
        "\n",
        "print(tabulate(table, headers = ['metric', 'Isolated', 'zoo']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mt6lQMmp27Si",
        "outputId": "b2113151-5e9f-475c-c0a7-788d7ce0366f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "metric                                  Isolated         zoo\n",
            "------------------------------------  ----------  ----------\n",
            "Avg task Acc at the end                    0.644  0.6908\n",
            "Learning accuracy (forward transfer)       0.644  0.656\n",
            "Forgetting (backward transfer)             0      0.00266667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.style.use('seaborn-whitegrid')\n",
        "\n",
        "def make_plot(run_log, title='Evolution of Task Accuracies'):\n",
        "    for task in range(EPISODES):\n",
        "        task_acc = []\n",
        "        for ep in range(task, EPISODES):\n",
        "            task_acc.append(run_log[ep]['test_acc'][task] * 100)\n",
        "        plt.plot(range(task+1, EPISODES+1), task_acc, color=plt.cm.tab20(task))\n",
        "        plt.scatter(range(task+1, EPISODES+1), task_acc, color=plt.cm.tab20(task))\n",
        "    plt.title(title)\n",
        "    plt.ylabel('Task Accuracy')\n",
        "    plt.xlabel('Episode')\n",
        "    plt.ylim([40, 90])\n",
        "    plt.legend(task_names[:EPISODES], bbox_to_anchor = (1.05, 1.05), title='task')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "DCXV_qOjH_4z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Model Zoo improves on past tasks. For example *Aq. Mammals* and *Fish* improve their accuracy with more episodes. It also has an improved ability to learn new tasks. For example *Household Furniture* has an accuracy ~60% for Isolated, while Model Zoo starts with an accuracy close to ~65%. Hence Model Zoo shows forward and backward transfer."
      ],
      "metadata": {
        "id": "6rwSRwd7IY_4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "make_plot(isolated_log, title='Isolated')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 291
        },
        "id": "309bj4bQebdI",
        "outputId": "cad13460-84c1-42d5-c4ae-dbd6139894d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "make_plot(zoo_log, title='Model Zoo')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 291
        },
        "id": "KTWAt2knIHTp",
        "outputId": "0e6008c9-5170-44a4-eeee-d3a330dc1740"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}