SSVAE_with_Pyro_H_alpha_better_scale.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 153
    },
    "colab_type": "code",
    "id": "G3dcWXty_P9w",
    "outputId": "fdc4806f-ecd4-43bf-cc03-ef8fe5860df3",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#!git clone https://github.com/TheMrGhostman/Semi-supervised-Learning-with-VAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 224
    },
    "colab_type": "code",
    "id": "6MDu2-LS_gJn",
    "outputId": "22a7fb91-5ba5-4eca-f7a8-18d80e2ce291"
   },
   "outputs": [],
   "source": [
    "#!pip install pyro-ppl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V2UGHzWc_M4o"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import pyro\n",
    "import pyro.distributions as dist\n",
    "import pyro.contrib.examples.util  # patches torchvision\n",
    "\n",
    "from pyro.infer import SVI, JitTrace_ELBO, JitTraceEnum_ELBO, Trace_ELBO, TraceEnum_ELBO, config_enumerate\n",
    "from pyro.optim import Adam\n",
    "\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d7UVg2g7_vXc"
   },
   "outputs": [],
   "source": [
    "#os.chdir(\"Semi-supervised-Learning-with-VAE/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 317
    },
    "colab_type": "code",
    "id": "IULMzLj8_-U0",
    "outputId": "17971c21-a74f-4db0-e762-4992537b85c4"
   },
   "outputs": [],
   "source": [
    "from utils.datasets import SupervisedDataset\n",
    "from utils.utils import One_Hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DNMkZpbU_M41"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import RobustScaler, StandardScaler\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, f1_score\n",
    "\n",
    "from utils.layers import Reshape, Flatten\n",
    "import utils.datasets as d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wdf8tYr-_M5C"
   },
   "outputs": [],
   "source": [
    "class VariationalLayer(nn.Module):\n",
    "    \"\"\"\n",
    "    Variational Layer with reparametrization trick. \n",
    "    It's used as bottleneck of Variational AutoEncoder ie. output of encoder.\n",
    "\n",
    "    \"Linear layer for variational inference with reparametrization trick\"\n",
    "    \"\"\"\n",
    "    def __init__(self, in_features, out_features, bias=True):\n",
    "        \"\"\"\t\n",
    "        : param in_features: \t\tNumber of input features (number of neurons on input)\n",
    "        : param out_features:\t\tNumber of output features (number of neurons on output)\n",
    "        : param bias:\t\t\t\tInclude bias - True/False\n",
    "        \"\"\"\n",
    "        super(VariationalLayer, self).__init__()\n",
    "        self.mu = nn.Linear(in_features=in_features, out_features=out_features, bias=bias)\n",
    "        self.rho = nn.Linear(in_features=in_features, out_features=out_features, bias=bias)\n",
    "        self.softplus = nn.Softplus()\n",
    "\n",
    "    def forward(self, x_in):\n",
    "        mu = self.mu(x_in)\n",
    "        sigma = self.softplus(self.rho(x_in))\n",
    "        return mu, sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K3pVB9ii_M5M"
   },
   "outputs": [],
   "source": [
    "class ConvTransposeDecoderOutput(nn.Module):\n",
    "    def __init__(self, in_channels, in_features, out_features, kernel_size, stride=1, padding=0, bias=True):\n",
    "        super(ConvTransposeDecoderOutput, self).__init__()\n",
    "        self.mu = nn.ConvTranspose1d(\n",
    "                in_channels=in_channels, \n",
    "                out_channels=1, \n",
    "                kernel_size=kernel_size, \n",
    "                stride=stride, \n",
    "                padding=padding\n",
    "            )\n",
    "        self.rho = nn.Linear(in_features=in_features, out_features=1, bias=bias)\n",
    "        self.flatten = Flatten(out_features=in_features)\n",
    "        self.flatten_mu = Flatten(out_features=out_features)\n",
    "        self.softplus = nn.Softplus()\n",
    "\n",
    "    def forward(self, x_in):\n",
    "        \"\"\"\n",
    "        x must be shape ... (-1, in_channels, size)\n",
    "        \"\"\"\n",
    "        mu = self.mu(x_in)\n",
    "        x = self.flatten(x_in)\n",
    "        sigma = self.softplus(self.rho(x))\n",
    "        return self.flatten_mu(mu), sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uXvhQTAA_M5b"
   },
   "outputs": [],
   "source": [
    "class ConvTransposeDecoderOutput2(nn.Module):\n",
    "    def __init__(self, in_channels, out_features, kernel_size, stride=1, padding=0, bias=True):\n",
    "        super(ConvTransposeDecoderOutput2, self).__init__()\n",
    "        self.mu = nn.ConvTranspose1d(\n",
    "                in_channels=in_channels, \n",
    "                out_channels=1, \n",
    "                kernel_size=kernel_size, \n",
    "                stride=stride, \n",
    "                padding=padding\n",
    "            )\n",
    "        self.flatten_mu = Flatten(out_features=out_features)\n",
    "\n",
    "    def forward(self, x_in):\n",
    "        \"\"\"\n",
    "        x must be shape ... (-1, in_channels, size)\n",
    "        \"\"\"\n",
    "        mu = self.mu(x_in)\n",
    "        return self.flatten_mu(mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B6UwZ6pE_M5j"
   },
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.first_part =  nn.Sequential(\n",
    "                Reshape(out_shape=(1, 160)),\n",
    "                nn.Conv1d(in_channels=1, out_channels=16, kernel_size=6, stride=2, padding=0, bias=False), # n*1*160 -> n*16*78\n",
    "                nn.PReLU(),\n",
    "                nn.Conv1d(in_channels=16, out_channels=32, kernel_size=4, stride=2, bias=False),#n*16*78->n*32*38\n",
    "                nn.BatchNorm1d(num_features=32),\n",
    "                nn.PReLU(),\n",
    "                nn.Conv1d(in_channels=32, out_channels=64, kernel_size=4, stride=2, bias=False),#n*32*38->n*64*18\n",
    "                nn.BatchNorm1d(num_features=64),\n",
    "                nn.PReLU(),\n",
    "                Flatten(out_features=64*18))\n",
    "        self.fc = nn.Linear(in_features=64*18+4, out_features=256)\n",
    "        self.act = nn.PReLU()\n",
    "        self.out = VariationalLayer(in_features=256, out_features=15)\n",
    "        \n",
    "    def forward(self, x,y):\n",
    "        z = self.first_part(x)\n",
    "        z = torch.cat([z,y], axis=1)\n",
    "        z = self.act(self.fc(z))\n",
    "        return self.out(z)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UOBBsQ8A_M50"
   },
   "outputs": [],
   "source": [
    "decoder = nn.Sequential(\n",
    "    nn.Linear(in_features=15+4, out_features=256),\n",
    "    nn.PReLU(),\n",
    "    nn.Linear(in_features=256, out_features=64*18),\n",
    "    Reshape(out_shape=(64,18)),\n",
    "    nn.BatchNorm1d(num_features=64),\n",
    "    nn.PReLU(),\n",
    "    nn.ConvTranspose1d(in_channels=64, out_channels=32, kernel_size=4, stride=2, padding=0),\n",
    "    nn.BatchNorm1d(num_features=32),\n",
    "    nn.PReLU(),\n",
    "    nn.ConvTranspose1d(in_channels=32, out_channels=16, kernel_size=4, stride=2, padding=0),\n",
    "    #nn.BatchNorm1d(num_features=16),\n",
    "    nn.PReLU(),\n",
    "    ConvTransposeDecoderOutput(\n",
    "        in_channels=16,\n",
    "        in_features=16*78,\n",
    "        out_features=160, \n",
    "        kernel_size=6, \n",
    "        stride=2\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zF71nKMU_M59"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jlSAJpZ-_M6G"
   },
   "outputs": [],
   "source": [
    "clf = nn.Sequential(\n",
    "    Reshape(out_shape=(1, 160)),\n",
    "    nn.Conv1d(in_channels=1, out_channels=16, kernel_size=6, stride=2, padding=0, bias=False), # n*1*160 -> n*16*78\n",
    "    nn.PReLU(),\n",
    "    nn.Conv1d(in_channels=16, out_channels=32, kernel_size=4, stride=2, bias=False),#n*16*78->n*32*38\n",
    "    nn.BatchNorm1d(num_features=32),\n",
    "    nn.PReLU(),\n",
    "    nn.Conv1d(in_channels=32, out_channels=64, kernel_size=4, stride=2, bias=False),#n*32*38->n*64*18\n",
    "    nn.BatchNorm1d(num_features=64),\n",
    "    nn.PReLU(),\n",
    "    Flatten(out_features=64*18),\n",
    "    nn.Linear(in_features=64*18, out_features=256),\n",
    "    nn.PReLU(),\n",
    "    nn.Linear(in_features=256, out_features=4),\n",
    "    nn.Softmax(dim=1)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HXbeS7xS_M6M"
   },
   "outputs": [],
   "source": [
    "class SSVAE(nn.Module):\n",
    "    \"\"\"\n",
    "    This class encapsulates the parameters (neural networks) and models & guides needed to train a\n",
    "    semi-supervised variational auto-encoder on the MNIST image dataset\n",
    "    :param output_size: size of the tensor representing the class label (10 for MNIST since\n",
    "                        we represent the class labels as a one-hot vector with 10 components)\n",
    "    :param input_size: size of the tensor representing the image (28*28 = 784 for our MNIST dataset\n",
    "                       since we flatten the images and scale the pixels to be in [0,1])\n",
    "    :param z_dim: size of the tensor representing the latent random variable z\n",
    "                  (handwriting style for our MNIST dataset)\n",
    "    :param hidden_layers: a tuple (or list) of MLP layers to be used in the neural networks\n",
    "                          representing the parameters of the distributions in our model\n",
    "    :param use_cuda: use GPUs for faster training\n",
    "    :param aux_loss_multiplier: the multiplier to use with the auxiliary loss\n",
    "    \"\"\"\n",
    "    def __init__(self, config_enum=None, use_cuda=False, aux_loss_multiplier=None):\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "        # initialize the class with all arguments provided to the constructor\n",
    "        self.output_size = 4\n",
    "        self.z_dim = 15\n",
    "        self.allow_broadcast = config_enum == 'parallel'\n",
    "        self.use_cuda = use_cuda\n",
    "        self.aux_loss_multiplier = aux_loss_multiplier\n",
    "\n",
    "        # define and instantiate the neural networks representing\n",
    "        # the paramters of various distributions in the model\n",
    "        self.setup_networks()\n",
    "\n",
    "    def setup_networks(self):\n",
    "\n",
    "        self.encoder_y = clf\n",
    "\n",
    "        self.encoder_z = Encoder()\n",
    "\n",
    "        self.decoder = decoder\n",
    "\n",
    "        if self.use_cuda:\n",
    "            self.cuda()\n",
    "\n",
    "    def model(self, xs, ys=None):\n",
    "        \"\"\"\n",
    "        The model corresponds to the following generative process:\n",
    "        p(z) = normal(0,I)              # handwriting style (latent)\n",
    "        p(y|x) = categorical(I/10.)     # which digit (semi-supervised)\n",
    "        p(x|y,z) = bernoulli(loc(y,z))   # an image\n",
    "        loc is given by a neural network  `decoder`\n",
    "        :param xs: a batch of scaled vectors of pixels from an image\n",
    "        :param ys: (optional) a batch of the class labels i.e.\n",
    "                   the digit corresponding to the image(s)\n",
    "        :return: None\n",
    "        \"\"\"\n",
    "        # register this pytorch module and all of its sub-modules with pyro\n",
    "        pyro.module(\"ss_vae\", self)\n",
    "\n",
    "        batch_size = xs.size(0)\n",
    "        options = dict(dtype=xs.dtype, device=xs.device)\n",
    "        with pyro.plate(\"data\"):\n",
    "\n",
    "            # sample the handwriting style from the constant prior distribution\n",
    "            prior_loc = torch.zeros(batch_size, self.z_dim, **options)\n",
    "            prior_scale = torch.ones(batch_size, self.z_dim, **options)\n",
    "            zs = pyro.sample(\"z\", dist.Normal(prior_loc, prior_scale).to_event(1))\n",
    "\n",
    "            # if the label y (which digit to write) is supervised, sample from the\n",
    "            # constant prior, otherwise, observe the value (i.e. score it against the constant prior)\n",
    "            alpha_prior = torch.ones(batch_size, self.output_size, **options) / (1.0 * self.output_size)\n",
    "            ys = pyro.sample(\"y\", dist.OneHotCategorical(alpha_prior), obs=ys)\n",
    "\n",
    "            # finally, score the image (x) using the handwriting style (z) and\n",
    "            # the class label y (which digit to write) against the\n",
    "            # parametrized distribution p(x|y,z) = bernoulli(decoder(y,z))\n",
    "            # where `decoder` is a neural network\n",
    "            mu, sigma = self.decoder(torch.cat([zs, ys], axis=1))\n",
    "            #mu = self.decoder(torch.cat([zs, ys], axis=1))\n",
    "            #pyro.sample(\"x\", dist.Normal(mu,torch.ones((mu.shape[0],1)).cuda()).to_event(1), obs=xs)\n",
    "            pyro.sample(\"x\", dist.Normal(mu,sigma).to_event(1), obs=xs)\n",
    "            # return the loc so we can visualize it later\n",
    "            return mu\n",
    "\n",
    "    def guide(self, xs, ys=None):\n",
    "        \"\"\"\n",
    "        The guide corresponds to the following:\n",
    "        q(y|x) = categorical(alpha(x))              # infer digit from an image\n",
    "        q(z|x,y) = normal(loc(x,y),scale(x,y))       # infer handwriting style from an image and the digit\n",
    "        loc, scale are given by a neural network `encoder_z`\n",
    "        alpha is given by a neural network `encoder_y`\n",
    "        :param xs: a batch of scaled vectors of pixels from an image\n",
    "        :param ys: (optional) a batch of the class labels i.e.\n",
    "                   the digit corresponding to the image(s)\n",
    "        :return: None\n",
    "        \"\"\"\n",
    "        # inform Pyro that the variables in the batch of xs, ys are conditionally independent\n",
    "        with pyro.plate(\"data\"):\n",
    "\n",
    "            # if the class label (the digit) is not supervised, sample\n",
    "            # (and score) the digit with the variational distribution\n",
    "            # q(y|x) = categorical(alpha(x))\n",
    "            if ys is None:\n",
    "                alpha = self.encoder_y(xs)\n",
    "                ys = pyro.sample(\"y\", dist.OneHotCategorical(alpha))\n",
    "\n",
    "            # sample (and score) the latent handwriting-style with the variational\n",
    "            # distribution q(z|x,y) = normal(loc(x,y),scale(x,y))\n",
    "            loc, scale = self.encoder_z(xs, ys)\n",
    "            pyro.sample(\"z\", dist.Normal(loc, scale).to_event(1))\n",
    "\n",
    "    def classifier(self, xs):\n",
    "        \"\"\"\n",
    "        classify an image (or a batch of images)\n",
    "        :param xs: a batch of scaled vectors of pixels from an image\n",
    "        :return: a batch of the corresponding class labels (as one-hots)\n",
    "        \"\"\"\n",
    "        # use the trained model q(y|x) = categorical(alpha(x))\n",
    "        # compute all class probabilities for the image(s)\n",
    "        alpha = self.encoder_y(xs)\n",
    "\n",
    "        # get the index (digit) that corresponds to\n",
    "        # the maximum predicted class probability\n",
    "        res, ind = torch.topk(alpha, 1)\n",
    "\n",
    "        # convert the digit(s) to one-hot tensor(s)\n",
    "        ys = torch.zeros_like(alpha).scatter_(1, ind, 1.0)\n",
    "        return ys\n",
    "\n",
    "    def model_classify(self, xs, ys=None):\n",
    "        \"\"\"\n",
    "        this model is used to add an auxiliary (supervised) loss as described in the\n",
    "        Kingma et al., \"Semi-Supervised Learning with Deep Generative Models\".\n",
    "        \"\"\"\n",
    "        # register all pytorch (sub)modules with pyro\n",
    "        pyro.module(\"ss_vae\", self)\n",
    "\n",
    "        # inform Pyro that the variables in the batch of xs, ys are conditionally independent\n",
    "        with pyro.plate(\"data\"):\n",
    "            # this here is the extra term to yield an auxiliary loss that we do gradient descent on\n",
    "            if ys is not None:\n",
    "                alpha = self.encoder_y.forward(xs)\n",
    "                with pyro.poutine.scale(scale=self.aux_loss_multiplier):\n",
    "                    pyro.sample(\"y_aux\", dist.OneHotCategorical(alpha), obs=ys)\n",
    "\n",
    "    def guide_classify(self, xs, ys=None):\n",
    "        \"\"\"\n",
    "        dummy guide function to accompany model_classify in inference\n",
    "        \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2FtPqhEoAYnB"
   },
   "outputs": [],
   "source": [
    "def get_accuracy(data_loader, clf):\n",
    "    \"\"\"\n",
    "        clf ... ssvae.classifier()\n",
    "    \"\"\"\n",
    "    dataloader_len = len(data_loader)\n",
    "    acc = 0\n",
    "    with torch.no_grad():\n",
    "        for (xs, ys) in data_loader:\n",
    "            xs = xs.cuda()\n",
    "            pred = clf(xs)\n",
    "            acc += accuracy_score(np.argmax(pred.cpu().detach().numpy(), axis=1) , np.argmax(ys.numpy(),axis=1))\n",
    "    return acc/dataloader_len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UKyJFa9dBZSk"
   },
   "outputs": [],
   "source": [
    "def run_inference_for_epoch(data_loaders, losses):\n",
    "    \"\"\"\n",
    "        thanks to random sampler supervised and unsupervised datasets have the same length\n",
    "\n",
    "        two losses -> [ ELBO , -E(q(y|x)) ]\n",
    "    \"\"\"\n",
    "    num_losses = len(losses) \n",
    "\n",
    "    epoch_losses_sup = [0.] * num_losses\n",
    "    epoch_losses_unsup = [0.] * num_losses\n",
    "\n",
    "    sup_iter = iter(data_loaders[\"sup\"])\n",
    "    unsup_iter = iter(data_loaders[\"unsup\"])\n",
    "    \n",
    "    #model.train()\n",
    "    for batch_idx  in range(len(data_loaders[\"unsup\"])):\n",
    "        \n",
    "        # supervised flow\n",
    "        (xs, ys) = next(sup_iter)\n",
    "        for loss_id in range(num_losses):\n",
    "            # evaluating (tracing) losses and optimizer step \n",
    "            new_loss = losses[loss_id].step(xs.cuda(), ys.cuda())\n",
    "            # saving losses \n",
    "            epoch_losses_sup[loss_id] += new_loss\n",
    "        \n",
    "\n",
    "        # unsupervised flow\n",
    "        xs = next(unsup_iter)\n",
    "        for loss_id in range(num_losses):\n",
    "            # evaluating (tracing) losses and optimizer step \n",
    "            new_loss = losses[loss_id].step(xs.cuda())\n",
    "            # saving losses\n",
    "            epoch_losses_unsup[loss_id] += new_loss\n",
    "\n",
    "            \n",
    "    return epoch_losses_sup, epoch_losses_unsup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3RhdAuMq_M6e"
   },
   "source": [
    "# Get Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6WIMMIto_M6g"
   },
   "outputs": [],
   "source": [
    "X_s = np.vstack((np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_pt1.npy\"),\n",
    "               np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_pt2.npy\")))\n",
    "y_s = np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_targets.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HaA--Iij_M6o"
   },
   "outputs": [],
   "source": [
    "X_u = np.vstack((np.load(\"data/unlabeled_sequences_part_1.npy\"), np.load(\"data/unlabeled_sequences_part_2.npy\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_vKSNFUb_M6u",
    "outputId": "b668500e-5377-4f70-b98f-72374ef3ca03"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(83680, 160)\n",
      "(97400, 160)\n"
     ]
    }
   ],
   "source": [
    "print(X_s.shape)\n",
    "print(X_u.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Wu5JbTYM_M61"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(np.array(X_s), np.array(y_s), test_size=0.2, random_state=666)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zSDTyV6N_M65"
   },
   "outputs": [],
   "source": [
    "scaler = RobustScaler()\n",
    "scaler.fit(np.vstack((np.array(X_s),np.array(X_u))))\n",
    "\n",
    "X_sup= scaler.transform(X_train)\n",
    "X_unsup = scaler.transform(np.array(X_u))\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aRJ6kp_a_M6-"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kvTo4tXX_M7D"
   },
   "source": [
    "# Defining model and inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kDkHS6dK_M7E"
   },
   "outputs": [],
   "source": [
    "ss_vae = SSVAE(config_enum=\"parallel\", use_cuda=True, aux_loss_multiplier=46)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9SN1qsci_M7G"
   },
   "outputs": [],
   "source": [
    "adam_params = {\"lr\": 0.0001}\n",
    "optimizer = Adam(adam_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a0khk4C5_M7L"
   },
   "source": [
    "## ELBO of main loss $\\mathcal{J} = \\sum_{sup} \\mathcal{L}(\\vec{x},y) + \\sum_{unsup} \\mathcal{U}(\\vec{x})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GgTdgFR3_M7L"
   },
   "outputs": [],
   "source": [
    "guide = config_enumerate(ss_vae.guide, \"sequential\", expand=True) #config_enumerate(ss_vae.guide, \"parallel\", expand=True)\n",
    "elbo = TraceEnum_ELBO(max_plate_nesting=1) #JitTraceEnum_ELBO\n",
    "loss_basic = SVI(ss_vae.model, guide, optimizer, loss=elbo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0S40F2TW_M7O"
   },
   "outputs": [],
   "source": [
    "losses = [loss_basic]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UPzK05gz_M7R"
   },
   "source": [
    "## adding auxillary loss $\\mathbb{E}_{sup}[- \\log q(y|\\vec{x})]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UFxFum0z_M7R"
   },
   "outputs": [],
   "source": [
    "elbo = Trace_ELBO()\n",
    "loss_aux = SVI(ss_vae.model_classify, ss_vae.guide_classify, optimizer, loss=elbo)\n",
    "losses.append(loss_aux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VjkAaWLE_M7T"
   },
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zjauZ2xG_M7U"
   },
   "outputs": [],
   "source": [
    "sup_num = X_unsup.shape[0]\n",
    "unsup_num = X_unsup.shape[0]\n",
    "periodic_interval_batches = 1\n",
    "best_valid_acc, corresponding_test_acc = 0.0, 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HIgfXpGJ_M7X"
   },
   "outputs": [],
   "source": [
    "batch_size = 512"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DTzr_-LC_M7Z"
   },
   "outputs": [],
   "source": [
    "sup = d.SupervisedDataset(X_sup, One_Hot(4)(y_train))\n",
    "test = d.SupervisedDataset(X_test, One_Hot(4)(y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ngJlHQE7_M7c"
   },
   "outputs": [],
   "source": [
    "data_loaders = {}\n",
    "data_loaders[\"sup\"] = torch.utils.data.DataLoader(\n",
    "                            dataset=sup,\n",
    "                            batch_size=batch_size, \n",
    "                            shuffle=False, \n",
    "                            sampler=torch.utils.data.RandomSampler(\n",
    "                                sup, \n",
    "                                replacement=True,\n",
    "                                num_samples=X_unsup.shape[0]\n",
    "                                )\n",
    "                            )\n",
    "data_loaders[\"unsup\"] = torch.utils.data.DataLoader(\n",
    "                            dataset=torch.tensor(X_unsup).float(), \n",
    "                            batch_size=batch_size, \n",
    "                            shuffle=False, \n",
    "                            sampler=torch.utils.data.RandomSampler(\n",
    "                                X_unsup, \n",
    "                                replacement=False\n",
    "                                )\n",
    ")\n",
    "#data_loaders[\"valid\"] = torch.utils.data.DataLoader(SupervisedDataset(X_train[-5000:].view(-1, 1,28,28), y_train[-5000:]), \n",
    "#                                                  batch_size=batch_size)\n",
    "data_loaders[\"test\"] = torch.utils.data.DataLoader(test, batch_size=batch_size)                                                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_loss, unsup_loss, clf_loss, test_acc = [],[],[],[]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_epochs = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZpImoaajLLbp"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/50], time 112.78s, sup_loss:-1.4107, sup_clf_loss:24.9233, unsup_loss:-40.5026, test_accuracy:0.8245\n",
      "Epoch [2/50], time 108.77s, sup_loss:-102.2745, sup_clf_loss:19.0223, unsup_loss:-130.9989, test_accuracy:0.8515\n",
      "Epoch [3/50], time 111.40s, sup_loss:-130.6502, sup_clf_loss:17.0768, unsup_loss:-153.6405, test_accuracy:0.8550\n",
      "Epoch [4/50], time 109.34s, sup_loss:-147.0316, sup_clf_loss:15.7648, unsup_loss:-169.8498, test_accuracy:0.8687\n",
      "Epoch [5/50], time 109.14s, sup_loss:-152.7255, sup_clf_loss:14.7824, unsup_loss:-172.0697, test_accuracy:0.8760\n",
      "Epoch [6/50], time 110.54s, sup_loss:-164.4351, sup_clf_loss:14.0899, unsup_loss:-182.8246, test_accuracy:0.8933\n",
      "Epoch [7/50], time 108.04s, sup_loss:-166.4719, sup_clf_loss:13.6378, unsup_loss:-188.7107, test_accuracy:0.8640\n",
      "Epoch [8/50], time 108.62s, sup_loss:-166.9791, sup_clf_loss:13.2570, unsup_loss:-188.5124, test_accuracy:0.8887\n",
      "Epoch [9/50], time 109.54s, sup_loss:-172.3164, sup_clf_loss:12.7399, unsup_loss:-191.1329, test_accuracy:0.8998\n",
      "Epoch [10/50], time 107.65s, sup_loss:-177.4836, sup_clf_loss:12.2820, unsup_loss:-198.1222, test_accuracy:0.9004\n",
      "Epoch [11/50], time 106.38s, sup_loss:-178.2018, sup_clf_loss:12.0060, unsup_loss:-197.7043, test_accuracy:0.8772\n",
      "Epoch [12/50], time 108.67s, sup_loss:-180.3066, sup_clf_loss:11.7727, unsup_loss:-200.1323, test_accuracy:0.8853\n",
      "Epoch [13/50], time 109.30s, sup_loss:-181.6112, sup_clf_loss:11.4697, unsup_loss:-205.5543, test_accuracy:0.8990\n",
      "Epoch [14/50], time 122.95s, sup_loss:-185.5428, sup_clf_loss:11.2894, unsup_loss:-204.1736, test_accuracy:0.9044\n",
      "Epoch [15/50], time 108.28s, sup_loss:-184.7774, sup_clf_loss:11.1059, unsup_loss:-206.5544, test_accuracy:0.9112\n",
      "Epoch [16/50], time 108.18s, sup_loss:-189.9386, sup_clf_loss:10.9995, unsup_loss:-210.6509, test_accuracy:0.9034\n",
      "Epoch [17/50], time 108.36s, sup_loss:-190.2990, sup_clf_loss:10.6355, unsup_loss:-213.7201, test_accuracy:0.9085\n",
      "Epoch [18/50], time 104.59s, sup_loss:-189.0908, sup_clf_loss:10.3409, unsup_loss:-212.5115, test_accuracy:0.9087\n",
      "Epoch [19/50], time 105.35s, sup_loss:-193.8984, sup_clf_loss:10.1223, unsup_loss:-218.1107, test_accuracy:0.9016\n",
      "Epoch [20/50], time 104.70s, sup_loss:-192.3385, sup_clf_loss:9.9657, unsup_loss:-214.6686, test_accuracy:0.9098\n",
      "Epoch [21/50], time 108.81s, sup_loss:-194.1430, sup_clf_loss:9.7286, unsup_loss:-218.2346, test_accuracy:0.9087\n",
      "Epoch [22/50], time 106.74s, sup_loss:-194.6887, sup_clf_loss:9.5658, unsup_loss:-215.9604, test_accuracy:0.8980\n",
      "Epoch [23/50], time 119.20s, sup_loss:-193.9248, sup_clf_loss:9.3695, unsup_loss:-218.2413, test_accuracy:0.9001\n",
      "Epoch [24/50], time 110.86s, sup_loss:-197.4779, sup_clf_loss:9.2082, unsup_loss:-220.9425, test_accuracy:0.9161\n",
      "Epoch [25/50], time 110.65s, sup_loss:-197.5274, sup_clf_loss:9.0094, unsup_loss:-217.7966, test_accuracy:0.9071\n",
      "Epoch [26/50], time 110.32s, sup_loss:-196.7671, sup_clf_loss:8.9023, unsup_loss:-220.4390, test_accuracy:0.9104\n",
      "Epoch [27/50], time 109.02s, sup_loss:-199.8728, sup_clf_loss:8.5580, unsup_loss:-221.8345, test_accuracy:0.9004\n",
      "Epoch [28/50], time 109.31s, sup_loss:-200.5476, sup_clf_loss:8.5264, unsup_loss:-224.1919, test_accuracy:0.9097\n",
      "Epoch [29/50], time 110.04s, sup_loss:-201.4509, sup_clf_loss:8.3827, unsup_loss:-223.9025, test_accuracy:0.9038\n",
      "Epoch [30/50], time 112.59s, sup_loss:-201.5548, sup_clf_loss:8.1561, unsup_loss:-223.8581, test_accuracy:0.9102\n",
      "Epoch [31/50], time 109.70s, sup_loss:-202.3303, sup_clf_loss:8.0225, unsup_loss:-225.7614, test_accuracy:0.9024\n",
      "Epoch [32/50], time 109.87s, sup_loss:-203.3682, sup_clf_loss:7.6343, unsup_loss:-227.0605, test_accuracy:0.9159\n",
      "Epoch [33/50], time 109.25s, sup_loss:-200.7593, sup_clf_loss:7.5541, unsup_loss:-226.6334, test_accuracy:0.9161\n",
      "Epoch [34/50], time 109.74s, sup_loss:-201.4479, sup_clf_loss:7.4002, unsup_loss:-225.5537, test_accuracy:0.9185\n",
      "Epoch [35/50], time 109.26s, sup_loss:-204.8481, sup_clf_loss:7.2307, unsup_loss:-231.0447, test_accuracy:0.9171\n",
      "Epoch [36/50], time 109.57s, sup_loss:-203.7936, sup_clf_loss:7.0743, unsup_loss:-228.7205, test_accuracy:0.9198\n",
      "Epoch [37/50], time 110.84s, sup_loss:-203.8536, sup_clf_loss:6.7465, unsup_loss:-228.7650, test_accuracy:0.9097\n",
      "Epoch [38/50], time 109.50s, sup_loss:-206.8473, sup_clf_loss:6.4821, unsup_loss:-230.7829, test_accuracy:0.8772\n",
      "Epoch [39/50], time 109.65s, sup_loss:-205.4836, sup_clf_loss:6.3374, unsup_loss:-230.8467, test_accuracy:0.9030\n",
      "Epoch [40/50], time 109.25s, sup_loss:-207.1798, sup_clf_loss:6.3976, unsup_loss:-230.7636, test_accuracy:0.9175\n",
      "Epoch [41/50], time 110.16s, sup_loss:-207.3960, sup_clf_loss:6.0367, unsup_loss:-230.2232, test_accuracy:0.9167\n",
      "Epoch [42/50], time 109.78s, sup_loss:-208.6496, sup_clf_loss:5.9252, unsup_loss:-233.4709, test_accuracy:0.9063\n",
      "Epoch [43/50], time 110.40s, sup_loss:-210.3062, sup_clf_loss:5.6386, unsup_loss:-234.2529, test_accuracy:0.9138\n",
      "Epoch [44/50], time 110.12s, sup_loss:-210.0268, sup_clf_loss:5.4672, unsup_loss:-234.5271, test_accuracy:0.9155\n",
      "Epoch [45/50], time 111.10s, sup_loss:-210.7541, sup_clf_loss:5.2132, unsup_loss:-231.7333, test_accuracy:0.9132\n",
      "Epoch [46/50], time 110.63s, sup_loss:-211.9566, sup_clf_loss:5.1703, unsup_loss:-233.8678, test_accuracy:0.9163\n",
      "Epoch [47/50], time 110.34s, sup_loss:-209.3731, sup_clf_loss:4.9061, unsup_loss:-233.9928, test_accuracy:0.9132\n",
      "Epoch [48/50], time 109.23s, sup_loss:-209.8256, sup_clf_loss:4.8540, unsup_loss:-237.6992, test_accuracy:0.9160\n",
      "Epoch [49/50], time 108.60s, sup_loss:-210.3683, sup_clf_loss:4.6686, unsup_loss:-234.1646, test_accuracy:0.9145\n",
      "Epoch [50/50], time 109.61s, sup_loss:-212.0449, sup_clf_loss:4.6255, unsup_loss:-231.4867, test_accuracy:0.9164\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,n_epochs): # 10 epochs for start\n",
    "    start = time.time()\n",
    "    epoch_sup_loss, epoch_unsup_loss = run_inference_for_epoch(data_loaders, losses)\n",
    "\n",
    "    sup_loss.append(epoch_sup_loss[0]/sup_num)\n",
    "    clf_loss.append(epoch_sup_loss[1]/sup_num)\n",
    "    unsup_loss.append(epoch_unsup_loss[0]/unsup_num)\n",
    "\n",
    "    test_accuracy = get_accuracy(data_loaders[\"test\"], ss_vae.encoder_y)\n",
    "    test_acc.append(test_accuracy)\n",
    "\n",
    "    \n",
    "    print(\"Epoch [{}/{}], time {:.2f}s, sup_loss:{:.4f}, sup_clf_loss:{:.4f}, unsup_loss:{:.4f}, test_accuracy:{:.4f}\"\\\n",
    "          .format(i+1, n_epochs, time.time()-start, sup_loss[-1], clf_loss[-1], unsup_loss[-1], test_accuracy))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [51/100], time 114.70s, sup_loss:-212.8062, sup_clf_loss:4.3624, unsup_loss:-235.2327, test_accuracy:0.9119\n",
      "Epoch [52/100], time 109.90s, sup_loss:-212.8504, sup_clf_loss:4.1171, unsup_loss:-239.0186, test_accuracy:0.9178\n",
      "Epoch [53/100], time 109.18s, sup_loss:-214.0279, sup_clf_loss:3.9206, unsup_loss:-235.1246, test_accuracy:0.9162\n",
      "Epoch [54/100], time 109.43s, sup_loss:-213.9791, sup_clf_loss:3.6857, unsup_loss:-234.4140, test_accuracy:0.9170\n",
      "Epoch [55/100], time 108.87s, sup_loss:-212.5992, sup_clf_loss:3.6828, unsup_loss:-235.0611, test_accuracy:0.9184\n",
      "Epoch [56/100], time 109.51s, sup_loss:-213.4499, sup_clf_loss:3.3905, unsup_loss:-235.0232, test_accuracy:0.9156\n",
      "Epoch [57/100], time 111.89s, sup_loss:-213.8794, sup_clf_loss:3.2287, unsup_loss:-236.0852, test_accuracy:0.9160\n",
      "Epoch [58/100], time 108.85s, sup_loss:-217.7953, sup_clf_loss:3.2227, unsup_loss:-238.1821, test_accuracy:0.9157\n",
      "Epoch [59/100], time 111.27s, sup_loss:-213.4137, sup_clf_loss:2.9186, unsup_loss:-238.8114, test_accuracy:0.9111\n",
      "Epoch [60/100], time 112.94s, sup_loss:-214.0697, sup_clf_loss:2.8453, unsup_loss:-238.2483, test_accuracy:0.9144\n",
      "Epoch [61/100], time 111.67s, sup_loss:-215.6738, sup_clf_loss:2.7895, unsup_loss:-238.8059, test_accuracy:0.9139\n",
      "Epoch [62/100], time 110.69s, sup_loss:-215.3887, sup_clf_loss:2.6146, unsup_loss:-238.6867, test_accuracy:0.9077\n",
      "Epoch [63/100], time 109.91s, sup_loss:-216.5674, sup_clf_loss:2.5091, unsup_loss:-239.7152, test_accuracy:0.9083\n",
      "Epoch [64/100], time 111.24s, sup_loss:-217.1639, sup_clf_loss:2.2956, unsup_loss:-239.0135, test_accuracy:0.9135\n",
      "Epoch [65/100], time 110.46s, sup_loss:-215.9005, sup_clf_loss:2.2578, unsup_loss:-237.4196, test_accuracy:0.9148\n",
      "Epoch [66/100], time 113.06s, sup_loss:-215.9064, sup_clf_loss:2.0098, unsup_loss:-239.3764, test_accuracy:0.9128\n",
      "Epoch [67/100], time 111.94s, sup_loss:-215.2610, sup_clf_loss:2.0104, unsup_loss:-241.3544, test_accuracy:0.9127\n",
      "Epoch [68/100], time 110.68s, sup_loss:-217.3626, sup_clf_loss:1.8359, unsup_loss:-242.9747, test_accuracy:0.9093\n",
      "Epoch [69/100], time 109.82s, sup_loss:-215.1982, sup_clf_loss:1.7535, unsup_loss:-239.3572, test_accuracy:0.9116\n",
      "Epoch [70/100], time 111.73s, sup_loss:-216.2506, sup_clf_loss:1.6647, unsup_loss:-239.2354, test_accuracy:0.9008\n",
      "Epoch [71/100], time 112.62s, sup_loss:-216.3167, sup_clf_loss:1.5688, unsup_loss:-242.2692, test_accuracy:0.9096\n",
      "Epoch [72/100], time 112.18s, sup_loss:-215.6154, sup_clf_loss:1.5188, unsup_loss:-241.3938, test_accuracy:0.9103\n",
      "Epoch [73/100], time 115.77s, sup_loss:-219.1166, sup_clf_loss:1.3146, unsup_loss:-242.8916, test_accuracy:0.9145\n",
      "Epoch [74/100], time 114.26s, sup_loss:-218.7652, sup_clf_loss:1.4090, unsup_loss:-240.8842, test_accuracy:0.9064\n",
      "Epoch [75/100], time 112.07s, sup_loss:-216.6563, sup_clf_loss:1.2236, unsup_loss:-240.7534, test_accuracy:0.9104\n",
      "Epoch [76/100], time 112.96s, sup_loss:-218.6166, sup_clf_loss:1.1347, unsup_loss:-242.2314, test_accuracy:0.8962\n",
      "Epoch [77/100], time 112.37s, sup_loss:-218.6517, sup_clf_loss:1.1192, unsup_loss:-240.2179, test_accuracy:0.9116\n",
      "Epoch [78/100], time 112.97s, sup_loss:-221.5080, sup_clf_loss:1.0568, unsup_loss:-243.6148, test_accuracy:0.9126\n",
      "Epoch [79/100], time 111.68s, sup_loss:-218.6158, sup_clf_loss:1.0666, unsup_loss:-242.3284, test_accuracy:0.9092\n",
      "Epoch [80/100], time 117.19s, sup_loss:-219.4138, sup_clf_loss:1.0022, unsup_loss:-242.1757, test_accuracy:0.9113\n",
      "Epoch [81/100], time 119.78s, sup_loss:-220.5934, sup_clf_loss:0.8805, unsup_loss:-241.7494, test_accuracy:0.9084\n",
      "Epoch [82/100], time 117.30s, sup_loss:-221.0226, sup_clf_loss:0.7677, unsup_loss:-244.2571, test_accuracy:0.9118\n",
      "Epoch [83/100], time 111.48s, sup_loss:-219.7630, sup_clf_loss:0.7377, unsup_loss:-242.1176, test_accuracy:0.9097\n",
      "Epoch [84/100], time 113.17s, sup_loss:-220.7556, sup_clf_loss:0.7662, unsup_loss:-243.4002, test_accuracy:0.9108\n",
      "Epoch [85/100], time 117.78s, sup_loss:-220.4189, sup_clf_loss:0.6287, unsup_loss:-244.7975, test_accuracy:0.9048\n",
      "Epoch [86/100], time 115.51s, sup_loss:-218.4674, sup_clf_loss:0.7907, unsup_loss:-242.2890, test_accuracy:0.9063\n",
      "Epoch [87/100], time 109.67s, sup_loss:-221.1460, sup_clf_loss:0.6132, unsup_loss:-246.5626, test_accuracy:0.9082\n",
      "Epoch [88/100], time 110.27s, sup_loss:-220.6713, sup_clf_loss:0.6577, unsup_loss:-243.2732, test_accuracy:0.9109\n",
      "Epoch [89/100], time 114.16s, sup_loss:-221.3441, sup_clf_loss:0.4866, unsup_loss:-244.3434, test_accuracy:0.9093\n",
      "Epoch [90/100], time 112.51s, sup_loss:-223.4321, sup_clf_loss:0.5676, unsup_loss:-244.9924, test_accuracy:0.9109\n",
      "Epoch [91/100], time 110.76s, sup_loss:-222.7962, sup_clf_loss:0.5908, unsup_loss:-246.2914, test_accuracy:0.9099\n",
      "Epoch [92/100], time 111.33s, sup_loss:-221.3324, sup_clf_loss:0.5404, unsup_loss:-245.5429, test_accuracy:0.9096\n",
      "Epoch [93/100], time 111.19s, sup_loss:-221.4641, sup_clf_loss:0.4438, unsup_loss:-244.5793, test_accuracy:0.9117\n",
      "Epoch [94/100], time 110.75s, sup_loss:-220.9533, sup_clf_loss:0.5124, unsup_loss:-244.5833, test_accuracy:0.9109\n",
      "Epoch [95/100], time 111.43s, sup_loss:-222.2832, sup_clf_loss:0.3683, unsup_loss:-245.3251, test_accuracy:0.9079\n",
      "Epoch [96/100], time 110.37s, sup_loss:-222.9221, sup_clf_loss:0.4365, unsup_loss:-246.0947, test_accuracy:0.9088\n",
      "Epoch [97/100], time 110.82s, sup_loss:-222.9266, sup_clf_loss:0.7417, unsup_loss:-245.7351, test_accuracy:0.9091\n",
      "Epoch [98/100], time 109.77s, sup_loss:-225.3756, sup_clf_loss:0.3047, unsup_loss:-246.6174, test_accuracy:0.9077\n",
      "Epoch [99/100], time 110.33s, sup_loss:-224.4333, sup_clf_loss:0.3118, unsup_loss:-246.4904, test_accuracy:0.9051\n",
      "Epoch [100/100], time 111.18s, sup_loss:-222.6711, sup_clf_loss:0.3283, unsup_loss:-247.0735, test_accuracy:0.9122\n"
     ]
    }
   ],
   "source": [
    "for i in range(50,100): # 10 epochs for start\n",
    "    start = time.time()\n",
    "    epoch_sup_loss, epoch_unsup_loss = run_inference_for_epoch(data_loaders, losses)\n",
    "\n",
    "    sup_loss.append(epoch_sup_loss[0]/sup_num)\n",
    "    clf_loss.append(epoch_sup_loss[1]/sup_num)\n",
    "    unsup_loss.append(epoch_unsup_loss[0]/unsup_num)\n",
    "\n",
    "    test_accuracy = get_accuracy(data_loaders[\"test\"], ss_vae.encoder_y)\n",
    "    test_acc.append(test_accuracy)\n",
    "\n",
    "    \n",
    "    print(\"Epoch [{}/{}], time {:.2f}s, sup_loss:{:.4f}, sup_clf_loss:{:.4f}, unsup_loss:{:.4f}, test_accuracy:{:.4f}\"\\\n",
    "          .format(i+1, 100, time.time()-start, sup_loss[-1], clf_loss[-1], unsup_loss[-1], test_accuracy))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1440 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(4,1, figsize=(15,20))\n",
    "fig.tight_layout()\n",
    "axes[0].plot(np.array(sup_loss), label=\"supervised loss\")\n",
    "axes[0].plot(np.array(unsup_loss), label=\"unsupervised loss\")\n",
    "\n",
    "axes[1].plot(np.array(clf_loss), label=\"classification loss\")\n",
    "\n",
    "axes[2].plot(np.array(test_acc), label=\"accuracy\")\n",
    "axes[2].grid(True)\n",
    "\n",
    "axes[3].plot(np.array(sup_loss) + np.array(unsup_loss)  + 46*np.array(clf_loss), label=r\"J^{alpha}\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ghost_000\\Miniconda3\\envs\\Pytorch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type SSVAE. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "C:\\Users\\ghost_000\\Miniconda3\\envs\\Pytorch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type Encoder. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "C:\\Users\\ghost_000\\Miniconda3\\envs\\Pytorch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type VariationalLayer. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "C:\\Users\\ghost_000\\Miniconda3\\envs\\Pytorch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type ConvTransposeDecoderOutput. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(ss_vae, \"models_and_losses/SSVAE_CBN_alpha-46_lr-1e-4_100ep.pt\")\n",
    "torch.save(ss_vae.state_dict(), \"models_and_losses/SSVAE_CBN_alpha-46_lr-1e-4_state_dict_100ep.pt\")\n",
    "torch.save(ss_vae.encoder_y, \"models_and_losses/SSVAE_CBN_classifier_alpha-46_lr-1e-4_100ep.pt\")\n",
    "torch.save(ss_vae.encoder_y.state_dict(), \"models_and_losses/SSVAE_CBN_classifier_alpha-46_lr-1e-4_state_dict_100ep.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>supervised_loss</th>\n",
       "      <th>unsupervised_loss</th>\n",
       "      <th>classification_loss</th>\n",
       "      <th>test_accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.410712</td>\n",
       "      <td>-40.502553</td>\n",
       "      <td>24.923337</td>\n",
       "      <td>0.824461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-102.274485</td>\n",
       "      <td>-130.998910</td>\n",
       "      <td>19.022317</td>\n",
       "      <td>0.851487</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-130.650177</td>\n",
       "      <td>-153.640456</td>\n",
       "      <td>17.076847</td>\n",
       "      <td>0.854974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-147.031611</td>\n",
       "      <td>-169.849771</td>\n",
       "      <td>15.764757</td>\n",
       "      <td>0.868699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-152.725495</td>\n",
       "      <td>-172.069664</td>\n",
       "      <td>14.782378</td>\n",
       "      <td>0.876038</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   supervised_loss  unsupervised_loss  classification_loss  test_accuracy\n",
       "0        -1.410712         -40.502553            24.923337       0.824461\n",
       "1      -102.274485        -130.998910            19.022317       0.851487\n",
       "2      -130.650177        -153.640456            17.076847       0.854974\n",
       "3      -147.031611        -169.849771            15.764757       0.868699\n",
       "4      -152.725495        -172.069664            14.782378       0.876038"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({\"supervised_loss\":sup_loss, \"unsupervised_loss\":unsup_loss, \"classification_loss\":clf_loss,\"test_accuracy\":test_acc})\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df.to_csv(\"models_and_losses/SSVAE_CBN_alpha-46_lr-1e-4_100ep_losses.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 1==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZEniSVNO_M7g"
   },
   "outputs": [],
   "source": [
    "ss_vae.encoder_y.eval()\n",
    "preds = []\n",
    "with torch.no_grad():\n",
    "    for (xs, ys) in data_loaders[\"test\"]:\n",
    "        xs = xs.cuda()\n",
    "        pred = ss_vae.encoder_y(xs)\n",
    "        preds.append(np.argmax(pred.cpu().detach().numpy(), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = np.hstack(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9134201720841301"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_true=y_test, y_pred=preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8628405502963292"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(y_true=y_test, y_pred=preds,average=\"macro\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3643,   383,    29,   180],\n",
       "       [  294, 10004,    37,   110],\n",
       "       [   17,    41,   405,    16],\n",
       "       [  197,   128,    17,  1235]], dtype=int64)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf1 = confusion_matrix(y_true=y_test, y_pred=preds) # x_axis = predicted, y_axis = ground_truth\n",
    "cf1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     array([[3808,  265,   25,  137],\n",
    "           [ 414, 9883,   35,  113],\n",
    "           [  22,   34,  404,   19],\n",
    "           [ 187,  102,   11, 1277]], dtype=int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf_test = deepcopy(ss_vae.encoder_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pred = ss_vae.encoder_y(torch.tensor(X_test).float().cuda())\n",
    "preds = []\n",
    "clf_test.eval()\n",
    "with torch.no_grad():\n",
    "    for (xs, ys) in data_loaders[\"test\"]:\n",
    "        xs = xs.cuda()\n",
    "        pred = clf_test(xs)\n",
    "        preds.append(np.argmax(pred.cpu().detach().numpy(), axis=1))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = np.hstack(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8642629347099131"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(y_true=y_test, y_pred=preds,average=\"macro\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9164077437858509"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_true=y_test, y_pred=preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "UPzK05gz_M7R"
   ],
   "name": "SSVAE_with_Pyro_H_alpha.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Pytorch",
   "language": "python",
   "name": "pytorch"
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}