SSVAE_with_Pyro_H_alpha_InceptionTime_more_ep-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\n",
    "from utils.inception import *"
   ]
  },
  {
   "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": 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": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zF71nKMU_M59"
   },
   "outputs": [],
   "source": [
    "# InceptionTime model\n",
    "clf = nn.Sequential(\n",
    "        Reshape(out_shape=(1,160)),\n",
    "        InceptionBlock(\n",
    "            in_channels=1, \n",
    "            n_filters=32, \n",
    "            kernel_sizes=[5, 11, 23],\n",
    "            bottleneck_channels=32,\n",
    "            use_residual=True,\n",
    "            activation=nn.ReLU()\n",
    "        ),\n",
    "        InceptionBlock(\n",
    "            in_channels=32*4, \n",
    "            n_filters=32, \n",
    "            kernel_sizes=[5, 11, 23],\n",
    "            bottleneck_channels=32,\n",
    "            use_residual=True,\n",
    "            activation=nn.ReLU()\n",
    "        ),\n",
    "        nn.AdaptiveAvgPool1d(output_size=1),\n",
    "        Flatten(out_features=32*4*1),\n",
    "        nn.Linear(in_features=4*32*1, 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) = normal(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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(66944, 160)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_sup.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,7))\n",
    "plt.hist(y_train)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,7))\n",
    "plt.hist(y_test)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kvTo4tXX_M7D"
   },
   "source": [
    "# Defining model and inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kDkHS6dK_M7E"
   },
   "outputs": [],
   "source": [
    "ss_vae = SSVAE(config_enum=\"parallel\", use_cuda=True, aux_loss_multiplier=0.1*66944)# pyro exaples suggests 46 for MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zjauZ2xG_M7U"
   },
   "outputs": [],
   "source": [
    "sup_num = X_unsup.shape[0]\n",
    "unsup_num = X_unsup.shape[0]\n",
    "best_valid_acc, corresponding_test_acc = 0.0, 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HIgfXpGJ_M7X"
   },
   "outputs": [],
   "source": [
    "batch_size = 512"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 34,
   "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": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_loss, unsup_loss, clf_loss, test_acc = [],[],[],[]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_epochs = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZpImoaajLLbp"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/50], time 538.76s, sup_loss:3.7910, sup_clf_loss:3170.5262, unsup_loss:-23.9907, test_accuracy:0.8829\n",
      "Epoch [2/50], time 538.55s, sup_loss:-95.1375, sup_clf_loss:2064.7858, unsup_loss:-125.1949, test_accuracy:0.9028\n",
      "Epoch [3/50], time 551.56s, sup_loss:-125.6118, sup_clf_loss:1792.6574, unsup_loss:-150.3259, test_accuracy:0.9151\n",
      "Epoch [4/50], time 567.21s, sup_loss:-142.3999, sup_clf_loss:1635.4805, unsup_loss:-165.7822, test_accuracy:0.9162\n",
      "Epoch [5/50], time 567.87s, sup_loss:-153.6416, sup_clf_loss:1527.3140, unsup_loss:-175.7674, test_accuracy:0.9104\n",
      "Epoch [6/50], time 573.59s, sup_loss:-159.8302, sup_clf_loss:1413.0117, unsup_loss:-180.9021, test_accuracy:0.9242\n",
      "Epoch [7/50], time 578.24s, sup_loss:-161.4024, sup_clf_loss:1352.8652, unsup_loss:-184.8013, test_accuracy:0.9227\n",
      "Epoch [8/50], time 581.42s, sup_loss:-170.6576, sup_clf_loss:1289.1355, unsup_loss:-192.0674, test_accuracy:0.9291\n",
      "Epoch [9/50], time 558.12s, sup_loss:-168.9978, sup_clf_loss:1181.2017, unsup_loss:-194.3888, test_accuracy:0.9284\n",
      "Epoch [10/50], time 632.96s, sup_loss:-173.5591, sup_clf_loss:1120.2970, unsup_loss:-195.6782, test_accuracy:0.9380\n",
      "Epoch [11/50], time 632.84s, sup_loss:-175.4230, sup_clf_loss:1065.1115, unsup_loss:-201.7224, test_accuracy:0.9402\n",
      "Epoch [12/50], time 529.83s, sup_loss:-177.3531, sup_clf_loss:999.0071, unsup_loss:-199.1160, test_accuracy:0.9162\n",
      "Epoch [13/50], time 581.75s, sup_loss:-182.3729, sup_clf_loss:1005.4335, unsup_loss:-205.1933, test_accuracy:0.9300\n",
      "Epoch [14/50], time 575.25s, sup_loss:-183.6576, sup_clf_loss:935.4490, unsup_loss:-203.1435, test_accuracy:0.9455\n",
      "Epoch [15/50], time 584.48s, sup_loss:-186.9994, sup_clf_loss:893.2591, unsup_loss:-209.4533, test_accuracy:0.9441\n",
      "Epoch [16/50], time 618.48s, sup_loss:-188.1361, sup_clf_loss:845.4090, unsup_loss:-210.2604, test_accuracy:0.9376\n",
      "Epoch [17/50], time 1077.49s, sup_loss:-187.4065, sup_clf_loss:847.8892, unsup_loss:-211.9746, test_accuracy:0.9397\n",
      "Epoch [18/50], time 1222.76s, sup_loss:-189.6757, sup_clf_loss:781.4341, unsup_loss:-212.5322, test_accuracy:0.9466\n",
      "Epoch [19/50], time 1274.09s, sup_loss:-189.8478, sup_clf_loss:749.5069, unsup_loss:-213.1334, test_accuracy:0.9572\n",
      "Epoch [20/50], time 1293.74s, sup_loss:-188.2287, sup_clf_loss:722.1932, unsup_loss:-214.9144, test_accuracy:0.9529\n",
      "Epoch [21/50], time 755.36s, sup_loss:-194.2000, sup_clf_loss:694.9420, unsup_loss:-217.0554, test_accuracy:0.9571\n",
      "Epoch [22/50], time 554.19s, sup_loss:-192.1829, sup_clf_loss:642.4458, unsup_loss:-216.5683, test_accuracy:0.9524\n",
      "Epoch [23/50], time 600.05s, sup_loss:-195.0673, sup_clf_loss:621.9856, unsup_loss:-215.5117, test_accuracy:0.9536\n",
      "Epoch [24/50], time 598.68s, sup_loss:-195.7391, sup_clf_loss:583.9338, unsup_loss:-216.9009, test_accuracy:0.9609\n",
      "Epoch [25/50], time 566.34s, sup_loss:-198.4279, sup_clf_loss:562.5562, unsup_loss:-219.0163, test_accuracy:0.9599\n",
      "Epoch [26/50], time 606.92s, sup_loss:-197.4325, sup_clf_loss:508.4377, unsup_loss:-220.2207, test_accuracy:0.9516\n",
      "Epoch [27/50], time 692.11s, sup_loss:-199.7056, sup_clf_loss:493.1449, unsup_loss:-220.6830, test_accuracy:0.9533\n",
      "Epoch [28/50], time 625.04s, sup_loss:-200.8971, sup_clf_loss:468.9125, unsup_loss:-222.3241, test_accuracy:0.9628\n",
      "Epoch [29/50], time 598.46s, sup_loss:-198.1494, sup_clf_loss:512.9164, unsup_loss:-220.9039, test_accuracy:0.9678\n",
      "Epoch [30/50], time 599.75s, sup_loss:-201.3334, sup_clf_loss:407.7334, unsup_loss:-224.3708, test_accuracy:0.9672\n",
      "Epoch [31/50], time 597.94s, sup_loss:-200.4993, sup_clf_loss:410.4192, unsup_loss:-227.5237, test_accuracy:0.9660\n",
      "Epoch [32/50], time 591.37s, sup_loss:-203.8108, sup_clf_loss:405.1354, unsup_loss:-225.9228, test_accuracy:0.9674\n",
      "Epoch [33/50], time 588.56s, sup_loss:-204.2365, sup_clf_loss:375.5822, unsup_loss:-224.6099, test_accuracy:0.9661\n",
      "Epoch [34/50], time 588.54s, sup_loss:-204.1552, sup_clf_loss:362.2607, unsup_loss:-226.6919, test_accuracy:0.9664\n",
      "Epoch [35/50], time 591.23s, sup_loss:-206.0944, sup_clf_loss:427.4266, unsup_loss:-227.0520, test_accuracy:0.9710\n",
      "Epoch [36/50], time 599.59s, sup_loss:-204.2829, sup_clf_loss:303.0285, unsup_loss:-226.4333, test_accuracy:0.9743\n",
      "Epoch [37/50], time 600.81s, sup_loss:-207.7107, sup_clf_loss:300.2913, unsup_loss:-229.6399, test_accuracy:0.9691\n",
      "Epoch [38/50], time 562.47s, sup_loss:-202.8644, sup_clf_loss:307.7317, unsup_loss:-229.5311, test_accuracy:0.9678\n",
      "Epoch [39/50], time 558.41s, sup_loss:-205.6633, sup_clf_loss:273.2076, unsup_loss:-228.5425, test_accuracy:0.9642\n",
      "Epoch [40/50], time 552.97s, sup_loss:-206.3905, sup_clf_loss:279.1163, unsup_loss:-230.1883, test_accuracy:0.9690\n",
      "Epoch [41/50], time 572.21s, sup_loss:-204.4087, sup_clf_loss:276.3485, unsup_loss:-230.6125, test_accuracy:0.9673\n",
      "Epoch [42/50], time 574.99s, sup_loss:-207.1747, sup_clf_loss:230.4765, unsup_loss:-230.5296, test_accuracy:0.9747\n",
      "Epoch [43/50], time 586.24s, sup_loss:-207.1583, sup_clf_loss:245.4243, unsup_loss:-231.0774, test_accuracy:0.9730\n",
      "Epoch [44/50], time 574.79s, sup_loss:-203.5791, sup_clf_loss:250.1757, unsup_loss:-231.5873, test_accuracy:0.9762\n",
      "Epoch [45/50], time 565.82s, sup_loss:-209.7744, sup_clf_loss:195.9752, unsup_loss:-231.6379, test_accuracy:0.9715\n",
      "Epoch [46/50], time 562.05s, sup_loss:-210.1705, sup_clf_loss:168.7352, unsup_loss:-233.1083, test_accuracy:0.9754\n",
      "Epoch [47/50], time 558.85s, sup_loss:-208.7892, sup_clf_loss:184.4385, unsup_loss:-230.1672, test_accuracy:0.9758\n",
      "Epoch [48/50], time 618.15s, sup_loss:-210.0609, sup_clf_loss:325.3505, unsup_loss:-234.6411, test_accuracy:0.9767\n",
      "Epoch [49/50], time 650.22s, sup_loss:-208.6814, sup_clf_loss:132.1002, unsup_loss:-233.0217, test_accuracy:0.9776\n",
      "Epoch [50/50], time 640.95s, sup_loss:-212.8276, sup_clf_loss:156.2736, unsup_loss:-234.9286, test_accuracy:0.9750\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": 39,
   "metadata": {
    "scrolled": false
   },
   "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": [
    "alpha = 0.1*66944\n",
    "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",
    "axes[0].legend()\n",
    "\n",
    "axes[1].plot(np.array(clf_loss), label=\"classification loss\")\n",
    "axes[1].legend()\n",
    "\n",
    "axes[2].plot(np.array(test_acc), label=\"accuracy\")\n",
    "axes[2].grid(True)\n",
    "axes[2].legend()\n",
    "\n",
    "axes[3].plot(np.array(sup_loss) + np.array(unsup_loss)  + alpha * np.array(clf_loss), label=r\"$\\mathcal{J}^{\\alpha}$\")\n",
    "axes[3].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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_InceptionTime_proper_scale_lr-1e-4_50ep.pt\")\n",
    "torch.save(ss_vae.state_dict(), \"models_and_losses/SSVAE_InceptionTime_proper_scale_lr-1e-4_state_dict_50ep.pt\")\n",
    "torch.save(ss_vae.encoder_y, \"models_and_losses/SSVAE_InceptionTime_proper_scale_classifier_lr-1e-4_50ep.pt\")\n",
    "torch.save(ss_vae.encoder_y.state_dict(), \"models_and_losses/SSVAE_InceptionTime_proper_scale_classifier_lr-1e-4_state_dict_50ep.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>3.790969</td>\n",
       "      <td>-23.990682</td>\n",
       "      <td>3170.526222</td>\n",
       "      <td>0.882942</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-95.137534</td>\n",
       "      <td>-125.194930</td>\n",
       "      <td>2064.785821</td>\n",
       "      <td>0.902850</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-125.611761</td>\n",
       "      <td>-150.325867</td>\n",
       "      <td>1792.657386</td>\n",
       "      <td>0.915074</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-142.399949</td>\n",
       "      <td>-165.782175</td>\n",
       "      <td>1635.480496</td>\n",
       "      <td>0.916242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-153.641615</td>\n",
       "      <td>-175.767372</td>\n",
       "      <td>1527.314026</td>\n",
       "      <td>0.910393</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   supervised_loss  unsupervised_loss  classification_loss  test_accuracy\n",
       "0         3.790969         -23.990682          3170.526222       0.882942\n",
       "1       -95.137534        -125.194930          2064.785821       0.902850\n",
       "2      -125.611761        -150.325867          1792.657386       0.915074\n",
       "3      -142.399949        -165.782175          1635.480496       0.916242\n",
       "4      -153.641615        -175.767372          1527.314026       0.910393"
      ]
     },
     "execution_count": 41,
     "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": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv(\"models_and_losses/SSVAE_CBN_proper_scale_lr-1e-4_100ep_losses.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pred = ss_vae.encoder_y(torch.tensor(X_test).float().cuda())\n",
    "preds = []\n",
    "ss_vae.encoder_y.eval()\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))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = np.hstack(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9406177712415476"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(y_true=y_test, y_pred=preds,average=\"macro\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9768164435946463"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_true=y_test, y_pred=preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4051,    42,    21,   121],\n",
       "       [   18, 10416,     1,    10],\n",
       "       [   34,     3,   428,    14],\n",
       "       [   69,    20,    35,  1453]], dtype=int64)"
      ]
     },
     "execution_count": 47,
     "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": [
    "       \n",
    "       [[ 3805,   296,    27,   107],\n",
    "       [   91, 10307,     8,    39],\n",
    "       [   22,     8,   425,    24],\n",
    "       [  169,    37,    20,  1351]] \n",
    "       InceptionTime best model so far\n",
    "       "
   ]
  },
  {
   "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
}