mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Supermasks in Superposition: Training and Task Inference\n",
    "\n",
    "<img src=\"images/teaser_supsup.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.autograd as autograd\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import torchvision\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "We train our model using the procedure from \"What's Hidden in a Randomly Weighted Neural Network\" (Ramanujan et al. 2019). Below is a modification of the layers (using signed constant initialization) from this paper for our continual learning setup. As a deviation from this setup, we assume that an edge (u, v) is included in the subnetwork if its score is greater than 0, rather than use it's absolute magnitude to construct a threshold. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subnetwork forward from hidden networks\n",
    "class GetSubnet(autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, scores):\n",
    "        return (scores >= 0).float()\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, g):\n",
    "        # send the gradient g straight-through on the backward pass.\n",
    "        return g\n",
    "\n",
    "\n",
    "def mask_init(module):\n",
    "    scores = torch.Tensor(module.weight.size())\n",
    "    nn.init.kaiming_uniform_(scores, a=math.sqrt(5))\n",
    "    return scores\n",
    "\n",
    "\n",
    "def signed_constant(module):\n",
    "    fan = nn.init._calculate_correct_fan(module.weight, 'fan_in')\n",
    "    gain = nn.init.calculate_gain('relu')\n",
    "    std = gain / math.sqrt(fan)\n",
    "    module.weight.data = module.weight.data.sign() * std\n",
    "\n",
    "\n",
    "class MultitaskMaskLinear(nn.Linear):\n",
    "    def __init__(self, *args, num_tasks=1, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        self.num_tasks = num_tasks\n",
    "        self.scores = nn.ParameterList(\n",
    "            [\n",
    "                nn.Parameter(mask_init(self))\n",
    "                for _ in range(num_tasks)\n",
    "            ]\n",
    "        )\n",
    "        \n",
    "        # Keep weights untrained\n",
    "        self.weight.requires_grad = False\n",
    "        signed_constant(self)\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def cache_masks(self):\n",
    "        self.register_buffer(\n",
    "            \"stacked\",\n",
    "            torch.stack(\n",
    "                [\n",
    "                    GetSubnet.apply(self.scores[j])\n",
    "                    for j in range(self.num_tasks)\n",
    "                ]\n",
    "            ),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.task < 0:\n",
    "            # Superimposed forward pass\n",
    "            alpha_weights = self.alphas[: self.num_tasks_learned]\n",
    "            idxs = (alpha_weights > 0).squeeze().view(self.num_tasks_learned)\n",
    "            if len(idxs.shape) == 0:\n",
    "                idxs = idxs.view(1)\n",
    "            subnet = (\n",
    "                alpha_weights[idxs]\n",
    "                * self.stacked[: self.num_tasks_learned][idxs]\n",
    "            ).sum(dim=0)\n",
    "        else:\n",
    "            # Subnet forward pass (given task info in self.task)\n",
    "            subnet = GetSubnet.apply(self.scores[self.task])\n",
    "        w = self.weight * subnet\n",
    "        x = F.linear(x, w, self.bias)\n",
    "        return x\n",
    "\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"MultitaskMaskLinear({self.in_dims}, {self.out_dims})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utility functions\n",
    "def set_model_task(model, task, verbose=True):\n",
    "    for n, m in model.named_modules():\n",
    "        if isinstance(m, MultitaskMaskLinear):\n",
    "            if verbose:\n",
    "                print(f\"=> Set task of {n} to {task}\")\n",
    "            m.task = task\n",
    "\n",
    "def cache_masks(model):\n",
    "    for n, m in model.named_modules():\n",
    "        if isinstance(m, MultitaskMaskLinear):\n",
    "            print(f\"=> Caching mask state for {n}\")\n",
    "            m.cache_masks()\n",
    "\n",
    "def set_num_tasks_learned(model, num_tasks_learned):\n",
    "    for n, m in model.named_modules():\n",
    "        if isinstance(m, MultitaskMaskLinear):\n",
    "            print(f\"=> Setting learned tasks of {n} to {num_tasks_learned}\")\n",
    "            m.num_tasks_learned = num_tasks_learned\n",
    "\n",
    "def set_alphas(model, alphas, verbose=True):\n",
    "    for n, m in model.named_modules():\n",
    "        if isinstance(m, MultitaskMaskLinear):\n",
    "            if verbose:\n",
    "                print(f\"=> Setting alphas for {n}\")\n",
    "            m.alphas = alphas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model\n",
    "\n",
    "For simplicity we use a simple 3-layer fully connected neural network. Note that you can make any neural by replacing a standard layer with its corresponding mask layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multitask Model, a simple fully connected model in this case\n",
    "class MultitaskFC(nn.Module):\n",
    "    def __init__(self, hidden_size, num_tasks):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            MultitaskMaskLinear(\n",
    "                784,\n",
    "                hidden_size,\n",
    "                num_tasks=num_tasks,\n",
    "                bias=False\n",
    "            ),\n",
    "            nn.ReLU(),\n",
    "            MultitaskMaskLinear(\n",
    "                hidden_size,\n",
    "                hidden_size,\n",
    "                num_tasks=num_tasks,\n",
    "                bias=False\n",
    "            ),\n",
    "            nn.ReLU(),\n",
    "            MultitaskMaskLinear(\n",
    "                hidden_size,\n",
    "                100,\n",
    "                num_tasks=num_tasks,\n",
    "                bias=False\n",
    "            )\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.model(x.flatten(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset \n",
    "\n",
    "Our \"base\" dataset is MNIST. Each task is a random permutation of the pixels of MNIST. Namely, given a dataset $\\{(x_i, y_i)\\}_i$ for each task $t$, we take a random permutation $S^t\\in S_{784}$ and construct a dataset $\\{(S^t(x_i), y_i)\\}_i$. \n",
    "\n",
    "Below we show this process and an example of a particular task. `MNISTPerm` uses an update task method to generate a particular sub-task. To assure these splits are reproducible, `MNISTPerm` takes a `seed` argument. In our paper we evaluate on seeds 0 through 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=493x269 at 0x12920C050>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MNISTPerm:\n",
    "    class permute(object):\n",
    "        def __call__(self, tensor):\n",
    "            out = tensor.flatten()\n",
    "            out = out[self.perm]\n",
    "            return out.view(1, 28, 28)\n",
    "\n",
    "        def __repr__(self):\n",
    "            return self.__class__.__name__\n",
    "\n",
    "    def __init__(self, seed=0):\n",
    "        super(MNISTPerm, self).__init__()\n",
    "        \n",
    "        data_root = \"mnist\"\n",
    "        self.permuter = self.permute()\n",
    "        self.seed = seed\n",
    "        train_dataset = torchvision.datasets.MNIST(\n",
    "            data_root,\n",
    "            train=True,\n",
    "            download=True,\n",
    "            transform=torchvision.transforms.Compose(\n",
    "                [\n",
    "                    torchvision.transforms.ToTensor(),\n",
    "                    torchvision.transforms.Normalize((0.1307,), (0.3081,)),\n",
    "                    self.permuter,\n",
    "                ]\n",
    "            ),\n",
    "        )\n",
    "\n",
    "        # Data loading code\n",
    "        self.train_loader = torch.utils.data.DataLoader(\n",
    "            train_dataset, batch_size=128, shuffle=True\n",
    "        )\n",
    "        self.val_loader = torch.utils.data.DataLoader(\n",
    "            torchvision.datasets.MNIST(\n",
    "                data_root,\n",
    "                train=False,\n",
    "                transform=torchvision.transforms.Compose(\n",
    "                    [\n",
    "                        torchvision.transforms.ToTensor(),\n",
    "                        torchvision.transforms.Normalize((0.1307,), (0.3081,)),\n",
    "                        self.permuter,\n",
    "                    ]\n",
    "                ),\n",
    "            ),\n",
    "            batch_size=128,\n",
    "            shuffle=False,\n",
    "        )\n",
    "\n",
    "    def update_task(self, i):\n",
    "        np.random.seed(i + self.seed)\n",
    "        self.permuter.__setattr__(\"perm\", np.random.permutation(784))\n",
    "    \n",
    "    def unpermute(self):\n",
    "        self.permuter.__setattr__(\"perm\", np.arange(784))\n",
    "\n",
    "mnist = MNISTPerm()\n",
    "\n",
    "# Showing some example images from MNISTPerm\n",
    "mnist.unpermute()\n",
    "batch, labels = next(iter(mnist.val_loader))\n",
    "\n",
    "mnist.update_task(0)\n",
    "task0, labels = next(iter(mnist.val_loader))\n",
    "\n",
    "torchvision.transforms.ToPILImage()(\n",
    "    torchvision.utils.make_grid(\n",
    "        torch.cat([batch, task0], dim=-1)[:64],\n",
    "        normalize=True,\n",
    "        padding=5,\n",
    "        pad_value=0.2\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple train and evaluation loops for classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finding supermasks per task\n",
    "\n",
    "def train(model, trainloader, optimizer, epoch):\n",
    "    model.train()\n",
    "\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    num_correct = 0\n",
    "    total_seen = 0\n",
    "    for i, (batch, labels) in tqdm(\n",
    "        enumerate(trainloader),\n",
    "        ascii=True,\n",
    "        total=len(trainloader)\n",
    "    ):\n",
    "        logits = model(batch)\n",
    "        loss = criterion(logits, labels)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if i % 20 == 0:\n",
    "            predictions = logits.argmax(dim=-1)\n",
    "            num_correct += (predictions == labels).float().sum()\n",
    "            total_seen += logits.size(0) \n",
    "            tqdm.write(\n",
    "                (f\"e{epoch} {i+1}/{len(trainloader)}\"\n",
    "                f\" => Loss {loss.item():0.4f}, \"\n",
    "                f\"Acc@1 {(num_correct / total_seen):0.4f}\"),\n",
    "                end=\"\\r\"\n",
    "            )\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluate(model, val_loader, epoch):\n",
    "    model.eval()\n",
    "    num_correct = 0\n",
    "    total_seen = 0\n",
    "    for batch, labels in tqdm(\n",
    "        val_loader,\n",
    "        ascii=True,\n",
    "        total=len(val_loader)\n",
    "    ):\n",
    "        logits = model(batch)\n",
    "        predictions = logits.argmax(dim=-1)\n",
    "        num_correct += (predictions == labels).float().sum()\n",
    "        total_seen += logits.size(0) \n",
    "    \n",
    "\n",
    "    tqdm.write(\n",
    "        f\"Val Perf after {epoch + 1} epochs \"\n",
    "        f\"Acc@1 {(num_correct / total_seen):0.4f}\", \n",
    "    )\n",
    "    return num_correct / total_seen\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For any scenario where task ID is given during train time, we simply train each supermask independently, one per task. We make use of our utility function `set_model_task` to do this. We use 5 tasks for demonstration purposes. Feel free to increase `num_tasks` in the following cell. In our paper we use as many as 2500 tasks with no drop in performance for either task inference or validation accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for task 0\n",
      "=> Set task of model.0 to 0\n",
      "=> Set task of model.2 to 0\n",
      "=> Set task of model.4 to 0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "23880cbff80a456397c9605c4c80d4ff",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=469), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e0 461/469 => Loss 0.2461, Acc@1 0.8532\n",
      "Validation\n",
      "============\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "477a36924af643aaa3413f0f9c0c6414",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=79), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\r",
      "\r",
      "\r",
      "Val Perf after 1 epochs Acc@1 0.9191\n",
      "=> Caching mask state for model.0\n",
      "=> Caching mask state for model.2\n",
      "=> Caching mask state for model.4\n",
      "\n",
      "=> Setting learned tasks of model.0 to 1\n",
      "=> Setting learned tasks of model.2 to 1\n",
      "=> Setting learned tasks of model.4 to 1\n",
      "\n",
      "Training for task 1\n",
      "=> Set task of model.0 to 1\n",
      "=> Set task of model.2 to 1\n",
      "=> Set task of model.4 to 1\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cfeccf293cd2471584f384d2b1fcb6c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=469), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e0 461/469 => Loss 0.2363, Acc@1 0.8506\n",
      "Validation\n",
      "============\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "032a38fd2ad849d2a1531d679990a122",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=79), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\r",
      "\r",
      "\r",
      "Val Perf after 1 epochs Acc@1 0.9292\n",
      "=> Caching mask state for model.0\n",
      "=> Caching mask state for model.2\n",
      "=> Caching mask state for model.4\n",
      "\n",
      "=> Setting learned tasks of model.0 to 2\n",
      "=> Setting learned tasks of model.2 to 2\n",
      "=> Setting learned tasks of model.4 to 2\n",
      "\n",
      "Training for task 2\n",
      "=> Set task of model.0 to 2\n",
      "=> Set task of model.2 to 2\n",
      "=> Set task of model.4 to 2\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "76563244f8cb4e1a9e6019287310539a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=469), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e0 461/469 => Loss 0.2814, Acc@1 0.8574\n",
      "Validation\n",
      "============\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b7a97a706e2843f8b7b861b5b5e1187b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=79), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\r",
      "\r",
      "\r",
      "Val Perf after 1 epochs Acc@1 0.9225\n",
      "=> Caching mask state for model.0\n",
      "=> Caching mask state for model.2\n",
      "=> Caching mask state for model.4\n",
      "\n",
      "=> Setting learned tasks of model.0 to 3\n",
      "=> Setting learned tasks of model.2 to 3\n",
      "=> Setting learned tasks of model.4 to 3\n",
      "\n",
      "Training for task 3\n",
      "=> Set task of model.0 to 3\n",
      "=> Set task of model.2 to 3\n",
      "=> Set task of model.4 to 3\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ecb30db53374429a569aeb307756013",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=469), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e0 461/469 => Loss 0.2601, Acc@1 0.8496\n",
      "Validation\n",
      "============\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a522435738654c99b6019c840c580c3c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=79), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\r",
      "\r",
      "\r",
      "Val Perf after 1 epochs Acc@1 0.9207\n",
      "=> Caching mask state for model.0\n",
      "=> Caching mask state for model.2\n",
      "=> Caching mask state for model.4\n",
      "\n",
      "=> Setting learned tasks of model.0 to 4\n",
      "=> Setting learned tasks of model.2 to 4\n",
      "=> Setting learned tasks of model.4 to 4\n",
      "\n",
      "Training for task 4\n",
      "=> Set task of model.0 to 4\n",
      "=> Set task of model.2 to 4\n",
      "=> Set task of model.4 to 4\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5ee9eb79699a485a935e518f0b0b2bdc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=469), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e0 461/469 => Loss 0.2476, Acc@1 0.8669\n",
      "Validation\n",
      "============\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "67b4290da216426bb5b419efe487efef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=79), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\r",
      "\r",
      "\r",
      "Val Perf after 1 epochs Acc@1 0.9269\n",
      "=> Caching mask state for model.0\n",
      "=> Caching mask state for model.2\n",
      "=> Caching mask state for model.4\n",
      "\n",
      "=> Setting learned tasks of model.0 to 5\n",
      "=> Setting learned tasks of model.2 to 5\n",
      "=> Setting learned tasks of model.4 to 5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Task ID given during train time\n",
    "from IPython.display import clear_output\n",
    "\n",
    "num_tasks = 5 # For demonstration purposes, we go up to 2500 in our paper\n",
    "model = MultitaskFC(hidden_size=300, num_tasks=num_tasks)\n",
    "\n",
    "for task in range(5):\n",
    "    print(f\"Training for task {task}\")\n",
    "    set_model_task(model, task)\n",
    "    mnist.update_task(task)\n",
    "\n",
    "    optimizer = optim.RMSprop([p for p in model.parameters() if p.requires_grad], lr=1e-4)\n",
    "    # Train for 1 epoch\n",
    "    for e in range(1):\n",
    "        train(model, mnist.train_loader, optimizer, e)\n",
    "        \n",
    "        print(\"Validation\")\n",
    "        print(\"============\")\n",
    "        acc1 = evaluate(model, mnist.val_loader, e)\n",
    "        \n",
    "    \n",
    "    cache_masks(model)\n",
    "    print()\n",
    "    set_num_tasks_learned(model, task + 1)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scenario GG: Task ID is given at train time and inference time\n",
    "\n",
    "If task ID is given at inference time, we simply evaluate using the mask we have trained for that ID. This procedure is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> Average top 1 performance: 0.9237\n",
      "Per task performance\n",
      "Task 0: 0.9191\n",
      "Task 1: 0.9292\n",
      "Task 2: 0.9225\n",
      "Task 3: 0.9207\n",
      "Task 4: 0.9269\n"
     ]
    }
   ],
   "source": [
    "# When task ID we can simply set the mask and evaluate\n",
    "\n",
    "gg_performance = []\n",
    "for task in range(5):\n",
    "    set_model_task(model, task)\n",
    "    mnist.update_task(task)\n",
    "    acc1 = evaluate(model, mnist.val_loader, 0)\n",
    "    gg_performance.append(acc1.item())\n",
    "\n",
    "clear_output()\n",
    "    \n",
    "print(f\"Average top 1 performance: {(sum(gg_performance) / len(gg_performance)):.4f}\")\n",
    "\n",
    "print(\"Per task performance\")\n",
    "for t in range(5):\n",
    "    print(f\"Task {t}: {gg_performance[t]:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scenario GNs: Task ID is given at train time but not inference time\n",
    "\n",
    "We can infer task identity at inference time for arbitrary pieces of data. Here we use the one-shot algorithm described in the paper for simplicity. In short, we assign each learned supermask $M^i$ a weight $\\alpha_i$ such that $\\sum_{i} \\alpha_i = 1$ and $\\alpha_i >= 0$. \n",
    "\n",
    "Given an example data point $x$ to classify, we can compute our loss as $H = \\mathcal{H}\\left(f\\left(x, \\theta \\odot \\left(\\sum_i \\alpha_i M^i\\right)\\right)\\right)$ where $f(x, \\theta)$ is our neural network which outputs logits and $\\mathcal H$ is our entropy function. From here our inferred task is simply \n",
    "$$t = \\text{argmin}_i \\frac{\\partial\\mathcal{H}}{\\partial \\alpha_i}.$$\n",
    "\n",
    "#### Intuition\n",
    "\n",
    "We can see entropy as a measure of confidence in our prediction. High entropy prediction distributions are very uncertain (close to uniform) and lowest entropy is reached when our distribution is very certain (at a one hot vector). So it stands to reason that supermasks which haven't been trained on the exemplar data will have high entropy. Further, instead of showing each individual supermask $x$, which would be computationally intractible for many tasks, we can show $x$ to a _superposition_ of supermasks and optimize for superposition coefficients $\\alpha_i$. Choosing the smallest $\\alpha_i$ for our task is essentially greedily moving in the direction of maximal decrease in entropy. \n",
    "\n",
    "Below is a simple implementation of oneshot task inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# When task info is not provided we can infer it\n",
    "# here we use the oneshot task inference alg detailed in the paper\n",
    "\n",
    "def oneshot_task_inference(model, batch, num_tasks):\n",
    "    # Set task < 0 for inference mode\n",
    "    set_model_task(model, -1, verbose=False)\n",
    "    \n",
    "    # Initialize alphas to uniform\n",
    "    alphas = torch.ones(num_tasks, 1, 1) / num_tasks\n",
    "    alphas.requires_grad_(True)\n",
    "    set_alphas(model, alphas, verbose=False)\n",
    "    \n",
    "    logits = model(batch)\n",
    "    \n",
    "    # Entropy of logits\n",
    "    entropy = -(logits.softmax(dim=1) * logits.log_softmax(dim=1)).sum(1).mean()\n",
    "    \n",
    "    # Gradient wrt alphas\n",
    "    g, = autograd.grad(entropy, alphas)\n",
    "    \n",
    "    inferred_task = (-g).squeeze().argmax()\n",
    "\n",
    "    return inferred_task.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task inference accuracy\n",
    "\n",
    "Below we show how accurate task inference is using our oneshot algorithm. If you would like to evaluate on more tasks (we use 5 for demonstration), just modify the `num_tasks` variable in the cell where we declare `MultitaskFC`. \n",
    "\n",
    "Here we evaluate task inference on 50 random images per task (the `trials` variable modifies this number) and show we predict the correct task with 100% accuracy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "81b88a0a96654e2b9a2750ee9716d372",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Task inference accuracy: 100.0%\n"
     ]
    }
   ],
   "source": [
    "# How many examples to show for task inference\n",
    "num_examples = 1\n",
    "trials = 50\n",
    "num_correct = 0\n",
    "num_seen = 0\n",
    "for _ in tqdm(range(trials)):\n",
    "    for task in range(5):\n",
    "        mnist.update_task(task)\n",
    "        inferred_task = oneshot_task_inference(\n",
    "            model,\n",
    "            batch=next(iter(mnist.val_loader))[0][:num_examples],\n",
    "            num_tasks=5\n",
    "        )\n",
    "        if inferred_task == task:\n",
    "            num_correct += 1\n",
    "        num_seen += 1\n",
    "\n",
    "print(f\"Task inference accuracy: {100 * num_correct / num_seen}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Full inference procedure\n",
    "\n",
    "Below is an example of how this could be used in an inference pipeline. In this scenario, we use one random image from the validation set to infer task identity $t$ and then evaluate with the appropriate mask $M^t$ on all tasks. We see that there is no drop in performance from the GG scenario. \n",
    "\n",
    "Note that for simplicity this is a small deviation from the evaluation setup in our paper. In our paper we use 1 image per batch to determine the task identity of the batch, and evaluate that batch using the inferred task. So task inference needs to be correct more often to match GG performance. We have already shown task inference accuracy is 100% with high probability in the previous cell so we don't need to do that here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> Average top 1 performance: 92.3680%\n",
      "=> Difference from GG performance: 0.0000\n"
     ]
    }
   ],
   "source": [
    "# Evaluation\n",
    "\n",
    "num_examples = 1\n",
    "\n",
    "# After task inference, we just perform the same evaluation procedure as before\n",
    "gns_performance = []\n",
    "for task in range(5):\n",
    "    mnist.update_task(task)\n",
    "    inferred_task = oneshot_task_inference(\n",
    "        model,\n",
    "        batch=next(iter(mnist.val_loader))[0][:num_examples],\n",
    "        num_tasks=5\n",
    "    )\n",
    "    set_model_task(model, inferred_task)\n",
    "    acc1 = evaluate(model, mnist.val_loader, 0)\n",
    "    gns_performance.append(acc1.item())\n",
    "\n",
    "clear_output()\n",
    "avg_acc = (sum(gns_performance) / len(gns_performance))\n",
    "print(f\"=> Average top 1 performance: {100*avg_acc:.4f}%\")\n",
    "print(f\"=> Difference from GG performance: \"\n",
    "      f\"{(sum(gg_performance) / len(gg_performance) - avg_acc):.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5.1\n"
     ]
    }
   ],
   "source": [
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3.7.4 64-bit ('prod': conda)",
   "language": "python",
   "name": "python37464bitprodconda17a3b0496aba4b76979106d5b5ac87cd"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}