{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# VBLL Classification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrdvmpB7OkhK"
      },
      "source": [
        "In this notebook, we walk through implementing VBLL classification models, including out of distribution detection.\n",
        "\n",
        "If you are new to VBLL models, we recommend checking out the regression notebook first!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "YmaBF6fUVu26",
        "outputId": "6e6a333a-040d-4227-e0a2-554b3896d329"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: vbll in /usr/local/lib/python3.10/dist-packages (0.1.3)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from vbll) (1.25.2)\n",
            "Requirement already satisfied: torch>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from vbll) (2.2.1+cu121)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (3.13.4)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (4.11.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (3.3)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (2023.6.0)\n",
            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (8.9.2.26)\n",
            "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.3.1)\n",
            "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (11.0.2.54)\n",
            "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (10.3.2.106)\n",
            "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (11.4.5.107)\n",
            "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.0.106)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (2.19.3)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (12.1.105)\n",
            "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.6.0->vbll) (2.2.0)\n",
            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch>=1.6.0->vbll) (12.4.127)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.6.0->vbll) (2.1.5)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.6.0->vbll) (1.3.0)\n"
          ]
        }
      ],
      "source": [
        "!pip install vbll\n",
        "import vbll\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import numpy as np\n",
        "from dataclasses import dataclass\n",
        "\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision.datasets as datasets\n",
        "from torch.utils.data import Dataset\n",
        "from torchvision.transforms import ToTensor\n",
        "from torchvision import transforms\n",
        "from PIL import Image\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn import metrics\n",
        "\n",
        "from tqdm import tqdm\n",
        "from matplotlib.pyplot import cm\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7F0rIERkP3gw"
      },
      "source": [
        "We will train a small MLP on MNIST. We use Fashion MNIST as an out of distribution dataset. We will also define a simple visualization function, which we will use later."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": true,
        "id": "UVesvKd2VzHT"
      },
      "outputs": [],
      "source": [
        "mnist_train_dataset = datasets.MNIST(root='data',\n",
        "                               train=True,\n",
        "                               transform=transforms.ToTensor(),\n",
        "                               download=True)\n",
        "\n",
        "mnist_test_dataset = datasets.MNIST(root='data',\n",
        "                              train=False,\n",
        "                              transform=transforms.ToTensor())\n",
        "\n",
        "mnist_ood_dataset = datasets.FashionMNIST(root='data',\n",
        "                                    train=False,\n",
        "                                    transform=transforms.ToTensor(),\n",
        "                                    download=True)\n",
        "\n",
        "def viz_performance(logs):\n",
        "  \"\"\"\n",
        "  A visualization function that plots losses, accuracies, and out of\n",
        "  distribution AUROC.\n",
        "\n",
        "  logs: a dictionary, with keys corresponding to different model evals and values\n",
        "  corresponding to dicts of results.\n",
        "  \"\"\"\n",
        "\n",
        "  # get list of colors\n",
        "  color = cm.rainbow(np.linspace(0, 1, len(logs)))\n",
        "\n",
        "  for i, (k,v) in enumerate(logs.items()):\n",
        "    # train and val loss\n",
        "    plt.plot(v['train_loss'], label=k + ' (train)', color=color[i])\n",
        "    plt.plot(v['val_loss'], label=k + ' (val)', linestyle = '--', color=color[i])\n",
        "  plt.legend()\n",
        "  plt.ylabel('Loss')\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.show()\n",
        "\n",
        "  for i, (k,v) in enumerate(logs.items()):\n",
        "    plt.plot([1 - x for x in v['train_acc']], label=k + ' (train)', color=color[i])\n",
        "    plt.plot([1 - x for x in v['val_acc']], label=k + ' (val)', linestyle='--', color=color[i])\n",
        "\n",
        "  plt.ylabel('Error rate')\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.legend()\n",
        "  plt.semilogy()\n",
        "  plt.show()\n",
        "\n",
        "  for i, (k,v) in enumerate(logs.items()):\n",
        "    plt.plot(v['ood_auroc'], label=k, color=color[i])\n",
        "  plt.legend()\n",
        "  plt.ylabel('OOD AUROC')\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQxg_u8xQEzD"
      },
      "source": [
        "We will first define a simple MLP (with a standard last layer) as a baseline."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "GXpmO9esV8Lk"
      },
      "outputs": [],
      "source": [
        "class MLP(nn.Module):\n",
        "  \"\"\"\n",
        "  A standard MLP classification model.\n",
        "\n",
        "  cfg: a config containing model parameters.\n",
        "  \"\"\"\n",
        "  def __init__(self, cfg):\n",
        "    super(MLP, self).__init__()\n",
        "\n",
        "    self.params = nn.ModuleDict({\n",
        "      'in_layer': nn.Linear(cfg.IN_FEATURES, cfg.HIDDEN_FEATURES),\n",
        "      'core': nn.ModuleList([nn.Linear(cfg.HIDDEN_FEATURES, cfg.HIDDEN_FEATURES) for i in range(cfg.NUM_LAYERS)]),\n",
        "      'out_layer': nn.Linear(cfg.HIDDEN_FEATURES, cfg.OUT_FEATURES),\n",
        "    })\n",
        "    self.activations = nn.ModuleList([nn.ELU() for i in range(cfg.NUM_LAYERS)])\n",
        "    self.cfg = cfg\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = x.view(x.shape[0], -1)\n",
        "    x = self.params['in_layer'](x)\n",
        "\n",
        "    for layer, ac in zip(self.params['core'], self.activations):\n",
        "      x = ac(layer(x))\n",
        "\n",
        "    return F.log_softmax(self.params['out_layer'](x), dim=-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5xc8YSnxQZQ8"
      },
      "source": [
        "We have defined a model, and can now write a train loop. In our regression notebook, we write a different train loop for the baseline models and for VBLL models, and highlight the differences. Here, our train function takes are argument in train_cfg indicating whether a model has a VBLL last layer or not. There is a handful of if statements in the code that are different for baseline models and for VBLL models, but the differences are relatively small."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "ZXKKRN64XkB8"
      },
      "outputs": [],
      "source": [
        "def eval_acc(preds, y):\n",
        "  map_preds = torch.argmax(preds, dim=1)\n",
        "  return (map_preds == y).float().mean()\n",
        "\n",
        "def eval_ood(model, ind_dataloader, ood_dataloader, VBLL=True):\n",
        "  ind_preds = []\n",
        "  ood_preds = []\n",
        "\n",
        "  def get_score(out):\n",
        "    if VBLL:\n",
        "      score = out.ood_scores.detach().cpu().numpy()\n",
        "    else:\n",
        "      score = torch.max(out, dim=-1)[0].detach().cpu().numpy()\n",
        "    return score\n",
        "\n",
        "  for i, (x, y) in enumerate(ind_dataloader):\n",
        "    x = x.to(device)\n",
        "    out = model(x)\n",
        "    ind_preds = np.concatenate((ind_preds, get_score(out)))\n",
        "\n",
        "  for i, (x, y) in enumerate(ood_dataloader):\n",
        "    x = x.to(device)\n",
        "    out = model(x)\n",
        "    ood_preds = np.concatenate((ood_preds, get_score(out)))\n",
        "\n",
        "  labels = np.concatenate((np.ones_like(ind_preds)+1, np.ones_like(ind_preds)))\n",
        "  scores = np.concatenate((ind_preds, ood_preds))\n",
        "  fpr, tpr, thresholds = metrics.roc_curve(labels, scores, pos_label=2)\n",
        "  return metrics.auc(fpr, tpr)\n",
        "\n",
        "\n",
        "def train(model, train_cfg):\n",
        "  \"\"\"Train a standard classification model with either standard or VBLL models.\n",
        "  \"\"\"\n",
        "\n",
        "  if train_cfg.VBLL:\n",
        "    # for VBLL models, set weight decay to zero on last layer\n",
        "    param_list = [\n",
        "        {'params': model.params.in_layer.parameters(), 'weight_decay': train_cfg.WD},\n",
        "        {'params': model.params.core.parameters(), 'weight_decay': train_cfg.WD},\n",
        "        {'params': model.params.out_layer.parameters(), 'weight_decay': 0.}\n",
        "    ]\n",
        "  else:\n",
        "    param_list = model.parameters()\n",
        "    loss_fn = nn.CrossEntropyLoss() # define loss function only for non-VBLL model\n",
        "\n",
        "  optimizer = train_cfg.OPT(param_list,\n",
        "                            lr=train_cfg.LR,\n",
        "                            weight_decay=train_cfg.WD)\n",
        "\n",
        "  dataloader = DataLoader(mnist_train_dataset, batch_size = train_cfg.BATCH_SIZE, shuffle=True)\n",
        "  val_dataloader = DataLoader(mnist_test_dataset, batch_size = train_cfg.BATCH_SIZE, shuffle=True)\n",
        "  ood_dataloader = DataLoader(mnist_ood_dataset, batch_size = train_cfg.BATCH_SIZE, shuffle=True)\n",
        "\n",
        "  output_metrics = {\n",
        "      'train_loss': [],\n",
        "      'val_loss': [],\n",
        "      'train_acc': [],\n",
        "      'val_acc': [],\n",
        "      'ood_auroc': []\n",
        "  }\n",
        "\n",
        "  for epoch in range(train_cfg.NUM_EPOCHS):\n",
        "    model.train()\n",
        "    running_loss = []\n",
        "    running_acc = []\n",
        "\n",
        "    for train_step, data in enumerate(dataloader):\n",
        "      optimizer.zero_grad()\n",
        "      x = data[0].to(device)\n",
        "      y = data[1].to(device)\n",
        "\n",
        "      out = model(x)\n",
        "      if train_cfg.VBLL:\n",
        "        loss = out.train_loss_fn(y)\n",
        "        probs = out.predictive.probs\n",
        "        acc = eval_acc(probs, y).item()\n",
        "      else:\n",
        "        loss = loss_fn(out, y)\n",
        "        acc = eval_acc(out, y).item()\n",
        "\n",
        "      running_loss.append(loss.item())\n",
        "      running_acc.append(acc)\n",
        "\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "\n",
        "    output_metrics['train_loss'].append(np.mean(running_loss))\n",
        "    output_metrics['train_acc'].append(np.mean(running_acc))\n",
        "\n",
        "    if epoch % train_cfg.VAL_FREQ == 0:\n",
        "      running_val_loss = []\n",
        "      running_val_acc = []\n",
        "\n",
        "      with torch.no_grad():\n",
        "        model.eval()\n",
        "        for test_step, data in enumerate(val_dataloader):\n",
        "          x = data[0].to(device)\n",
        "          y = data[1].to(device)\n",
        "\n",
        "          out = model(x)\n",
        "          if train_cfg.VBLL:\n",
        "            loss = out.val_loss_fn(y)\n",
        "            probs = out.predictive.probs\n",
        "            acc = eval_acc(probs, y).item()\n",
        "          else:\n",
        "            loss = loss_fn(out, y)\n",
        "            acc = eval_acc(out, y).item()\n",
        "\n",
        "          running_val_loss.append(loss.item())\n",
        "          running_val_acc.append(acc)\n",
        "\n",
        "        output_metrics['val_loss'].append(np.mean(running_val_loss))\n",
        "        output_metrics['val_acc'].append(np.mean(running_val_acc))\n",
        "      output_metrics['ood_auroc'].append(eval_ood(model, val_dataloader, ood_dataloader, VBLL=train_cfg.VBLL))\n",
        "      print('Epoch: {:2d}, train loss: {:4.4f}'.format(epoch, np.mean(running_loss)))\n",
        "      print('Epoch: {:2d}, valid loss: {:4.4f}'.format(epoch, np.mean(np.mean(running_val_loss))))\n",
        "  return output_metrics\n",
        "\n",
        "outputs = {}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RgV12EDrYvTR"
      },
      "source": [
        "We can now train a baseline MLP:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8lLNEuqPXqH5",
        "outputId": "7cd733b5-9a2c-46e3-e839-956dd826b5d3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch:  0, train loss: 0.5983\n",
            "Epoch:  0, valid loss: 0.2720\n",
            "Epoch:  1, train loss: 0.2489\n",
            "Epoch:  1, valid loss: 0.2165\n",
            "Epoch:  2, train loss: 0.1990\n",
            "Epoch:  2, valid loss: 0.1779\n",
            "Epoch:  3, train loss: 0.1639\n",
            "Epoch:  3, valid loss: 0.1543\n",
            "Epoch:  4, train loss: 0.1395\n",
            "Epoch:  4, valid loss: 0.1355\n",
            "Epoch:  5, train loss: 0.1209\n",
            "Epoch:  5, valid loss: 0.1291\n",
            "Epoch:  6, train loss: 0.1065\n",
            "Epoch:  6, valid loss: 0.1129\n",
            "Epoch:  7, train loss: 0.0937\n",
            "Epoch:  7, valid loss: 0.1053\n",
            "Epoch:  8, train loss: 0.0838\n",
            "Epoch:  8, valid loss: 0.1009\n",
            "Epoch:  9, train loss: 0.0752\n",
            "Epoch:  9, valid loss: 0.1056\n",
            "Epoch: 10, train loss: 0.0678\n",
            "Epoch: 10, valid loss: 0.0980\n",
            "Epoch: 11, train loss: 0.0609\n",
            "Epoch: 11, valid loss: 0.0911\n",
            "Epoch: 12, train loss: 0.0548\n",
            "Epoch: 12, valid loss: 0.0893\n",
            "Epoch: 13, train loss: 0.0528\n",
            "Epoch: 13, valid loss: 0.0915\n",
            "Epoch: 14, train loss: 0.0465\n",
            "Epoch: 14, valid loss: 0.0886\n",
            "Epoch: 15, train loss: 0.0416\n",
            "Epoch: 15, valid loss: 0.0868\n",
            "Epoch: 16, train loss: 0.0385\n",
            "Epoch: 16, valid loss: 0.0962\n",
            "Epoch: 17, train loss: 0.0350\n",
            "Epoch: 17, valid loss: 0.0915\n",
            "Epoch: 18, train loss: 0.0324\n",
            "Epoch: 18, valid loss: 0.0865\n",
            "Epoch: 19, train loss: 0.0318\n",
            "Epoch: 19, valid loss: 0.0930\n",
            "Epoch: 20, train loss: 0.0255\n",
            "Epoch: 20, valid loss: 0.0906\n",
            "Epoch: 21, train loss: 0.0228\n",
            "Epoch: 21, valid loss: 0.0896\n",
            "Epoch: 22, train loss: 0.0194\n",
            "Epoch: 22, valid loss: 0.0949\n",
            "Epoch: 23, train loss: 0.0190\n",
            "Epoch: 23, valid loss: 0.0866\n",
            "Epoch: 24, train loss: 0.0167\n",
            "Epoch: 24, valid loss: 0.0934\n",
            "Epoch: 25, train loss: 0.0156\n",
            "Epoch: 25, valid loss: 0.0994\n",
            "Epoch: 26, train loss: 0.0153\n",
            "Epoch: 26, valid loss: 0.0986\n",
            "Epoch: 27, train loss: 0.0130\n",
            "Epoch: 27, valid loss: 0.0967\n",
            "Epoch: 28, train loss: 0.0118\n",
            "Epoch: 28, valid loss: 0.0966\n",
            "Epoch: 29, train loss: 0.0096\n",
            "Epoch: 29, valid loss: 0.1035\n"
          ]
        }
      ],
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n",
        "\n",
        "class train_cfg:\n",
        "  NUM_EPOCHS = 30\n",
        "  BATCH_SIZE = 512\n",
        "  LR = 1e-3\n",
        "  WD = 1e-4\n",
        "  OPT = torch.optim.AdamW\n",
        "  CLIP_VAL = 1\n",
        "  VAL_FREQ = 1\n",
        "  VBLL = False\n",
        "\n",
        "class cfg:\n",
        "  IN_FEATURES = 784\n",
        "  HIDDEN_FEATURES = 128\n",
        "  OUT_FEATURES = 10\n",
        "  NUM_LAYERS = 2\n",
        "\n",
        "\n",
        "model = MLP(cfg()).to(device)\n",
        "outputs['MLP'] = train(model, train_cfg())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uue1oMGlY0hY"
      },
      "source": [
        "Now, let's define a VBLL model. Note that the only difference is the out_layer switching from a linear layer to a VBLLClassificationD layer.\n",
        "\n",
        "We also no longer need to include an output softmax, since that is included in the VBLL classification layer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "HXnseOsOYMRI"
      },
      "outputs": [],
      "source": [
        "class DiscVBLLMLP(nn.Module):\n",
        "  def __init__(self, cfg):\n",
        "    super(DiscVBLLMLP, self).__init__()\n",
        "\n",
        "    self.params = nn.ModuleDict({\n",
        "      'in_layer': nn.Linear(cfg.IN_FEATURES, cfg.HIDDEN_FEATURES),\n",
        "      'core': nn.ModuleList([nn.Linear(cfg.HIDDEN_FEATURES, cfg.HIDDEN_FEATURES) for i in range(cfg.NUM_LAYERS)]),\n",
        "      'out_layer': vbll.DiscClassification(cfg.HIDDEN_FEATURES, cfg.OUT_FEATURES, cfg.REG_WEIGHT, parameterization = cfg.PARAM, return_ood=cfg.RETURN_OOD, prior_scale=cfg.PRIOR_SCALE),\n",
        "    })\n",
        "    self.activations = nn.ModuleList([nn.ELU() for i in range(cfg.NUM_LAYERS)])\n",
        "    self.cfg = cfg\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = x.view(x.shape[0], -1)\n",
        "    x = self.params['in_layer'](x)\n",
        "\n",
        "    for layer, ac in zip(self.params['core'], self.activations):\n",
        "      x = ac(layer(x))\n",
        "\n",
        "    return self.params['out_layer'](x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bE5YWUL9XRGh",
        "outputId": "11b93fe7-e573-4a80-bf36-ed4cd80fbc11"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch:  0, train loss: 3.6502\n",
            "Epoch:  0, valid loss: 0.9098\n",
            "Epoch:  1, train loss: 2.0208\n",
            "Epoch:  1, valid loss: 0.6610\n",
            "Epoch:  2, train loss: 1.4807\n",
            "Epoch:  2, valid loss: 0.3486\n",
            "Epoch:  3, train loss: 1.1293\n",
            "Epoch:  3, valid loss: 0.2595\n",
            "Epoch:  4, train loss: 0.9065\n",
            "Epoch:  4, valid loss: 0.1816\n",
            "Epoch:  5, train loss: 0.7412\n",
            "Epoch:  5, valid loss: 0.2053\n",
            "Epoch:  6, train loss: 0.6349\n",
            "Epoch:  6, valid loss: 0.1367\n",
            "Epoch:  7, train loss: 0.5440\n",
            "Epoch:  7, valid loss: 0.1794\n",
            "Epoch:  8, train loss: 0.4800\n",
            "Epoch:  8, valid loss: 0.1147\n",
            "Epoch:  9, train loss: 0.4257\n",
            "Epoch:  9, valid loss: 0.1342\n",
            "Epoch: 10, train loss: 0.3846\n",
            "Epoch: 10, valid loss: 0.1473\n",
            "Epoch: 11, train loss: 0.3472\n",
            "Epoch: 11, valid loss: 0.1377\n",
            "Epoch: 12, train loss: 0.3253\n",
            "Epoch: 12, valid loss: 0.1053\n",
            "Epoch: 13, train loss: 0.3079\n",
            "Epoch: 13, valid loss: 0.1232\n",
            "Epoch: 14, train loss: 0.2750\n",
            "Epoch: 14, valid loss: 0.1231\n",
            "Epoch: 15, train loss: 0.2691\n",
            "Epoch: 15, valid loss: 0.1170\n",
            "Epoch: 16, train loss: 0.2540\n",
            "Epoch: 16, valid loss: 0.1458\n",
            "Epoch: 17, train loss: 0.2518\n",
            "Epoch: 17, valid loss: 0.1305\n",
            "Epoch: 18, train loss: 0.2328\n",
            "Epoch: 18, valid loss: 0.1152\n",
            "Epoch: 19, train loss: 0.2238\n",
            "Epoch: 19, valid loss: 0.1721\n",
            "Epoch: 20, train loss: 0.2079\n",
            "Epoch: 20, valid loss: 0.1115\n",
            "Epoch: 21, train loss: 0.2016\n",
            "Epoch: 21, valid loss: 0.1418\n",
            "Epoch: 22, train loss: 0.1898\n",
            "Epoch: 22, valid loss: 0.1278\n",
            "Epoch: 23, train loss: 0.1856\n",
            "Epoch: 23, valid loss: 0.1194\n",
            "Epoch: 24, train loss: 0.1802\n",
            "Epoch: 24, valid loss: 0.1353\n",
            "Epoch: 25, train loss: 0.1901\n",
            "Epoch: 25, valid loss: 0.1724\n",
            "Epoch: 26, train loss: 0.1921\n",
            "Epoch: 26, valid loss: 0.1773\n",
            "Epoch: 27, train loss: 0.1768\n",
            "Epoch: 27, valid loss: 0.1335\n",
            "Epoch: 28, train loss: 0.1707\n",
            "Epoch: 28, valid loss: 0.1522\n",
            "Epoch: 29, train loss: 0.1576\n",
            "Epoch: 29, valid loss: 0.1478\n"
          ]
        }
      ],
      "source": [
        "class train_cfg:\n",
        "  NUM_EPOCHS = 30\n",
        "  BATCH_SIZE = 512\n",
        "  LR = 3e-3\n",
        "  WD = 1e-4\n",
        "  OPT = torch.optim.AdamW\n",
        "  CLIP_VAL = 1\n",
        "  VAL_FREQ = 1\n",
        "  VBLL = True\n",
        "\n",
        "class cfg:\n",
        "    IN_FEATURES = 784\n",
        "    HIDDEN_FEATURES = 128\n",
        "    OUT_FEATURES = 10\n",
        "    NUM_LAYERS = 2\n",
        "    REG_WEIGHT = 1./mnist_train_dataset.__len__()\n",
        "    PARAM = 'diagonal'\n",
        "    RETURN_OOD = True\n",
        "    PRIOR_SCALE = 1.\n",
        "\n",
        "disc_vbll_model = DiscVBLLMLP(cfg()).to(device)\n",
        "outputs['DiscVBLL'] = train(disc_vbll_model, train_cfg())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qMKrnHFDZfGw"
      },
      "source": [
        "We can also train a VBLL MLP with a Generative VBLL last layer. Note that we are only changing the output layer. We can use the same config.\n",
        "\n",
        "Note also that the train loss is not directly comparable between the generative and discriminative models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "IUlvvQmgOcao"
      },
      "outputs": [],
      "source": [
        "class GenVBLLMLP(nn.Module):\n",
        "  def __init__(self, cfg):\n",
        "    super(GenVBLLMLP, self).__init__()\n",
        "\n",
        "    self.params = nn.ModuleDict({\n",
        "      'in_layer': nn.Linear(cfg.IN_FEATURES, cfg.HIDDEN_FEATURES),\n",
        "      'core': nn.ModuleList([nn.Linear(cfg.HIDDEN_FEATURES, cfg.HIDDEN_FEATURES) for i in range(cfg.NUM_LAYERS)]),\n",
        "      'out_layer': vbll.GenClassification(cfg.HIDDEN_FEATURES, cfg.OUT_FEATURES, cfg.REG_WEIGHT, parameterization = cfg.PARAM, return_ood=cfg.RETURN_OOD, prior_scale=cfg.PRIOR_SCALE),\n",
        "    })\n",
        "    self.activations = nn.ModuleList([nn.ELU() for i in range(cfg.NUM_LAYERS)])\n",
        "    self.cfg = cfg\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = x.view(x.shape[0], -1)\n",
        "    x = self.params['in_layer'](x)\n",
        "\n",
        "    for layer, ac in zip(self.params['core'], self.activations):\n",
        "      x = ac(layer(x))\n",
        "\n",
        "    return self.params['out_layer'](x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G7-vq_cYhODi",
        "outputId": "90a422ee-8caf-48a0-ef7a-2582f2fecc6f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch:  0, train loss: 1052.9993\n",
            "Epoch:  0, valid loss: 1.0089\n",
            "Epoch:  1, train loss: 411.9979\n",
            "Epoch:  1, valid loss: 0.4640\n",
            "Epoch:  2, train loss: 224.6902\n",
            "Epoch:  2, valid loss: 0.3177\n",
            "Epoch:  3, train loss: 143.0866\n",
            "Epoch:  3, valid loss: 0.2567\n",
            "Epoch:  4, train loss: 99.4332\n",
            "Epoch:  4, valid loss: 0.2219\n",
            "Epoch:  5, train loss: 73.2394\n",
            "Epoch:  5, valid loss: 0.1944\n",
            "Epoch:  6, train loss: 56.1805\n",
            "Epoch:  6, valid loss: 0.1693\n",
            "Epoch:  7, train loss: 44.3615\n",
            "Epoch:  7, valid loss: 0.1641\n",
            "Epoch:  8, train loss: 35.9223\n",
            "Epoch:  8, valid loss: 0.1493\n",
            "Epoch:  9, train loss: 29.5990\n",
            "Epoch:  9, valid loss: 0.1312\n",
            "Epoch: 10, train loss: 24.7483\n",
            "Epoch: 10, valid loss: 0.1246\n",
            "Epoch: 11, train loss: 20.9903\n",
            "Epoch: 11, valid loss: 0.1157\n",
            "Epoch: 12, train loss: 17.9761\n",
            "Epoch: 12, valid loss: 0.1115\n",
            "Epoch: 13, train loss: 15.5314\n",
            "Epoch: 13, valid loss: 0.1111\n",
            "Epoch: 14, train loss: 13.5226\n",
            "Epoch: 14, valid loss: 0.1042\n",
            "Epoch: 15, train loss: 11.8618\n",
            "Epoch: 15, valid loss: 0.0962\n",
            "Epoch: 16, train loss: 10.4580\n",
            "Epoch: 16, valid loss: 0.1000\n",
            "Epoch: 17, train loss: 9.2954\n",
            "Epoch: 17, valid loss: 0.0978\n",
            "Epoch: 18, train loss: 8.2763\n",
            "Epoch: 18, valid loss: 0.0984\n",
            "Epoch: 19, train loss: 7.4101\n",
            "Epoch: 19, valid loss: 0.0914\n",
            "Epoch: 20, train loss: 6.6650\n",
            "Epoch: 20, valid loss: 0.0939\n",
            "Epoch: 21, train loss: 6.0070\n",
            "Epoch: 21, valid loss: 0.0903\n",
            "Epoch: 22, train loss: 5.4354\n",
            "Epoch: 22, valid loss: 0.0935\n",
            "Epoch: 23, train loss: 4.9440\n",
            "Epoch: 23, valid loss: 0.0886\n",
            "Epoch: 24, train loss: 4.4972\n",
            "Epoch: 24, valid loss: 0.0890\n",
            "Epoch: 25, train loss: 4.1072\n",
            "Epoch: 25, valid loss: 0.0905\n",
            "Epoch: 26, train loss: 3.7585\n",
            "Epoch: 26, valid loss: 0.0943\n",
            "Epoch: 27, train loss: 3.4438\n",
            "Epoch: 27, valid loss: 0.0958\n",
            "Epoch: 28, train loss: 3.1712\n",
            "Epoch: 28, valid loss: 0.0946\n",
            "Epoch: 29, train loss: 2.9195\n",
            "Epoch: 29, valid loss: 0.1095\n"
          ]
        }
      ],
      "source": [
        "gen_vbll_model = GenVBLLMLP(cfg()).to(device)\n",
        "outputs['GenVBLL'] = train(gen_vbll_model, train_cfg())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ou_1cVbZmD0"
      },
      "source": [
        "And finally, we can visualize performance of all models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "D5WXV9MjP3og",
        "outputId": "2b70bb35-a438-4b29-e876-e5b06119cc73"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "viz_performance(outputs)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}