Tumor_Analysis.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rhausman/CAD_learning_experience_2018/blob/master/Tumor_Analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yx5WQsDz_OZk",
        "outputId": "a7e60998-453a-456a-fec0-dbc334925f7e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0TyY1y6_XMh"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install torchtest"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R6RlTQzzdICh",
        "outputId": "4fae0ef8-1674-4554-ff23-9717f803552f"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: torchtest in /usr/local/lib/python3.8/dist-packages (0.5)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.8/dist-packages (from torchtest) (1.13.1+cu116)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch->torchtest) (4.5.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "vJ58QIJP_AP3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "525d3169-102d-43d0-aa89-27545c93962a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7f079361d250>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#from sklearn.model_selection import train_test_split \n",
        "\n",
        "import torch\n",
        "from torch.utils.data import Dataset, DataLoader, random_split\n",
        "from torchvision import transforms\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "from torch import nn\n",
        "from torch.nn import functional as F\n",
        "import torch.optim as optim\n",
        "from torch._C import NoneType\n",
        "from torchtest import assert_vars_change\n",
        "\n",
        "import os\n",
        "from math import sqrt\n",
        "import time\n",
        "from copy import deepcopy\n",
        "import skimage \n",
        "from skimage import io\n",
        "from sklearn.metrics import RocCurveDisplay\n",
        "from sklearn.preprocessing import LabelBinarizer\n",
        "import plotly.express as px\n",
        "import plotly.figure_factory as ff\n",
        "from matplotlib import pyplot as plt \n",
        "\n",
        "from PIL import Image\n",
        "from IPython.display import clear_output\n",
        "# set seed for reproducability\n",
        "torch.manual_seed(42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmW-i0D1_euu"
      },
      "source": [
        "## Get the data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "m2wBI6n-_d9v",
        "outputId": "d6a856f6-fd04-471f-e277-c9c60f77e4fe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/kaggle\n",
            "brain-mri-images-for-brain-tumor-detection.zip: Skipping, found more recently modified local copy (use --force to force download)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' MORE DATA OPTIONS:\\n!kaggle competitions download -c hpa-single-cell-image-classification # whole cell image thing\\n\\n!kaggle datasets download -d dschettler8845/human-protein-atlas-yellow-cell-tile-dataset\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "os.environ['KAGGLE_CONFIG_DIR'] = \"/content/drive/MyDrive/kaggle\"\n",
        "%cd /content/drive/MyDrive/kaggle/\n",
        "!kaggle datasets download -d navoneel/brain-mri-images-for-brain-tumor-detection --unzip\n",
        "\"\"\" MORE DATA OPTIONS:\n",
        "!kaggle competitions download -c hpa-single-cell-image-classification # whole cell image thing\n",
        "\n",
        "!kaggle datasets download -d dschettler8845/human-protein-atlas-yellow-cell-tile-dataset\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7UHUMm7eIJ-H",
        "outputId": "a337def5-6a2d-4006-9acb-9e4b64776c3a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['kaggle.json',\n",
              " 'human-protein-atlas-yellow-cell-tile-dataset.zip',\n",
              " 'brain_tumor_dataset',\n",
              " 'no',\n",
              " 'yes',\n",
              " 'brain-mri-images-for-brain-tumor-detection.zip',\n",
              " '1676335239.pt',\n",
              " '1676336668.pt',\n",
              " '1676337773.pt',\n",
              " '1676339293.pt',\n",
              " '1676341225.pt',\n",
              " '1676341575.pt',\n",
              " '1676342570.pt',\n",
              " '1676343146.pt',\n",
              " '1676354204.pt',\n",
              " '1677558439.pt',\n",
              " '1677600789.pt',\n",
              " '1677601472.pt',\n",
              " '1677603110.pt',\n",
              " '1677611569.pt',\n",
              " '1677613092.pt',\n",
              " '1677614061.pt',\n",
              " '1677614140.pt',\n",
              " '1677614743.pt',\n",
              " '1677614811.pt',\n",
              " '1677615045.pt',\n",
              " '1677615995.pt',\n",
              " '1677616546.pt',\n",
              " '1678047583_ae.pt',\n",
              " '1678048679_ae.pt',\n",
              " '1678049426_cls.pt',\n",
              " '1678049683_cls.pt',\n",
              " '1678056135_ae.pt',\n",
              " '1678056510_ae.pt']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "os.listdir()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GwQVNBJKACJt"
      },
      "source": [
        "## Notes\n",
        "* Remove InvertColor transforms\n",
        "* Try using PCA to visualize the latent space. See if it separates the classes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AjO6ZutCDE_4"
      },
      "source": [
        "\\## Set up Dataset\n",
        "\n",
        "Notes:\n",
        "* Using a `RandomInvert()` transform is not intuitive because color-inverted images don't appear in the train or validation set, but it's desireable because: 1. Emperically, it SIGNIFICANTLY reduced overfitting in my case, and 2. It's possible that some computer systems that process brain scans could invert the color, and concievably a system using my model could recieve a color-inverted image."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "DxCOeBevBnkb"
      },
      "outputs": [],
      "source": [
        "DEFAULT_RES = 200\n",
        "class MyDataSet(Dataset):\n",
        "  def __init__(self, pos_dir: str, neg_dir: str, transform=None, res:int=DEFAULT_RES):\n",
        "    self.res = res\n",
        "    self.pos_dir = pos_dir\n",
        "    self.neg_dir = neg_dir\n",
        "    self.transform = transform\n",
        "    self.pos_filenames = [ os.path.join(pos_dir, x) for x in os.listdir(pos_dir)]\n",
        "    self.neg_filenames = [ os.path.join(neg_dir, x) for x in os.listdir(neg_dir)]\n",
        "\n",
        "    if not self.transform: # kind of need one. \n",
        "      self.transform_list = [\n",
        "          transforms.Resize([res, res]), # maybe should make this bigger\n",
        "          transforms.RandomHorizontalFlip(),\n",
        "          transforms.RandomVerticalFlip(),\n",
        "          #transforms.RandomRotation(15),\n",
        "          #transforms.RandomInvert(),\n",
        "          transforms.ToTensor(),\n",
        "          #transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "          ]\n",
        "      self.transform = transforms.Compose(self.transform_list)\n",
        "  \n",
        "  def get_mean_and_std(self):\n",
        "    loader = DataLoader(self, batch_size=10, num_workers=1, shuffle=False)\n",
        "    mean = 0.\n",
        "    std = 0.\n",
        "    nb_samples = 0.\n",
        "    for _data in loader:\n",
        "        data = _data[0]\n",
        "        batch_samples = data.size(0)\n",
        "        data = data.view(batch_samples, data.size(1), -1)\n",
        "        mean += data.mean(2).sum(0)\n",
        "        std += data.std(2).sum(0)\n",
        "        nb_samples += batch_samples\n",
        "    mean /= nb_samples\n",
        "    std /= nb_samples\n",
        "    return mean, std\n",
        "  \n",
        "  def set_up_normalization(self, mean, std):\n",
        "    self.transform_list.append(transforms.Normalize(mean=(mean), std=(std) ))\n",
        "    self.transform = transforms.Compose(self.transform_list)\n",
        "    print(\"Normalization added to transform\")\n",
        "    \n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.pos_filenames) + len(self.neg_filenames)\n",
        "\n",
        "  def __getitem__(self, x):\n",
        "    #print(\"Index: \", x)\n",
        "    img = None\n",
        "    tumor = None\n",
        "    if x < len(self.neg_filenames): # return a negative\n",
        "      img = self.get_single_image(self.neg_filenames[x])\n",
        "      tumor = 0\n",
        "    else: # return a positive\n",
        "      img = self.get_single_image(self.pos_filenames[x%len(self.neg_filenames)])\n",
        "      tumor = 1\n",
        "    img = img.convert('L')\n",
        "    if self.transform:\n",
        "      #print(\"transforming. shape before\", img.size)\n",
        "      img = self.transform(img)\n",
        "      #print(\"shape after\", img.size)\n",
        "    if img is None:\n",
        "      print(\"Problem: \", x%len(self.neg_filenames), self.pos_filenames[x%len(self.neg_filenames)])\n",
        "    #print(img.size())\n",
        "    return img, tumor\n",
        "\n",
        "  # filename should be absolute path\n",
        "  def get_single_image(self, filename):\n",
        "    img = Image.open(filename)#io.imread(filename)\n",
        "    if img is None:\n",
        "      print(\"YO: \", filename)\n",
        "    return img"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nsEvokzKIImo"
      },
      "source": [
        "## View Samples to see if it's working"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305
        },
        "id": "yii6pmm2IFal",
        "outputId": "351dd172-467a-4cc6-beaf-156ee0064ba7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normalization added to transform\n",
            "torch.Size([1, 200, 200])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def show_batch(batch):\n",
        "  batch = batch[0]\n",
        "  f, axarr = plt.subplots(2,2)\n",
        "  print(batch[0].size())\n",
        "  batch = [ np.squeeze(t.numpy(), axis=0) for t in batch ]\n",
        "  axarr[0][0].imshow(batch[0])\n",
        "  axarr[0][1].imshow(batch[1])\n",
        "  axarr[1][0].imshow(batch[2])\n",
        "  axarr[1][1].imshow(batch[3])\n",
        "  #print(batch, type(batch))\n",
        "\n",
        "ds = MyDataSet(pos_dir = \"/content/drive/MyDrive/kaggle/brain_tumor_dataset/yes\", neg_dir=\"/content/drive/MyDrive/kaggle/brain_tumor_dataset/no\")\n",
        "mean, std = ds.get_mean_and_std() # set up normalization with the same mean and td overall for each\n",
        "ds.set_up_normalization(mean, std)\n",
        "dl = DataLoader(ds, batch_size=4, shuffle=True, num_workers=0) # for now no extra workers\n",
        "\n",
        "for i, batch in enumerate(dl):\n",
        "  if i ==4:\n",
        "    show_batch(batch)\n",
        "    break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "frx4SoTAvOgB"
      },
      "source": [
        "# Classifier"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iLEa6PokUahT"
      },
      "source": [
        "## Model Definition - Classifier\n",
        "* Idea: VAE with one disentangled latent variable for tumor_presence (0 for no tumor, 1 for tumor)\n",
        "* This way it's both a predictor and example generator. \n",
        "1. to predict: embed an image and look at the latent variable value\n",
        "2. To generate: generate from point in latent space, control the latent variable as desired.\n",
        "* base on: https://ieeexplore.ieee.org/document/9291992 or another paper"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "rBAmSmhy_IOw"
      },
      "outputs": [],
      "source": [
        "# first I'll do a classifier\n",
        "class Classifier(nn.Module):\n",
        "  def __init__(self, res:int =DEFAULT_RES, confidence=0.75):\n",
        "    super(Classifier, self).__init__()\n",
        "    self.res = res\n",
        "    self.confidence = confidence\n",
        "    self.layers = []\n",
        "    s = (1, self.res, self.res)\n",
        "\n",
        "    self.layers.append(nn.Conv2d(1, 4, 5))\n",
        "    s = 4, s[1] - 4, s[2]-4 # stride is 2 i believe\n",
        "    self.layers.append(nn.MaxPool2d((2,2)))\n",
        "    s = s[0], s[1]/2, s[2]/2\n",
        "    self.layers.append(nn.Conv2d(4, 8, 10))\n",
        "    s = 8, s[1]-9, s[2] - 9\n",
        "    self.layers.append(nn.MaxPool2d(2))\n",
        "    s = s[0], (s[1]-1)/2, (s[2]-1)/2\n",
        "    self.layers.append(nn.Flatten())\n",
        "    s = s[0]*s[1]*s[2], None\n",
        "    self.layers.append(nn.Linear( int(s[0]), 120))\n",
        "    #self.layers.append(nn.ReLU())\n",
        "    self.layers.append(nn.Linear(120, 60) )\n",
        "    #self.layers.append(nn.ReLU())\n",
        "    self.layers.append(nn.Linear(60,20))\n",
        "    #self.layers.append(nn.ReLU())\n",
        "    self.layers.append(nn.Linear(20, 1))\n",
        "    self.layers.append(nn.Sigmoid())\n",
        "    #self.layers = [self.conv1, self.pool1, self.conv2, self.pool2, self.flatten, self.l1, self.l2, self.l3, self.l4, self.sigmoid]\n",
        "    # dropout?\n",
        "    self.seq = nn.Sequential(*self.layers)\n",
        "\n",
        "  def forward(self, x):\n",
        "    #print(\"input shape: \", x.shape)\n",
        "    #for i, layer in enumerate(self.layers):\n",
        "    #  x = layer(x) #F.relu(layer(x))\n",
        "      #print(f\"{i} shape: {x.shape}\")\n",
        "    x = self.seq(x)\n",
        "    return x # get in batch format\n",
        "  \n",
        "  def inference(self, x):\n",
        "    out = self.forward(x)\n",
        "    out = out > self.confidence\n",
        "    return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RwNRo_lo6H2D"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F28Ntxj_ceay",
        "outputId": "69a4adf6-6ca3-4ebd-e7d3-924d433f061a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normalization added to transform\n",
            "Train set: 203, Test set: 50\n",
            "Training model at  1678053259_cls.pt\n"
          ]
        }
      ],
      "source": [
        "# constants\n",
        "epochs = 40\n",
        "\n",
        "# data\n",
        "ds = MyDataSet(pos_dir = \"/content/drive/MyDrive/kaggle/brain_tumor_dataset/yes\", neg_dir=\"/content/drive/MyDrive/kaggle/brain_tumor_dataset/no\")\n",
        "mean, std = ds.get_mean_and_std() # set up normalization with the same mean and td overall for each\n",
        "ds.set_up_normalization(mean, std)\n",
        "train_set, test_set = random_split(ds, [0.8, 0.2], generator=torch.Generator().manual_seed(42)) # manual seed for reproducible result right now\n",
        "\n",
        "print(f\"Train set: {len(train_set)}, Test set: {len(test_set)}\")\n",
        "train_loader = DataLoader(train_set, batch_size=12, shuffle=True, num_workers=2) # for now no extra workers\n",
        "test_loader = DataLoader(test_set, batch_size=12, shuffle = False, num_workers=2)\n",
        "\n",
        "# save info\n",
        "model_save_name = str(int(time.time())) + \"_cls.pt\" # unique name\n",
        "save_path = f\"/content/drive/MyDrive/kaggle/{model_save_name}\"\n",
        "print(\"Training model at \", model_save_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 673
        },
        "id": "6htuQSQCeF37",
        "outputId": "2290c9ce-3f8e-44ad-cf2f-9aec76fde77e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 30 train loss: 1.9447893886826932\n",
            " test loss: 3.1381235273547645\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmbElEQVR4nO3deXxU1d3H8c/JvpCVLGxZ2QIiIEQBQUUBxaVVaxe1Lm212ket1ra22mdr+7R9nm5qq23VqtXWrdZi3VBZXFhElH3fk0BCEkJ2si/n+eMOgkggJJPM3Jnv+/XiNcnNzNzf5cI3Z84951xjrUVERNwnxNcFiIhIzyjARURcSgEuIuJSCnAREZdSgIuIuFRYf+4sJSXFZmdn9+cuRURcb/Xq1QettanHbu/XAM/OzmbVqlX9uUsREdczxhQdb7u6UEREXEoBLiLiUgpwERGXUoCLiLiUAlxExKUU4CIiLqUAFxFxKVcE+CvrSnjmw+MOgxQRCVquCPC3NpXx6JLdvi5DRMSvuCLAJ2clsa+qiQN1zb4uRUTEb7gmwAFWFVX7uBIREf/higA/bUgCkWEhrFaAi4h8whUBHhEWwoRhiWqBi4gcxRUBDjA5O4nNJbU0t3X4uhQREb/gmgDPz0qivdOyfl+Nr0sREfELrgnwSZnOhczVe9WNIiICLgrwpNgIhqfGsrpQAS4iAi4KcHCGE67eW4211teliIj4nKsCPD8rmZrGNnZXNPi6FBERn3NVgE/yTOhZXVTl40pERHzPVQE+PDWWxJhwTegREcFlAW6MYXJmkib0iIjgsgAHZ0LPnooGqhpafV2KiIhPuS/APePB16gVLiJBznUBPiEjkfBQowk9IhL0XBfgUeGhnDYkQRN6RCTouS7AwZnQs764htb2Tl+XIiLiM64M8PysJFraO9m8v9bXpYiI+IwrA3zyJxN61I0iIsHLlQGeFh9FRnK0AlxEgporAxz4ZEKPFrYSkWDl3gDPTqaivoXi6iZflyIi4hPuDfDMw3eq18JWIhKcXBvgowfFMSAyTP3gIhK0XBvgoSGGMzITWaUJPSISpE4a4MaYJ40xB4wxm47almyMWWiM2el5TOrbMo9vclYS28vrqW9u88XuRUR8qjst8KeAucdsuxdYbK0dCSz2fN/v8rOSsRbW7q3xxe5FRHzqpAFurV0CHHul8HLgac/XTwNXeLes7pmYmUiI0YQeEQlOPe0DT7fWlnq+LgPSu3qiMeYWY8wqY8yqioqKHu7u+AZEhpE3KF4BLiJBqdcXMa0zk6bL2TTW2sestfnW2vzU1NTe7u4zJmclsXZvNe0dWthKRIJLTwO83BgzGMDzeMB7JZ2a/OwkGlo72F5e76sSRER8oqcB/ipwo+frG4FXvFPOqZuUqYWtRCQ4dWcY4fPACmC0MabYGHMT8H/AHGPMTmC253ufGJYUTXp8pAJcRIJO2MmeYK29posfzfJyLT1ijGFyVpIm9IhI0HHtTMyjTc5KpqSmibLaZl+XIiLSbwIkwNUPLiLBJyAC/LQh8USFhyjARSSoBESAh4eGMH5YIqu1tKyIBJGACHBwbnS8eX8dTa0dvi5FRKRfBE6AZyfR3mlZX1zj61JERPpFwAS4JvSISLAJmABPjIlgRNoABbiIBI2ACXBw+sE/LqiisbXd16WIiPS5gArwL+UPo76lnRc/3ufrUkRE+lxABfjkrGTys5L489ICLS8rIgEvoAIc4NbzhlNS08QbG0tP/mQRERcLuACflZfGiLQBPPL+Hpx7TYiIBKaAC/CQEMMt5+aytbSOpTsP+rocEZE+E3ABDnD5xCGkx0fy6JLdvi5FRKTPBGSAR4aF8o3pOSzfVcnG4lpflyMi0icCMsABrpmSSVxkGI+oFS4iASpgAzw+KpyvTs3izY2lFFU2+LocERGvC9gAB/j69GzCQkJ4fGmBr0sREfG6gA7w9PgorjxjKC+u2sfBQy2+LkdExKsCOsABvnluLq0dnfz1g0JflyIi4lUBH+Aj0gYwZ0w6T68ooqFFi1yJSOAI+AAHZ3p9bVMbL67SIlciEjiCIsAnZyVxZnYSjy8toE2LXIlIgAiKAAe49VzPIlcbtMiViASGoAnwC/LSGJk2gEfe361FrkQkIARNgB9e5GpbWT1LtMiViASAoAlwgMsnDiU9PpJH3tP0ehFxv6AK8IiwEG6akcOKPZWs31fj63JERHolqAIc4JqzMomLCuOxJXt8XYqISK8EXYDHRYVz3dQs3thYyo9f3aw72IuIa4X5ugBfuGvWSBpa2nnqg0IWbyvn/74wnukjUnxdlojIKelVC9wYc7cxZrMxZpMx5nljTJS3CutLUeGh/PTycfz9lqmEhYTw1cdXct+8DdQ1t/m6NBGRbutxgBtjhgJ3AvnW2nFAKHC1twrrD1NyB/LmXedw67m5/P3jfVx4/xIWby33dVkiIt3S2z7wMCDaGBMGxAD7e19S/4oKD+W+S8bw8m3TSYgO56anV/GdF9ZS1dDq69JERE6oxwFurS0BfgPsBUqBWmvtAm8V1t8mZCTy2rdncNeskby+oZQ597/PGxtKNWtTRPxWb7pQkoDLgRxgCBBrjLnuOM+7xRizyhizqqKioueV9oOIsBDunjOK1++cwdCkaG5/bg23/G01S3dW0NquRbBExL+YnrYwjTFfAuZaa2/yfH8DMNVae1tXr8nPz7erVq3q0f76W3tHJ08sK+DBRTtpausgLjKMmXlpzB6TxszRaSREh/u6RBEJEsaY1dba/GO392YY4V5gqjEmBmgCZgHuSOduCAsN4dbzhnPDtGyW7TrIoi3lLN5Wzmvr9xMWYpiaO5DZY9KYPTadYUkxvi5XRIJQj1vgAMaYnwBfAdqBtcDN1toubz7pphb48XR0Wtbtq2HhlnIWbiljd4Vzt/uxg+OZMzada87KZFCCK0ZSioiLdNUC71WAnyq3B/ix9lQcYtHWchZuKWd1UTVhoSF8dUom/zZzOGlxCnIR8Q4FeB/bV9XIQ+/s5J9rSggPNdw4LZtbzxtOcmyEr0sTEZdTgPeTwoMN/G7xTv61roSY8FC+Pj2Hb56TS0KMLnqKSM8owPvZrgP1PLBoJ29sKCUuKoybZ+TyjRnZxEUpyEXk1CjAfWRraR0PLNzBgi3lJMaEc8u5udw4LZvYyKBcR0xEekAB7mMbi2u5f+F23t1eQVJMODefk8sN07LUIheRk1KA+4k1e6t5aPFO3t1e4ay9MiOHG8/O1sQgEemSAtzPbCiu4feLd7FoazlxUWF8fXoO35ieTWKMRq2IyKcpwP3UppJaHn5nF29tLmNAZBg3np3FTTNyNfxQRD6hAPdz28rqeOidXczfWEp0eCjXT8vi1nM1jlxEug7woLsnpr/KGxTPH66dxILvnMucsen8eckePv/wMgoPNvi6NBHxUwpwPzMyPY7fXX0G826bTkNLO198ZAVbS+t8XZaI+CEFuJ+amJHIi7dOIyzE8JVHV7C6qNrXJYmIn1GA+7GR6XH841vTSIqN4LrHV7J0p3/fEENE+pcC3M9lJMfwj29NI2tgDDc9tYq3NpX6uiQR8RMKcBdIi4vi77dMY9zQeG57dg3/WLXP1yWJiB9QgLtEQkw4z9w8hekjUrjnpQ08sazA6/uw1rK6qIq/fVhER6du5izi77SikovERITx+I353PX8Ov7n9S3UNrVx9+yRGGN69b6Nre28sm4/f1tRxBbPiJfaxlbuuGCkN8oWkT6iAHeZyLBQHr72DO6bt5HfL95JXVMb/3XZWEJCTj3ECw428LcVRfxj9T7qm9vJGxTHz68cx4d7qrh/4Q7OzE5mSu7APjgKEfEGBbgLhYWG8MurxhMfHc4TywrYWFLL6UMTyE2NJXtgLDkpsQxJjCb0OKHe0Wl5Z9sB/rqikKU7DxIWYrj49MFcPzWLM7OTMMZw+cShbCqp5c4X1jL/znMYOCDSB0cpIiejqfQuZq3liWUFvLy2hIKDDTS2dnzys4jQEDIHxpCT4gR69sBYqhtbeW7lXkpqmhgUH8W1UzK5+qyM496/c/P+Wq784wecPXwgT954Zo9a+CLiHVoLJcBZa6mob2HPwQYKDzZQcNSfoqpGWts7AZiWO5AbpmUxZ2w6YaEnvob9txWF/Ocrm7nv4jxuPW94fxyGiBxHVwGuLpQAYYwhLT6KtPgoph7Tb93RaSmtbcJaZ1x5d103NYsVeyr59dvbyc9OZnJWkrfLFpFe0DDCIBAaYhiWFHNK4Q3OL4X//cJ4BidGcefza6lpbO2jCkWkJxTgckIJ0eE8fM0kDtQ3c89LG+jPLjcROTEFuJzUhIxEfjg3j4VbyvnL8kJflyMiHgpw6ZabZuQwe0w6//vmVjYU1/i6HBFBAS7dZIzhN18aT+qASO54bi11zW2+Lkkk6CnApdsSYyJ46NozKKlp4t5/qj9cxNcU4HJKJmcl8/0LRzN/YxnPrtzr63JEgprGgcspu/XcXFbsqeSnr2+h01quPSvzpJOCRMT79L9OTllIiOGBL09gUmYi//XKZi75/VLdLUjEBxTg0iMDB0Ty/Den8sh1k2hq6+D6Jz7i5qc/Zk/FoVN+r4aWduatKebmpz/mlXUlfVCtSGBSF4r0mDGGueMGM3N0Gn9ZXsjD7+zkogeXcOO0bL49ayQJ0eFdvraj0/Lhnkr+uaaYtzaV0djaQVR4CO9tryApJoJzR6X245GIuFOvFrMyxiQCjwPjAAt8w1q7oqvnazGrwHagvpnfvr2DF1fvIykmgu/OGcXVZ2Z8qn98Z3k9/1xTwivrSiitbSYuKozLxg/mC5OGMXpQHF9+ZAXF1U28eOs0xg6J9+HRiPiPPlmN0BjzNLDUWvu4MSYCiLHW1nT1fAV4cNhUUstPX9vCR4VV5A2K4/sXjmZfdSPz1pSwsaSW0BDDeaNS+cKkocwek05UeOgnry2rbebKPy7HWnj59rMZnBDtwyMR8Q9eD3BjTAKwDsi13XwTBXjwsNby5qYyfjF/K8XVTQCMGxrPF84YxucmDCE1ruubRGwrq+NLf1rB0KRoXvzWNOKjuu6KEQkGfRHgE4HHgC3ABGA1cJe1tuGY590C3AKQmZk5uaioqEf7E3dqbutg4ZZyRqXHMXpQXLdft3zXQW588iOm5Cbzl6+dRUSYrrdL8OoqwHvzvyIMmAT8yVp7BtAA3Hvsk6y1j1lr8621+ampujAVbKLCQ/nchCGnFN4A00ek8MurxrN8VyX3zjv1WZ+ltU3cN28jdzy3hp3l9af0WhG36M0olGKg2Fq70vP9SxwnwEV66qrJwyipaeL+hTsYlhTDd+eMOulrDrW08+j7u/nz0j10dkJkWAhvbirjmrMyuHv2KN3fUwJKjwPcWltmjNlnjBltrd0OzMLpThHxmm9fMILi6kZ+v3gnwxKj+fKZGcd9XntHJ39ftY8HFu7g4KFWPj9hCPdcNJrYyDB+t2gHz6zcyytr93PHBSP42vRsIsNCj/s+Im7S21EoE3GGEUYAe4CvW2uru3q+LmJKT7R1dPKNpz7mg92VPPm1MznvqDHi1lre217BL+ZvZeeBQ5yVncyPLh3DxIzET73HrgOH+MX8rbyz7QAZydHcO3cMl5w+CGN0s2bxf7qpsbhafXMbX370Q/ZWNvDit6Zx2pAENu+v5Rfzt7J8VyU5KbHce3EeF45NP2EoL91Zwc/f2Mq2snrys5L4j8vGfibsRfyNAlxcr7yumSv/sJz2TsuMESm8vK6ExOhw7po1kmunZHV7pEpHp+Ufq/bxmwU7OHiohSsmDuGeuXkMTdSYc/FPCnAJCNvL6vninz6gpb2Tr8/I5raZI044Zf9EDrW088h7zgXPyLAQXrljBjkpsV6uWKT3FOASMPZVNRIWarw2S7PgYANf+ONyUuMiefm26cRGaokg8S99MQ5cxCcykmO8OsU+JyWWh66ZxK4Dh/iB7jQkLqIAFwFmjEzhh3PzeGNDKY8t2ePrckS6RQEu4nHLublcevpgfvnWNpbtPOjrckROSgEu4mGM4VdfHM+ItAF8+/k17Ktq9HVJIiekABc5SmxkGI9en097p+Vbz6ymua3D1yWJdEkBLnKMnJRYHvzKRDbvr+NHL2/URU3xWwpwkeOYNSad78weybw1Jfx1hZZAFv+kABfpwp0XjGT2mDT+5/UtfFRQ5etyRD5DAS7ShZAQw/1fmUhGcgy3PbuGstrmXr9nS3sHeysbWbG7knlrinliWQGltU1eqFaCkWZiipzEjvJ6rvjDckYPiuOFW6Z2uRRtY2s7B+paOFDfQnldM6W1TeyvcR5La5vZX9PMwUMtn3ldyoBIHr1+EpOzkvv6UMSlNJVepBfmbyzltmfXcNn4wUzMSPwkpA/UtVBe30xFXQv1Le2feV1sRChDEqMZnBjNkIQoBidEMzgxiiGex6bWDm5/bg2lNc387MpxfDn/+OudS3BTgIv00q/f3sYf3t0NOHf6SY+PIi0ukrT4SNLioo48erYNTogmPirspGuO1zS2cvtza1i+q5KbZuRw38V5hIWqd1OOUICLeMH+miZiI8O6Fcynor2jk5+9sZWnPijknJEpPHzNJBJierbKogQeLWYl4gVDEqNJiA73+p18wkJD+PHnT+OXV53Oh3squeKPy9l14JBX9yGBRwEu4ke+cmYmz39zKvXNbVz5h+W8u/2Ar0sSP6YAF/Ez+dnJvHLHDDIHxvCNpz7msSW7NRtUjksBLuKHhiZG89K3zuaS0wfzi/nb+N6L67Uui3yGbj0i4qeiI0J5+JozGDMojt8s2MGuikM8ct1khujeneKhFriIHzPGcMcFI/nzDfnsqWjgcw8t48M9lb4uS/yEAlzEBeaMTedft08nMSacrz6+kieXFahfXBTgIm4xIm0A/7p9OrPy0vjp61v47ovraWpVv3gwU4CLuEhcVDiPXDeZ780Zxb/WlfDFRz7QnYOCmAJcxGVCQgzfnjWSJ288k71VjXz+4WW6h2eQUoCLuNT5eWm8dscMUuMiueHJlTz6vu/Gi5fXNfPq+v10dqpfvj9pGKGIi2WnxPLybdO556X1/O+b29hQUsuvrhpPbGT//Nfu6LQ8u7KIX7+1nfqWdg41t3PtlMx+2bdoMSuRgGCt5dEle/jVW9uICAthclYSU3IGMiUnmYmZiV2uYd4bm/fX8qN5G1lfXMuMESk0tXWws7yexd+bSWpcpNf3F8y0GqFIEFhdVMVr60tZWVDFtrI6rIWIsBDOyEhkau5ApuQmMykziajwngd6Q0s7Dy7awZPLC0mKCec/Lh3L5ROHsLuigYt/t4TLxg/hga9M9N5BiQJcJNjUNLbycWE1H+6pZGVBJVv219FpISI0hAkZCUzJGchZOclMykpiQDe7XBZtKee/XtnE/tpmrjkrgx/OzSMxJuKTn/92wXYeemcXz948hekjUvrq0IKOAlwkyNU1t7GqsIqVe6r4cE8lm/bX0dFpCQ0xjBsSz1k5yZyVM5Azs5M+FcoApbVN/PjVzby9uZxR6QP4xZWnk5/92VvANbd1cNGDSwgxhjfvOqdXLX05QgEuIp9yqKWdNUXVfFRQxUeFVazbV0NreycAeYPiOCsnmTOzkzlQ38L9C7bT3mm5a/ZIbp6RS0RY1wPYluyo4IYnP+I7s0fyndmj+utwAlqfBbgxJhRYBZRYay870XMV4CL+q7mtgw3FtXxUUMnKgipWF1XT6Jnpee6oVH52+TgyB8Z0672+/fxa3t5Uxtt3n0tOSmxflh0U+jLAvwvkA/EKcJHA0d7Ryeb9dTS1dTAlJ/mU7kJ0oK6ZWb99n/EZCTxz0xSv38Eo2PTJLdWMMcOAS4HHe/M+IuJ/wkJDmOAZvXKqAZwWH8UP5o5m+a5KXl2/v48qlN7OxHwQ+AHQ2dUTjDG3GGNWGWNWVVRU9HJ3IuIW107JYsKwBP7n9S3UNrb5upyA1OMAN8ZcBhyw1q4+0fOstY9Za/Ottfmpqak93Z2IuExoiOHnV55OVUMrv3p7m6/LCUi9aYFPBz5vjCkEXgAuMMY845WqRCQgjBuawNfOzuG5j/ayZm+1r8sJOD0OcGvtfdbaYdbabOBq4B1r7XVeq0xEAsJ3LxxFelwU//7yJto7uuxtlR7QaoQi0qcGRIbx48+PZWtpHU99UOjrcgKKVwLcWvveyYYQikjwuui0QczKS+P+hTsoqWnydTkBQy1wEelzxhh+/PnT6LSWn7y62dflBAwFuIj0i4zkGL4zexQLtpTzw5c2UNPY6uuSXE83dBCRfnPzjByqG1t5fGkBi7aW8x+XjeGKiUM1U7OH1AIXkX4TFhrCfReP4bU7ZpCRHMPdf1/PdU+sZE/FIV+X5koKcBHpd2OHxDPv387mZ1eMY0NxLXMfXMqDi3bQ0t7h69JcRQEuIj4REmK4bmoWi793HheNG8SDi3Zy8e+WsmJ3Zbffo7PTUlbbTFuQji/XeuAi4hfe31HBf/5rE3urGrlq0jD+/dIxJMdG0NLeQXF1E0WVDRRVNlJU2cjeqkYKKxsormqitaOTL04exm++NMHXh9BndEMHEfF7zW0dPPTOTh59fw8xEaHERYWzv7aJo2MqNiKUzIGxZCXHkDUwhuKaJt7YUMq8285mUmaS74rvQ10FuEahiIjfiAoP5Z6L8rh84lAeemcXoQayBg4ja6AT1pnJsaQMiPjUqJWGlnY+LqjiJ69t4eV/O5uQkOAZ0aIAFxG/Myo9joeuOaNbz42NDOPei/P47ovreXltCVdNHtbH1fkPXcQUEde7YuJQJmYk8su3tnGopd3X5fQbtcBFxPVCQgz//bmxXPnHD/jju7v4wdy8vt1hayOs/gvsXAi2myNgLv8DJGZ4tQwFuIgEhDMyk/jCpKE8vrSAq8/M7PYNmE9JWxOs+gssfxAOlUP6OIgY0M0Xe3/AiAJcAk97C+z9EHYtgupC7753eDRkToPh50NStnffW3rth3PzeGtTGT+fv4VHr//MoI2ea2uC1U/Bsgec4M45F770FGSd7b199IACXAJDdRHsWgi7FsOe96GtAULCITkXjBcv9TRVwYa/O18n50Lu+TD8Asg5B6ISvLcf6ZH0+ChuP38Ev357O8t3HWT6iJTevWFb81HBXQbZ58AX/wLZ071Sb2+5Yxz4+hegclf3nhudDKMugoHDT30/4h5tzVC03Gll71oEB3c42xMzYcQcGDHbaSVFdvfjbTdZ6+xr97uw+x0oXOb8sjChMCzfE+jnw9DJEBru3X1LtzS3dTDngfeJDg9l/p3nEBbag1/gbc2w5mknuOtLIWs6zLzP+UXtA+6eyPPcV2Dngu499/AFhZTRkHcJjL4EhuZDiAbcuF7l7iOBXbAU2psgNBKyZ8BIT2gPHAH9ubJdeysUfwx7PIG+f63zbzAy3mmtDfe00JNz+7euIPfWpjK+9cxqfnr5adwwLbv7L2xrhrV/g6X3Q/1+yDwbzr/POZc+PH/uDvBTUV0EO96CbW84LbTOdohNg9FzYfSlkHue048p/q+10Wnh7lroXO2vLnC2Jw93wnrkHKdlFNEHF6t6qqkaCpY4Yb77XagpcrYnZMLwmU4LPXcmxCT7ssqAZ63lq4+vZPP+Ot77/kySYiNO/IL2Fljz1yPBnTHVCe6c8/ziF2/wBPjRmqph5yLY/obz2FoP4TFOi2j0JTBqLsQO7L965MSshYM7PX3Zi6BwOXS0OOcs+xxPK3uW05p1i6o9R7pbCpZCSy1gYMjEI/3nGWdBWKSvKw0428rquOR3S7l+ahY/uXzc8Z/U3gJrn3GCu64YMqY4XSW5M/0iuA8LzgA/WnsrFC6F7fNh+5tQV+Jc3MqYCqMvhrxL1W/uCy2HnBbr4dCu2etsTxl9JLAzz4bwKN/W6Q0d7U4Xy+53nC6X4o+dT4jhMc4nicPdLal5fhUebvaf/9rEcx/tZf6d5zB6UNyRH7S3wrpnYMlvneAedqYT3MMv8Mu/ewX40ayF0nVOkG+bD+Ubne2f9Jtf6lyEUr+591kLB7YeCeyiFdDZ5oylzTkPRs52ukcSM31dad9rrnO6iPa867TSK3c62+MGOy3Aw90tcem+rNLVqhtamfmb9xg3NJ5nbpqC6WiD9c85wV2717k+dv59MHyWXwb3YQrwE6kucsJ8+xvOx3bbAQPSnS6W0ZcEV7+5tdDa4N33bG+BomWeC5CLnU8/AGmneQJ7jvPRNewk/ZSBrmbfkTDf854zZBGcySK5MyHBy2t8RMZD6mhIGQVR8d59bz/y1PICfvbaBl6ZvpfTdj/mfMobOhlm/sj5hOfHwX2YAry7mqqdC2bb53+23zzvUhh5kTv7zdtbnQkIhw4441kPf11fdtS2A872jj662WxkgnMhb4SnlR0/pG/2Ewg6O6Fsw5Hulr0f9t15AYgf6oR5at6nH6NdvjxrRxvt656n4vWfMdiW0zlkEiHn/8j59+eC4D5MAd4T7S1Ov/k2T795/X6n3zxzmtNvPvoS3/abWwvNtZ8O4PrD4Vz+6XBuqj7+e8QMdD5tHP4Tl+6Mpffm5BcT4rR4huVrbHRPtbdAW6N337OxCiq2Q8W2I48Hd3x6PwPSjxPsY/y/EdPR5ky4WvJrqC6kPvl07iybS/bUK/jhxWOICg/1dYWnRAHeW4f7zbfNd1rn5Zuc7al5R41o6eWsr2N1Gc5HbWtv/uzrQiOdIB5w7J80iBt05PvYVHVbyKd1dkLtvmOCfavz2HrUjYdjUj7bWk/Nc/6N+bJl29F+VHAXwOCJzsXJURfx/Zc28NLqYoYkRHHX7JFcNWlYzyb5+IAC3NuO12/e16KTj7SSDwfygEHHbEt3pnS76OOhuIC1zrWLo1vrFdvhwDbP0EiPqMTjB3v8kL79N9nRDhv/AUt+5QzdHDQezv+R07Dy7Nday/Jdlfx6wXbW76shJyWWu+eM4rLTB/v9TSAU4H2pqdoZTdDq5Y+4kXFHwjk2VWOFxf9Y63wqrNjmhPlBT6hXbP10t11EnBPmaXnObNkwLw4LbWtyxnJX7YZBpzst7tGXdPkLw1rLwi3l/HbBDraX15M3KI57LhrNBXlpn7rTjz9RgItI/7EWGg56WurHtNobDnh/f+mnw8x7nYEG3Qzhjk7La+v388CiHRRVNjIpM5F7Lspj2nD/699XgIuIf2ipdyYweVNUYo+7aNo6OvnHqmJ+v3gnZXXNzBiRwt1zRjE5y39G4CjARUROoLmtg2c+LOKP7+2mqqGVCcMSuGFaNpeOH+zzUSsKcBGRbjjU0s68NcU8/UEhuysaSI6N4OozM7huahZDEn0zoU8BLiJyCqy1fLC7kqc+KGTx1nIALhw7iBvOzmJa7sB+veDZVYDrjjwiIsdhjGH6iBSmj0hhX1Ujz67cywsf7+WtzWWMSh/ADdOyufKMocRG+i5Ge9wCN8ZkAH8F0nHu1vmYtfZ3J3qNWuAi4mbNbR28un4/T39QyOb9dcREhDJzdCoXnTaImaPTSIjum5nGXu9CMcYMBgZba9cYY+KA1cAV1totXb1GAS4igcBay5q91by0uoRFW8upqG8hLMQwbfhALjxtEHPGpDMowXtj3fu8D9wY8wrwsLV2YVfPUYCLSKDp7LSs3VfDgi1lLNhcTsFBZzXPCRmJXHRaOheOHcSItN7dm7VPA9wYkw0sAcZZa+uO+dktwC0AmZmZk4uKinq9PxERf2StZXfFId7eXM6CzWWsL3aWGchNjeWR6yYzKj3uJO9wfH0W4MaYAcD7wM+ttfNO9Fy1wEUkmJTWNrFoSzmLtx3gD9dO6vEFzz4ZhWKMCQf+CTx7svAWEQk2gxOiuX5aNtdPy+6T9+/xWorGGQT5BLDVWnu/90oSEZHu6M1iuNOB64ELjDHrPH8u8VJdIiJyEj3uQrHWLgP8c+1FEZEg4I7bUYiIyGcowEVEXEoBLiLiUgpwERGXUoCLiLhUv64HboypAHo6lz4FOOjFcnwpUI4lUI4DdCz+KlCOpbfHkWWtTT12Y78GeG8YY1YdbyqpGwXKsQTKcYCOxV8FyrH01XGoC0VExKUU4CIiLuWmAH/M1wV4UaAcS6AcB+hY/FWgHEufHIdr+sBFROTT3NQCFxGRoyjARURcyhUBboyZa4zZbozZZYy519f19JQxptAYs9Gz9K6rbk1kjHnSGHPAGLPpqG3JxpiFxpidnsckX9bYXV0cy4+NMSVuWhrZGJNhjHnXGLPFGLPZGHOXZ7vrzssJjsWN5yXKGPORMWa951h+4tmeY4xZ6cmxvxtjInq9L3/vAzfGhAI7gDlAMfAxcI21dotPC+sBY0whkG+tdd3EBGPMucAh4K/W2nGebb8Cqqy1/+f5xZpkrf2hL+vsji6O5cfAIWvtb3xZ26kwxgwGBltr1xhj4oDVwBXA13DZeTnBsXwZ950XA8Raaw957lq2DLgL+C4wz1r7gjHmEWC9tfZPvdmXG1rgZwG7rLV7rLWtwAvA5T6uKehYa5cAVcdsvhx42vP10zj/4fxeF8fiOtbaUmvtGs/X9cBWYCguPC8nOBbXsY5Dnm/DPX8scAHwkme7V86LGwJ8KLDvqO+LcemJxTmJC4wxq40xt/i6GC9It9aWer4uA9J9WYwX3GGM2eDpYvH7boejGWOygTOAlbj8vBxzLODC82KMCTXGrAMOAAuB3UCNtbbd8xSv5JgbAjyQzLDWTgIuBm73fJQPCNbpi/Pv/rgT+xMwHJgIlAK/9Wk1p8AYMwDn5uLfsdbWHf0zt52X4xyLK8+LtbbDWjsRGIbTi5DXF/txQ4CXABlHfT/Ms811rLUlnscDwMs4J9bNyj19l4f7MA/4uJ4es9aWe/7TdQJ/xiXnxtPH+k/gWWvtPM9mV56X4x2LW8/LYdbaGuBdYBqQaIw5fBtLr+SYGwL8Y2Ck5wpuBHA18KqPazplxphYz8UZjDGxwIXAphO/yu+9Ctzo+fpG4BUf1tIrhwPP40pccG48F8ueALZaa+8/6keuOy9dHYtLz0uqMSbR83U0zgCMrThB/kXP07xyXvx+FAqAZ+jQg0Ao8KS19ue+rejUGWNycVrd4NxM+jk3HYcx5nlgJs6ymOXAfwP/Al4EMnGWCf6ytdbvLw52cSwzcT6mW6AQuPWofmS/ZIyZASwFNgKdns0/wuk7dtV5OcGxXIP7zst4nIuUoTiN5BettT/1ZMALQDKwFrjOWtvSq325IcBFROSz3NCFIiIix6EAFxFxKQW4iIhLKcBFRFxKAS4i4lIKcBERl1KAi4i41P8DRWpqoZ8fYkcAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-68-1b40453f3163>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss_fxn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m     \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# retain_graph=True for multi losses?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m     \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    486\u001b[0m                 \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    487\u001b[0m             )\n\u001b[0;32m--> 488\u001b[0;31m         torch.autograd.backward(\n\u001b[0m\u001b[1;32m    489\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    490\u001b[0m         )\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    195\u001b[0m     \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    196\u001b[0m     \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 197\u001b[0;31m     Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m    198\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    199\u001b[0m         allow_unreachable=True, accumulate_grad=True)  # Calls into the C++ engine to run the backward pass\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "net = Classifier()\n",
        "loss_fxn = nn.BCELoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-7) # todo try adding l2 regularization with: weight_decay=1e-5\n",
        "\n",
        "train_losses = []\n",
        "test_losses = []\n",
        "for epoch in range(epochs):\n",
        "\n",
        "  running_loss = 0.\n",
        "  for i, batch in enumerate(train_loader):\n",
        "    X, y = batch\n",
        "    optimizer.zero_grad()\n",
        "    output = net(X)\n",
        "    output = torch.squeeze(output, 1)\n",
        "    loss = loss_fxn(output, y.float())\n",
        "    loss.backward() # retain_graph=True for multi losses?\n",
        "    optimizer.step()\n",
        "\n",
        "    #print(f\"Output: {output}, labels: {y}, loss: {loss.item()}\")\n",
        "    #stats\n",
        "    running_loss += loss.item()\n",
        "  # save model each epoch\n",
        "  torch.save(net.state_dict(), save_path)\n",
        "  train_losses.append(running_loss)\n",
        "  # see the validation loss\n",
        "  if epoch % 5 == 0:\n",
        "    net.eval()\n",
        "    with torch.no_grad():\n",
        "      test_loss = 0.\n",
        "      for i, batch in enumerate(test_loader):\n",
        "        X, y = batch \n",
        "        output = net(X)\n",
        "        output = torch.squeeze(output, 1)\n",
        "        loss = loss_fxn(output, y.float())\n",
        "        test_loss += loss.item()\n",
        "      if len(test_losses) > 0:\n",
        "        fill_losses = np.linspace(test_losses[-1], test_loss, 4)\n",
        "        test_losses.extend(list(fill_losses))\n",
        "      test_losses.append(test_loss)\n",
        "    net.train()\n",
        "    \n",
        "  # Display output!\n",
        "  clear_output(wait=True)\n",
        "  print(f\"Epoch {epoch} train loss: {train_losses[-1]}\\n test loss: {test_losses[-1]}\")\n",
        "  plt.plot(train_losses)\n",
        "  plt.plot(test_losses)\n",
        "  plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Id0Rj_hJY1YJ"
      },
      "source": [
        "## Validation \n",
        "* Validate on train and validation data to see if the issue is overfitting or mere underperformance/underfitting\n",
        "\n",
        "Good models so far:\n",
        "* 1676343146.pt\n",
        "* 1676354204.pt (fantastic. 40 epochs. I recently discoverd bug in training code)\n",
        "* 1677601472.pt (good performance, but somewhat overfit. Inversion was not used for this model)\n",
        "* 1677603110.pt (This didn't do so great, though inversion was used)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OaexH9QNNvSD",
        "outputId": "9389d372-ebf6-4d7c-d997-6fdb12f11bb6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Selected model for evaluation:  /content/drive/MyDrive/kaggle/1678049683_cls.pt\n"
          ]
        }
      ],
      "source": [
        "desired_model_name = None #'1676354204.pt'\n",
        "desired_model_path = os.path.join(\"/content/drive/MyDrive/kaggle\", sorted([ x for x in os.listdir() if \"_cls.pt\" in x ])[-1] if desired_model_name is None else desired_model_name)\n",
        "print('Selected model for evaluation: ', desired_model_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "gZRfSYvw61SI"
      },
      "outputs": [],
      "source": [
        "net = Classifier()\n",
        "net.load_state_dict(torch.load(desired_model_path))\n",
        "net.confidence = 0.5\n",
        "net.eval()\n",
        "\n",
        "def evaluate(model, loader):\n",
        "  all_preds = []\n",
        "  all_labels = []\n",
        "  for i, batch in enumerate(loader):\n",
        "    X, y = batch\n",
        "    out = model(X)\n",
        "    all_preds += list(out.detach().squeeze(1).numpy())\n",
        "    all_labels += list(y.numpy())\n",
        "  \n",
        "  \n",
        "  all_preds_binary = np.array(all_preds) > net.confidence\n",
        "  all_labels = np.array(all_labels)\n",
        "  f_neg, f_pos, t_neg, t_pos = (np.logical_and(all_preds_binary==0, all_labels==1).sum(), \n",
        "                              np.logical_and(all_preds_binary==1, all_labels==0).sum(), \n",
        "                              np.logical_and(all_preds_binary==0, all_labels==0).sum(), \n",
        "                              np.logical_and(all_preds_binary==1, all_labels==1).sum()\n",
        "                              )\n",
        "  n = float(len(all_labels))\n",
        "  print(f\"False negatives: {f_neg} ({100*f_neg/n}% of total)\")\n",
        "  print(f\"False positives: {f_pos} ({100*f_pos/n}% of total)\")\n",
        "  print(f\"True negatives:  {t_neg} ({100*t_neg/n}% of total)\")\n",
        "  print(f\"True positives:  {t_pos} ({100*t_pos/n}% of total)\")\n",
        "\n",
        "  # ROC curve\n",
        "  #breakpoint()\n",
        "  #breakpoint()\n",
        "  binary_converter = LabelBinarizer().fit( list(all_labels) + [2])\n",
        "  y_onehot = binary_converter.transform( np.array(list(all_labels)))\n",
        "  y_score = all_preds\n",
        "  pos_class = \"Tumor present\"\n",
        "  class_id = 1 #np.flatnonzero(binary_converter.classes_ == pos_class)[0]\n",
        "  RocCurveDisplay.from_predictions(\n",
        "    y_onehot[:, class_id],\n",
        "    np.array(y_score),\n",
        "    name= pos_class,\n",
        "    color=\"darkorange\",\n",
        "  )\n",
        "  plt.plot([0, 1], [0, 1], \"k--\", label=\"chance level (AUC = 0.5)\")\n",
        "  plt.axis(\"square\")\n",
        "  plt.xlabel(\"False Positive Rate\")\n",
        "  plt.ylabel(\"True Positive Rate\")\n",
        "  plt.title(\"ROC Curve for Tumor Detection\")\n",
        "  plt.legend()\n",
        "  plt.show()\n",
        "\n",
        "  # confusion matrix. Vertical axis is label, horizontal is prediction\n",
        "  z = [[t_neg, f_pos], [f_neg, t_pos]]\n",
        "  z_text = [[str(val) for val in row] for row in z]\n",
        "  axis_labels = [\"No Tumor\", \"Tumor\"]\n",
        "  fig = px.imshow(z, text_auto=True, title=\"Confusion Matrix\", ) #ff.create_annotated_heatmap(z, x=axis_labels, y=axis_labels, annotation_text = z_text)\n",
        "  #fig.update_layout(title_text='<b>Confusion Matrix</b>', )\n",
        "  fig.update_xaxes(title=\"Prediction\")\n",
        "  fig.update_yaxes(title=\"Actual Value\")\n",
        "  fig.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 891
        },
        "id": "G2jmRPhnkYEd",
        "outputId": "1c0997f0-9625-4303-e86e-1fb2bb7a34eb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False negatives: 5 (10.0% of total)\n",
            "False positives: 5 (10.0% of total)\n",
            "True negatives:  11 (22.0% of total)\n",
            "True positives:  29 (58.0% of total)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<html>\n",
              "<head><meta charset=\"utf-8\" /></head>\n",
              "<body>\n",
              "    <div>            <script src=\"https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-AMS-MML_SVG\"></script><script type=\"text/javascript\">if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}</script>                <script type=\"text/javascript\">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>\n",
              "        <script src=\"https://cdn.plot.ly/plotly-2.8.3.min.js\"></script>                <div id=\"e3ef7a5a-6859-481b-a993-efb5f2765cc8\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"e3ef7a5a-6859-481b-a993-efb5f2765cc8\")) {                    Plotly.newPlot(                        \"e3ef7a5a-6859-481b-a993-efb5f2765cc8\",                        [{\"coloraxis\":\"coloraxis\",\"name\":\"0\",\"texttemplate\":\"%{z}\",\"z\":[[11,5],[5,29]],\"type\":\"heatmap\",\"xaxis\":\"x\",\"yaxis\":\"y\",\"hovertemplate\":\"x: %{x}<br>y: %{y}<br>color: %{z}<extra></extra>\"}],                        {\"template\":{\"data\":{\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"choropleth\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"contour\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"contourcarpet\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmap\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmapgl\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2d\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2dcontour\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattermapbox\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolar\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolargl\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]],\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"#E5ECF6\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"white\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"mapbox\":{\"style\":\"light\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"#E5ECF6\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"bgcolor\":\"#E5ECF6\",\"radialaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"},\"yaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"},\"zaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"ternary\":{\"aaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"bgcolor\":\"#E5ECF6\",\"caxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"title\":{\"x\":0.05},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"zerolinewidth\":2},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"zerolinewidth\":2}}},\"xaxis\":{\"anchor\":\"y\",\"domain\":[0.0,1.0],\"scaleanchor\":\"y\",\"constrain\":\"domain\",\"title\":{\"text\":\"Prediction\"}},\"yaxis\":{\"anchor\":\"x\",\"domain\":[0.0,1.0],\"autorange\":\"reversed\",\"constrain\":\"domain\",\"title\":{\"text\":\"Actual Value\"}},\"coloraxis\":{\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"title\":{\"text\":\"Confusion Matrix\"}},                        {\"responsive\": true}                    ).then(function(){\n",
              "                            \n",
              "var gd = document.getElementById('e3ef7a5a-6859-481b-a993-efb5f2765cc8');\n",
              "var x = new MutationObserver(function (mutations, observer) {{\n",
              "        var display = window.getComputedStyle(gd).display;\n",
              "        if (!display || display === 'none') {{\n",
              "            console.log([gd, 'removed!']);\n",
              "            Plotly.purge(gd);\n",
              "            observer.disconnect();\n",
              "        }}\n",
              "}});\n",
              "\n",
              "// Listen for the removal of the full notebook cells\n",
              "var notebookContainer = gd.closest('#notebook-container');\n",
              "if (notebookContainer) {{\n",
              "    x.observe(notebookContainer, {childList: true});\n",
              "}}\n",
              "\n",
              "// Listen for the clearing of the current output cell\n",
              "var outputEl = gd.closest('.output');\n",
              "if (outputEl) {{\n",
              "    x.observe(outputEl, {childList: true});\n",
              "}}\n",
              "\n",
              "                        })                };                            </script>        </div>\n",
              "</body>\n",
              "</html>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "evaluate(net, test_loader)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 891
        },
        "id": "N24i9IYe2B5g",
        "outputId": "e6d7e63b-8382-4401-f352-a108555ae529"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False negatives: 1 (0.49261083743842365% of total)\n",
            "False positives: 0 (0.0% of total)\n",
            "True negatives:  82 (40.39408866995074% of total)\n",
            "True positives:  120 (59.11330049261084% of total)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQwAAAEWCAYAAACTwaluAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0L0lEQVR4nO3dd5gUVdbA4d8ZMoiwEgwgDkmSDENQBBOgggoiLGlIy7goLiq4oK5xzbvqqmCC3c+IAYakBBERFRAJOpKjJAGJShJJQg+c74+qbnuaCTXM9HT3zHmfpx+6qm5VnSm6T9+6deuWqCrGGONFXKQDMMbEDksYxhjPLGEYYzyzhGGM8cwShjHGM0sYxhjPLGEUciJSSkQ+EZGDIjIh0vEYEJGrRGRdpOPISKFKGCKyRUSOichhEdktIqNE5KyQMi1FZJaIHHK/RJ+ISP2QMmeLyMsi8pO7rU3udMVM9isiMlhEVonIERHZLiITRKRhOP9ej7oC5wIVVLVbbjYkIr3d43HYPc6ngqYP5024uScirUJi2y4i40Xk0hxsY5SIPJNH8aiI1PJPq+o3qlonL7ad1wpVwnDdrKpnAYlAY+Ah/wIRaQHMBKYAFwDVgeXAfBGp4ZYpDnwFNABuAM4GWgD7gMsy2ecrwD3AYOAc4GJgMtA+p8GLSNGcrpONi4D1qpqW21hUdbSqnuUe3xuBnf5pd16+y+J47XRjKgtcDvwAfCMi1+ZbcLFIVQvNC9gCXBc0/R/g06Dpb4CRGaz3GfC++/424GfgLI/7rA2cBC7Loswc4Lag6WRgXtC0AncBG4DNwH+BF0O2MQUY6r6/APgI2OOWH5zJfp8ETgA+4DDQH+dH5FFgK/AL8D5Qzi0f78bSH/gJmJvF39QK2J7FsX8C+DBku7cC24ADwN+AS4EVwK/A60Hr5irG0NiC5r8OLAqargt8AewH1gHd3fkD3GN2wj1un2R33IEiwMPAJuAQsBi4EJjrxnvE3VaPDI5dPfcz8iuwGugYtGwUMAL41N3ud0DNsH2HIv0lzs9X8IcWqAqsBF5xp0vjfLFbZ7DercAu9/1Y4L0c7PNvwNZsyswh+4TxBU7tpBRwtfvFEnf5n4Bj7gc2zv0wPgYUB2oAPwLtMtn3E7hfXHf6r8BGd72zgI+BD9xl/i/j+0AZoFQWf1Pohz5w7EP3G7Td/wElgbbA7zi1sMpAFZzEcE1exBgaW9D8NsApd70y7jG+FSiKUxvdC9R3y44CnglaN8vjDtyP83mrAwjQCOc00P//Wyuj+IBi7t/6sLvdNjiJoU5QHP7abVFgNDA2XN+hwnhKMllEDuF8GH4BHnfnn4Pzn74rg3V2Af72iQqZlMlMTstn5llV3a+qx3BqQgpc5S7rCixU1Z04v8qVVPUpVT2hqj8CbwJJHvfTGximqj+q6mGcU7akkKr9E6p6xI0lLz2tqr+r6kycX9wUVf1FVXfg/M2NwxzjTpwvc3mgA7BFVd9V1TRVXYpTe8isnSe7434b8KiqrlPHclXd5yGmy3GS4nPudmcB04CeQWUmqWqqOqeVo3FOt8Mir8+HY0EnVf1SRK4BxuAkgl9xqsGngPNxzmeDnY/z6wJONj8/B/vLafnMbPO/UVUVkbE4H5q5QC/gQ3fxRcAFIvJr0LpFcL5wXlyAU9X324rzOTk3o1jy2M9B749lMO1vBwlXjFVwEvGvOMexechxLAp8kMm62R33C3FOR3LqAmCbqp4KmrfVjdVvd9D7o/xxnPJcYaxhAKCqX+NU5150p48AC8n4F6Q7TkMnwJdAOxEp43FXXwFVRaRZFmWO4JwS+Z2XUcgh0ylAVxG5CGiO8+sHzhdls6qWD3qVVdWbPMa7E+fD71cNSCP9l/dMbnH28jd6Fa4YOwNL3M/CNuDrkON4lqoOzGT72R33bUDNM4hpJ3ChiAR/V6sBO85gW7lWaBOG62XgehFp5E4/CPRzL4GWFZE/uZfOWuA0EILzC7MN+EhE6opInIhUEJGHReS0L6WqbgBGAinu5bziIlJSRJJE5EG32DLgzyJS2r281j+7wN0q8l7gLeBzVf3VXZQKHBKRB9w+FkVE5JIcXDJMAYaISHX3kvO/gXF6BldRQizDOW0o5ibPrrnYVp7F6F7yriIij+OcNjzsLpoGXCwifd2Yi4nIpSJSz13+M047hV92x/0t4GkRqe3uM0FEKmSyrWDf4dQa/uHG0Aq4GactLd8V6oShqntwGscec6fnAe2AP+O0O2zFOW++0v3io6rHgetwTlu+AH7D+bBUxPnPzchgnBb4ETjV3U04v2afuMuH47S4/wy8h3Me6sUYN5YxQX/TSZzz70Sclnp/UinncZvv4CTFue76vwODPK6blX/i/MIewEm+Y7IunqW8iPECt2/IYeB7oCHQym0/QVUP4TS+JuH8yu8GngdKuOu/DdQXkV9FZLKH4z4MGI9z2f43d/1S7rIngPfcbXUPDlJVT+AkiBvdbY4E/qKqoafN+cLfym6MMdkq1DUMY0zOWMIwxnhmCcMY45klDGOMZzHXcatixYoaHx8f6TCMKdAWL168V1Urhc6PuYQRHx/PokWLIh2GMQWaiGzNaL6dkhhjPLOEYYzxzBKGMcYzSxjGGM8sYRhjPAtbwhCRd0TkFxFZlclyEZFXRWSjiKwQkSbhisUYkzfCWcMYhTNIbmZuxBnvsjbOGIn/DWMsxpg8ELZ+GKo6V0TisyhyC87Augp8KyLlReR8Vc39cHYr3oC1ubl72piCxZd2isO/n+RPNS6F1i+f8XYi2YZRhfTDqG0n/bBjASIyQEQWiciiPXv2ZL/ltWNgz7K8iNGYAuGBMT/S+unlHD+Ru3GQYqKnp6q+AbwB0KxZM28DeFRKhB5zwheUMTHk3it3cMnnn1Oi3V9ztZ1I1jB24AyM6leVCI1TaExB5PP5eP311zl58iRVqlThr3/NXbKAyCaMqcBf3KsllwMH86T9whiDz+ejZ8+eDBo0iJkzZ+bZdsN2SiIiKTgPZKkoIttxnv9RDEBV/wdMB27CeUjLUZwHxhhjcsmfLD766COGDx/OjTfemGfbDudVkp7ZLPc//s8Yk0dCk8Xf//73PN2+9fQ0pgBZu3YtM2bMCEuygBi5SmKMyZqqIiIkJCSwfv16LrjggrDsx2oYxsQ4n89H9+7dGTFiBEDYkgVYwjAmpvnbLCZOnIjP5wv7/ixhGBOjwt3AmRFLGMbEIFWlV69e+ZoswBo9jYlJIkLLli1p2bJlviULsIRhTEzx+XysX7+eBg0aMGTIkHzfv52SGBMjfD4fvXr1okWLFuzevTsiMVgNw5gY4E8WEydOZPjw4Zx33nkRicNqGMZEudBkkZ9tFqEsYRgT5UaOHBkVyQLslMSYqHfnnXdSs2ZNOnToEOlQrIZhTDTy+Xzcf//97N69m2LFikVFsgBLGMZEHX+bxYsvvsiMGTMiHU46ljCMiSKhDZzJycmRDikdSxjGRIlouhqSGUsYxkSJgwcPsnr16qhNFmBXSYyJOP9t6RUrVmTx4sWUKlUqwhFlzhKGMRHkv0U9Li6OcePGRXWyADslMSZigsezaNmyJSIS6ZCyZQnDmAiIxOA3ecEShjERMGDAgJhLFmBtGMZExO23307Tpk25++67Ix1KjlgNw5h84vP5+OSTTwBo2bJlzCULsIRhTL7wt1l07NiRpUuXRjqcM2YJw5gwC23gbNy4caRDOmOWMIwJo1i9GpIZSxjGhNGXX35ZYJIF2FUSY8LqxhtvZPny5SQkJEQ6lDxhNQxj8pjP56Nfv37MnTsXoMAkCwhzwhCRG0RknYhsFJEHM1heTURmi8hSEVkhIjeFMx5jws3fZvH++++zfPnySIeT58KWMESkCDACuBGoD/QUkfohxR4FxqtqYyAJGBmueIwJt9AGzkGDBkU6pDwXzhrGZcBGVf1RVU8AY4FbQsoocLb7vhywM4zxGBM2Be1qSGbCmTCqANuCpre784I9AfQRke3AdCDDlCwiA0RkkYgs2rNnTzhiNSZX4uLiKFmyZIFOFhD5qyQ9gVGq+pKItAA+EJFLVPVUcCFVfQN4A6BZs2YagTiNyZDP5+PAgQNUrlyZDz74ICZuUc+NcNYwdgAXBk1XdecF6w+MB1DVhUBJoGIYYzImz/hPQ6688kqOHj1a4JMFhDdhfA/UFpHqIlIcp1FzakiZn4BrAUSkHk7CsHMOE/WC2ywGDhxI6dKlIx1SvghbwlDVNOBu4HNgLc7VkNUi8pSIdHSL3QvcLiLLgRQgWVXtlMNEteBkMWzYMIYMGRLpkPJNWNswVHU6TmNm8LzHgt6vAa4IZwzG5LVHH320UCYLiHyjpzEx57777qNBgwb85S9/iXQo+c66hhvjgc/n46WXXuLEiRNUqlSpUCYLsIRhTLb8bRb33Xcfn332WaTDiShLGMZkIbSB85ZbQjsrFy6WMIzJRGG+GpIZSxjGZGLTpk189dVXliyC2FUSY0KcOnWKuLg46taty7p166hcuXKkQ4oaVsMwJojP56N79+4899xzAJYsQljCMMYV3GZRsmTJSIcTlSxhGEPhGc8itzwnDBEpHHfXmEJHVendu7clCw+ybfQUkZbAW8BZQDURaQTcoap3hjs4Y/KDiNC2bVtatmxpySIbXq6SDAfa4d6arqrLReTqsEZlTD7w+XysWrWKxo0bc9ttt0U6nJjg6ZREVbeFzDoZhliMyTf+NosrrriC7du3RzqcmOGlhrHNPS1RESkG3IMzvoUxMSm0gbNq1aqRDilmeKlh/A24C2cA3x1AImDtFyYm2dWQ3PFSw6ijqr2DZ4jIFcD88IRkTPi8/fbblixywUvCeA1o4mGeMVFvwIAB1KhRg7Zt20Y6lJiUacJwh/1vCVQSkaFBi84GioQ7MGPyis/n4/7772fo0KFUq1bNkkUuZNWGURyn70VRoGzQ6zega/hDMyb3/G0Wr7zyCl988UWkw4l5mdYwVPVr4GsRGaWqW/MxJmPyRGgDZ//+/SMdUszz0oZxVEReABrgPDcEAFVtE7aojMkluxoSHl4uq44GfgCqA08CW3AeUmRM1Dpy5AibN2+2ZJHHvNQwKqjq2yJyT9BpiiUME5V8Ph8nT56kfPnyLFy4kOLFi0c6pALFS8Lwuf/uEpH2wE7gnPCFZMyZ8fl89OrViyNHjjBt2jRLFmHg5ZTkGREph/NYw/tw7lz9eziDMian/Mli4sSJtG3blrg4G+olHLKtYajqNPftQaA1BHp6GhMVgpOFtVmEV1Ydt4oA3XHuIZmhqqtEpAPwMFAKaJw/IRqTtTvvvNOSRT7JqobxNnAhkAq8KiI7gWbAg6o6OR9iM8aTO++8kyZNmjBw4MBIh1LgZZUwmgEJqnpKREoCu4Gaqrovf0IzJnM+n4/JkyfTrVs3GjduTOPGVuHND1m1DJ1Q1VMAqvo78GNOk4WI3CAi60Rko4g8mEmZ7iKyRkRWi8iYnGzfFE7+Tlndu3fn22+/jXQ4hUpWNYy6IrLCfS9ATXdaAFXVhKw27LaBjACuB7YD34vIVFVdE1SmNvAQcIWqHhARewiEyVJoD87LL7880iEVKlkljHq53PZlwEZV/RFARMYCtwBrgsrcDoxQ1QMAqvpLLvdpCjDr7h15Wd18ltsbzqoAwWOBbgeah5S5GEBE5uPcMv+Eqs4I3ZCIDAAGAFSrVi2XYZlYNW/ePCZNmmTJIoIi/WzVokBtoBVQFZgrIg1V9dfgQqr6BvAGQLNmzTSfYzRRonXr1qxevZq6detGOpRCK5zd4XbgXJb1q+rOC7YdmKqqPlXdDKzHSSDGAM5pSJ8+fZgxw6l4WrKILE8JQ0RKiUidHG77e6C2iFQXkeJAEu6zTYJMxqldICIVcU5RfszhfkwB5W+zGD16NOvXr490OAYPCUNEbgaWATPc6UQRCf3in0ZV04C7gc9xHkswXlVXi8hTItLRLfY5sE9E1gCzgfutn4eB0xs4Bw8eHOmQDN7aMJ7AueIxB0BVl4lIdS8bV9XpwPSQeY8FvVdgqPsyBoC0tDS7GhKlvJyS+FT1YMg8a3g0YRMXF0fFihUtWUQhLzWM1SLSCyjidrQaDCwIb1imMPL5fPzyyy9UqVKF//73v4hIpEMyIbzUMAbhjOd5HBiDc5v738MYkymE/G0WLVu25NChQ5YsopSXGkZdVX0EeCTcwZjCKbSBs2zZspEOyWTCSw3jJRFZKyJPi8glYY/IFCrW3Tu2ZJswVLU1zkhbe4D/E5GVIvJo2CMzhcLTTz9tySKGeOoarqq7cQbRmQ38A3gMeCacgZnC4d5776Vu3br06tUr0qEYD7x03KonIk+IyEqchzAvwOnmbcwZ8fl8/Pvf/+bo0aOUK1fOkkUM8VLDeAcYB7RT1Z1hjscUcMFtFhdffDFdu9pjemOJl1HDW+RHIKbgC23gtGQRe7IaNXy8qnZ3T0WCe3Z6GnHLmGB2NaRgyKqGcY/7b4f8CMQUbNu2bWPu3LmWLGJcViNu7XLf3qmqDwQvE5HngQdOX8uY9E6ePElcXBw1atTghx9+4Jxz7CmbscxLx63rM5h3Y14HYgoen89Hjx49eOQRp5OwJYvYl2nCEJGBbvtFHRFZEfTaDKzIbD1jIH2bRaVKlSIdjskjWbVhjAE+A54Fgp8pckhV94c1KhPTgpPFsGHDGDJkSKRDMnkkq4ShqrpFRO4KXSAi51jSMBlRVfr27WvJooDKrobRAViMc1k1+H5jBWqEMS4To0SETp06cfnll9vVkAIoq6skHdx/PQ3HZwo3n8/HkiVLaN68OUlJSZEOx4SJl3tJrhCRMu77PiIyTETsaUImwN9mcdVVV7F58+ZIh2PCyMtl1f8CR0WkEXAvsAn4IKxRmZgR3MD5n//8h+rVrUJakHlJGGnu6N63AK+r6gjAhkQy1t27EPJyt+ohEXkI6AtcJSJxQLHwhmViwYcffmjJopDxkjB6AL2Av6rqbrf94oXwhmViQXJyMvHx8bRu3TrSoZh84mWIvt3AaKCciHQAflfV98MemYlKPp+Pu+66iw0bNiAiliwKGS9XSboDqUA3oDvwnYjYQAaFkL/NYuTIkcyePTvS4ZgI8HJK8ghwqar+AiAilYAvgYnhDMxEl9AGzgEDBkQ6JBMBXq6SxPmThWufx/VMAWFXQ4yflxrGDBH5HEhxp3sQ8oBlU7AdP36cn3/+2ZKF8TSm5/0i8mfgSnfWG6o6KbxhmWjg8/k4ceIEZ511FrNnz6ZoUU9PpTAFWFZjetYGXgRqAiuB+1R1R34FZiLLfxqyd+9evvzyS0sWBsi6LeIdYBrQBeeO1ddyunERuUFE1onIRhF5MItyXURERaRZTvdh8l5wm0WnTp0sWZiArD4JZVX1Tff9OhFZkpMNi0gRYATOEH/bge9FZKqqrgkpVxZnwOHvcrJ9Ex7WwGmyklXCKCkijfljHIxSwdOqml0CuQzYqKo/AojIWJz7UdaElHsaeB64P4exmzAYPHiwJQuTqawSxi5gWND07qBpBdpks+0qwLag6e1A8+ACItIEuFBVPxWRTBOGiAwABgBUq2Z31ofTPffcQ2JiInfccUekQzFRKKsBdMLa59e9iW0YkJxdWVV9A3gDoFmzZppNcZNDPp+PlJQU+vbtS926dalbt26kQzJRKpwdsHYAFwZNV3Xn+ZUFLgHmiMgW4HJgqjV85i9/m0W/fv345ptvIh2OiXLhTBjfA7VFpLqIFAeSgKn+hap6UFUrqmq8qsYD3wIdVXVRGGMyQUIbOK+++upIh2SiXNgShqqmAXcDnwNrgfGqulpEnhKRjuHar/HGroaYM5HtBXYREaA3UENVn3LHwzhPVVOzW1dVpxPSjVxVH8ukbCtPEZs88f333zNlyhRLFiZHvPTIGQmcwrkq8hRwCPgIuDSMcZkwa9myJT/88AM1a9aMdCgmhng5JWmuqncBvwOo6gGgeFijMmHh8/no1asXEyc6IxNYsjA55SVh+NxemwqB8TBOhTUqk+f8ySIlJYUdO+yWIHNmvCSMV4FJQGUR+RcwD/h3WKMyeSq4ZjF8+HDuueeeSIdkYpSX29tHi8hi4FqcbuGdVHVt2CMzeSItLS1dsrAGTpMbXq6SVAOOAp8Ez1PVn8IZmMkbRYoUIT4+3pKFyRNerpJ8yh8PYy4JVAfWAQ3CGJfJJZ/Px44dO4iPj+eFF+ypECZveHnMQENVTXD/rY1zF+rC8IdmzpS/U1aLFi349ddfIx2OKUByPDKKqi4RkebZlzSRENqDs3z58pEOyRQgXtowhgZNxgFNgJ1hi8icMevubcLNSw0j+MHLaThtGh+FJxyTG88//7wlCxNWWSYMt8NWWVW9L5/iMbkwZMgQ6tSpQ7du3SIdiimgMm30FJGiqnoSuCIf4zE55PP5eOKJJ/jtt98oU6aMJQsTVlnVMFJx2iuWichUYAJwxL9QVT8Oc2wmG8FtFnXr1iUpKSnSIZkCzksbRkmcxyO24Y/+GApYwoig0AZOSxYmP2SVMCq7V0hW8Uei8LNxNSPIroaYSMkqYRQBziJ9ovCzhBFBu3fv5rvvvrNkYfJdlo8ZUNWn8i0Sk620tDSKFCnChRdeyOrVqzn77LMjHZIpZLLqGp5RzcJEiM/nIykpicGDB6OqlixMRGSVMK7NtyhMloLbLGrWrIkzzKox+S/ThKGq+/MzEJMxa+A00SSczyUxeSA5OdmShYkaOb5b1eSvnj170rx5cwYPHhzpUIyxhBGNfD4fCxYs4JprrqFDhw6RDseYADsliTL+Nos2bdqwbt26SIdjTDpWw4giwQ2cw4YNo06dOpEOyZh0rIYRJUKTxZAhQyIdkjGnsYQRJSZOnGjJwkQ9OyWJEklJSVSrVo0rrrDhR0z0shpGBPl8PgYMGMCKFSsQEUsWJuqFNWGIyA0isk5ENorIgxksHyoia0RkhYh8JSIXhTOeaOJvs3jzzTeZP39+pMMxxpOwJQx3PNARwI1AfaCniNQPKbYUaKaqCcBE4D/hiieahDZwDhw4MNIhGeNJOGsYlwEbVfVHVT0BjAVuCS6gqrNV9ag7+S1QNYzxRAW7GmJiWTgTRhVgW9D0dndeZvoDn2W0QEQGiMgiEVm0Z8+ePAwx/6WlpXHo0CFLFiYmRcVVEhHpAzQDrslouaq+AbwB0KxZs5gc7cvn83Hs2DHOPvtspk+fTpEiRSIdkjE5Fs4axg7gwqDpqu68dETkOuARoKOqHg9jPBHjPw25/vrrOXHihCULE7PCmTC+B2qLSHURKQ4kAVODC4hIY+D/cJLFL2GMJWKC2yx69uxJ8eLFIx2SMWcsbAlDVdOAu4HPgbXAeFVdLSJPiUhHt9gLOAMNTxAR//NPCgwb/MYUNGFtw1DV6cD0kHmPBb2/Lpz7j7R7773XkoUpUKKi0bOgGjp0KAkJCdx2222RDsWYPGFdw/OYz+fjzTff5NSpU8THx1uyMAWKJYw85G+zGDBgALNmzYp0OMbkOUsYeSS0gfO66wp084wppCxh5AG7GmIKC0sYeWDFihV8+umnlixMgWdXSXJBVUlLS+Occ84hNTWVokWLsnbt2kiHZYxnJUuWpGrVqhQrVsxTeUsYZ8jn89G7d2/uvvtu6tevT3x8vD3C0MQUVWXfvn1s376d6tWre1rHTknOgL/NYsKECZQoUYIKFSpYsjAxR0SoUKECv//+u+d1LGHkUGgD59lnn23JwsSsnH52LWHkwKlTp+xqiCnULGHkQFxcHImJiVGVLPbt20diYiKJiYmcd955VKlSJTB94sSJSIeX75YtW8b06dMzXb506VL69++fbl6nTp24/PLL081LTk5m4sSJ6eadddZZgffr16/npptuonbt2jRp0oTu3bvz888/5yr2CRMm0KBBA+Li4li0aFGm5WbMmEGdOnWoVasWzz33XGD+5s2bad68ObVq1aJHjx6B///XX3+dd955J1exBahqTL2aNm2q2Rp7jfPKIydOnNB169ZluGzNmjV5tp/cevzxx/WFF17Il335fL4cr3Pq1Ck9efJkGKL5w7vvvqt33XVXpsu7du2qy5YtC0wfOHBAq1atqnXr1tVNmzYF5vfr108nTJiQbt0yZcqoquqxY8e0Vq1aOnXq1MCy2bNn68qVK3MV+5o1a/SHH37Qa665Rr///vsMy6SlpWmNGjV006ZNevz4cU1ISNDVq1erqmq3bt00JSVFVVXvuOMOHTlypKqqHjlyRBMTE7PcbyhgkWbw/bOrJNnw+Xz06tWLr776ivXr11OxYsXMC8/+O/yyLG8DqJwIrV/O0SrJycl06NCBrl27As4v4+HDh5kzZw6PP/445cuXZ+XKlXTv3p2GDRvyyiuvcOzYMSZPnkzNmjXZsmULf/3rX9m7dy+VKlXi3XffpVq1aiQnJ1OyZEmWLl3KFVdcwbBhwwL7HDVqFJMmTeLgwYPs2LGDPn368Pjjj7NlyxbatWtH8+bNWbx4MdOnT2f8+PGMHz+e48eP07lzZ5588kmOHDlC9+7d2b59OydPnuSf//wnPXr0YPHixQwdOpTDhw9TsWJFRo0axfnnn0+rVq1o3rw5s2fP5tdff+Xtt9+mefPmPPbYYxw7dox58+bx0EMP0aNHj0CMhw4dYsWKFTRq1Cgw7+OPP+bmm2/m3HPPZezYsTz88MPZHt8xY8bQokULbr755sC8Vq1a5ej/KCP16tXLtkxqaiq1atWiRo0agPM8mylTplCvXj1mzZrFmDFjAOjXrx9PPPEEAwcOpHTp0sTHx5Oamspll12WqxgtYWTBnywmTpzI8OHDs04WMWL58uWsXbuWc845hxo1anDbbbeRmprKK6+8wmuvvcbLL7/MoEGD6NevH/369eOdd95h8ODBTJ48GYDt27ezYMGCDEcNS01NZdWqVZQuXZpLL72U9u3bU7FiRTZs2MB7773H5ZdfzsyZM9mwYQOpqamoKh07dmTu3Lns2bOHCy64gE8//RSAgwcP4vP5GDRoEFOmTKFSpUqMGzeORx55JFC9TktLIzU1lenTp/Pkk0/y5Zdf8tRTT7Fo0SJef/310+JbtGgRl1xySbp5KSkpPPbYY5x77rl06dLFU8JYtWoVTZs2zbbcoUOHuOqqqzJcNmbMGOrXDx1EP3s7duzgwgv/GMiuatWqfPfdd+zbt4/y5ctTtGjRwPwdO/4Y4K5Zs2Z88803ljDCJTRZeGqzyGFNIBIuvfRSzj//fABq1qxJ27ZtAWjYsCGzZ88GYOHChXz88ccA9O3bl3/84x+B9bt165bpEIPXX389FSpUAODPf/4z8+bNo1OnTlx00UWBNoKZM2cyc+ZMGjduDMDhw4fZsGEDV111Fffeey8PPPAAHTp04KqrrmLVqlWsWrWK66+/HoCTJ08GYvfvA6Bp06Zs2bIl2799165dVKpUKTD9888/s2HDBq688kpEhGLFirFq1SouueSSDK8e5PSKQtmyZVm2bFmO1gmXypUr88MPP+R6O5YwMvHyyy/nLFlEkaJFi3Lq1CnAubIT3PhZokSJwPu4uLjAdFxcHGlpadluu0yZMpkuC/1C+aeD11FVHnroIe64447T1l+yZAnTp0/n0Ucf5dprr6Vz5840aNCAhQsXZrg/f+xFihTxFHupUqXS9TkYP348Bw4cCHRa+u2330hJSeFf//oXFSpU4MCBA4Gy+/fvD9QwGzRowNdff53t/sJRw6hSpQrbtv0xGP/27dupUqUKFSpU4NdffyUtLY2iRYsG5vv9/vvvlCpVKsf7C2VXSTIxePBgJk2aFHPJAiA+Pp7FixcDMHXqVHw+X47Wb9myJWPHjgVg9OjRmX7oQ33xxRfs378/0B6S0aMf27VrxzvvvMPhw4cBp4r9yy+/sHPnTkqXLk2fPn24//77WbJkCXXq1GHPnj2BhOHz+Vi9enWWMZQtW5ZDhw5luKxevXps3LgxMJ2SksKMGTPYsmULW7ZsYfHixYG/u1WrVowbNy6QbEeNGkXr1q0B6NWrFwsWLAicPgHMnTuXVatWnRbLsmXLMnydSbIAp4a4YcMGNm/ezIkTJxg7diwdO3ZERGjdunXgys57773HLbf88Rig9evXn3Y6diYsYQTx+Xw8/PDD7Nu3jxIlStCpU6dIh3RGbr/9dr7++msaNWrEwoULs6wVZOS1117j3XffJSEhgQ8++IBXXnnF03qXXXYZXbp0ISEhgS5dutCsWbPTyrRt25ZevXrRokULGjZsSNeuXTl06BArV67ksssuIzExkSeffJJHH32U4sWLM3HiRB544AEaNWpEYmIiCxYsyDKG1q1bs2bNGhITExk3bly6ZXXr1uXgwYMcOnSILVu2sHXr1nSXU6tXr065cuX47rvvAqdFTZs2JTExkfnz5/P8888DTk1l2rRpvPbaa9SuXZv69eszcuTIdKc7Z2LSpElUrVqVhQsX0r59e9q1awfAzp07uemmmwCn9vj666/Trl076tWrR/fu3WnQoAEAzz//PMOGDaNWrVrs27cv3eXj+fPnB07tciWjSyfR/ArXZdUTJ05o165dFdAPPvjA83rRdFk1krK7nBkthg0bpm+++Wakw8hXS5Ys0T59+mS6PCeXVa2GwekNnH369Il0SCZMBg4cmK4dpzDYu3cvTz/9dJ5sq9A3ep7R1RBzmuTkZJKTkyMdRrZKlixJ3759Ix1GvsqTUxFXoa9h7Nu3j6VLl1qyMMaDQlvD8Pl8xMXFcd5557F8+fIcNwwaUxgVyhqG/xb1/v37o6qWLIzxqNAljODxLBITE20sC2NyoFAljMI0undGt2dHQnx8PHv37s2Xbaoqbdq04bfffgvMmzx5MiKSrlv0nDlz6NChQ7p1g4+Xz+fjwQcfDNy63qJFCz777LNcx/3ss89Sq1Yt6tSpw+eff55hmeTkZKpXrx4YosDftXzatGk89thjGa6TnwpVwujfv3+hSBaF1fTp02nUqBFnn312YF5KSgpXXnklKSkpnrfzz3/+k127drFq1SqWLFnC5MmTM+096tWaNWsYO3Ysq1evZsaMGdx5552cPHkyw7IvvPBCoEdoYmIiAO3bt+eTTz7h6NGjuYojtwpVwkhOTubVV18Na7Jo1arVaa+RI0cCcPTo0QyXjxo1CnCul4cu8+L9998nISGBRo0apbtkOHfuXFq2bEmNGjUCv56HDx/m2muvpUmTJjRs2JApU6YAsGXLFurVq8ftt99OgwYNaNu2LceOHQNg48aNXHfddTRq1IgmTZqwadMmwPlgX3rppSQkJPD4449nG+eHH34Y6M15xx13cPLkSf73v/9x//33B8qMGjWKu+++O9PyWRk9enS67tCHDx9m3rx5vP3224Eu39k5evQob775Jq+99lqgv8a5555L9+7dPa2fmSlTppCUlESJEiWoXr06tWrVIjU11fP6IkKrVq2YNm1aruLIrQKfMHw+HzNnzgSgTZs2DBo0KMIR5a3Vq1fzzDPPMGvWLJYvX56uG/euXbuYN28e06ZN48EHHwScfgiTJk1iyZIlzJ49m3vvvRenYx9s2LCBu+66i9WrV1O+fHk++ugjAHr37s1dd93F8uXLWbBgAeeff36629SXLVvG4sWLmTt3bqZxrl27lnHjxjF//nyWLVtGkSJFGD16NF26dGHSpEmBcuPGjSMpKSnT8lmZP39+utvOp0yZwg033MDFF19MhQoVAvfXZGXjxo1Uq1YtXS0lM0OGDAmcOgS/gkfB8svotvTg28+DPfLIIyQkJDBkyBCOHz8emO+/RT2SCvRlVX+bxccff8yKFSvy5Oab7MyZMyfTZaVLl85yecWKFbNcnpFZs2bRrVu3wJ2U55xzTmBZp06diIuLo379+oHh41SVhx9+mLlz5xIXF8eOHTsCy/znzvDHLeOHDh1ix44ddO7cGXASDmR+m/rVV1+dYZxfffUVixcv5tJLLwXg2LFjVK5cmUqVKlGjRg2+/fZbateuzQ8//MAVV1zBiBEjMiyflf3791O2bNnAdEpKCvfccw/gDDSTkpJC06ZNM23ozmkD+PDhw3NU3otnn32W8847jxMnTjBgwACef/75QNtF5cqV2blzZ57vMyfCmjBE5AbgFaAI8JaqPheyvATwPtAU2Af0UNUtebFvX1r6AXvzI1lEm+Au0P5axOjRo9mzZw+LFy+mWLFixMfHB275Di5fpEiRwClJRjSL29QzK9+vXz+effbZ05YlJSUxfvx46tatS+fOnRGRLMtnxn9bf1xcHPv372fWrFmsXLkSEeHkyZOICC+88MJpt67DH7ev16pVi59++onffvst21rGkCFDAmOIhP49/hqdX2a3pYfyj/dRokQJbr31Vl588cXAsry6RT03wnZKIiJFgBHAjUB9oKeIhN7T2x84oKq1gOHA83mxb1/aKXq+urZQNHC2adOGCRMmsG/fPsD54Gfl4MGDVK5cmWLFijF79my2bt2aZfmyZctStWrVwIhbx48f5+jRo5nepp6Za6+9lokTJwbK7N+/P7Dvzp07M2XKFFJSUkhKSsq2fGbq1KnDjz/+CMDEiRPp27cvW7duZcuWLWzbto3q1avzzTffULt2bXbu3Bl4St3WrVtZvnw5iYmJlC5dmv79+3PPPfcEbm3fs2cPEyZMOG1/w4cPz/DW9dBkAdCxY0fGjh3L8ePH2bx5Mxs2bMhw9Ktdu3YBToKdPHlyuh+6vLpFPTfC2YZxGbBRVX9U1RPAWOCWkDK3AO+57ycC10oedIz4dOl+PkrdW+CTBTiDuTzyyCNcc801NGrUiKFDh2ZZvnfv3ixatIiGDRvy/vvvU7du3Wz38cEHH/Dqq6+SkJBAy5Yt2b17d6a3qWemfv36PPPMM7Rt25aEhASuv/76wJfjT3/6E/Xq1WPr1q2BL1FW5TPTvn37wCldSkpK4DTKr0uXLqSkpFCiRAk+/PBDbr31VhITE+natStvvfUW5cqVA+CZZ56hUqVK1K9fn0suuYQOHTp4atPISoMGDejevTv169fnhhtuYMSIEYGRy2666abAqUbv3r1p2LAhDRs2ZO/evTz66KOBbcyePZv27dvnKo5cy+gW1rx4AV1xTkP8032B10PKrAKqBk1vAipmsK0BwCJgUbVq1bK/n3fWPbrof0nZl8sDdnt79Ni5c6ded911kQ4jLHbv3q1t2rQJy7YL3O3tqvqGqjZT1WaeBilp/TJN7/B+3d0UDOeffz633357uo5bBcVPP/3ESy+9FOkwwtrouQO4MGi6qjsvozLbRaQoUA6n8dOYM5Lb/hLRyn+1KNLCWcP4HqgtItVFpDiQBEwNKTMV6Oe+7wrMcqtDMSUGQzYGyPlnN2wJQ1XTgLuBz4G1wHhVXS0iT4lIR7fY20AFEdkIDAVOb16OciVLlmTfvn2WNEzMUVX27dsX6FvjhcTaB71Zs2aa1XMn85vP52P79u3phq83JlaULFmSqlWrUqxYsXTzRWSxqp42inOB7umZH4oVKxZ4roUxBV1MXCUxxkQHSxjGGM8sYRhjPIu5Rk8R2QNkfVOBoyKQt0M95Z1ojg0svtyI5tjAe3wXqeppvSRjLmF4JSKLMmrljQbRHBtYfLkRzbFB7uOzUxJjjGeWMIwxnhXkhPFGpAPIQjTHBhZfbkRzbJDL+ApsG4YxJu8V5BqGMSaPWcIwxngW8wlDRG4QkXUislFETrvbVURKiMg4d/l3IhIfRbENFZE1IrJCRL4SkYvyKzYv8QWV6yIiKiL5drnQS2wi0t09fqtFZEx+xeYlPhGpJiKzRWSp+/97Uz7G9o6I/CIiqzJZLiLyqhv7ChFp4nnjGQ3DFSsvnNHINwE1gOLAcqB+SJk7gf+575OAcVEUW2ugtPt+YH7F5jU+t1xZYC7wLdAsWmIDagNLgT+505Wj6djhNC4OdN/XB7bkY3xXA02AVZksvwn4DBDgcuA7r9uO9RpGxAYazovYVHW2qvqfffctzqhk+cXLsQN4Gmc09/y8f99LbLcDI1T1AICqZj5keWTiU8A/cnA5IN8eKKKqc4Gsho+/BXhfHd8C5UXkfC/bjvWEUQXYFjS93Z2XYRl1BvU5CFSIktiC9cfJ+vkl2/jcquqFqvppPsYF3o7dxcDFIjJfRL51n4GTX7zE9wTQR0S2A9OBaHrkXk4/mwE2HkYUEJE+QDPgmkjH4iciccAwIDnCoWSmKM5pSSucmtlcEWmoqr9GMqggPYFRqvqSiLQAPhCRS1T1VKQDy41Yr2HkZKBh8nmgYS+xISLXAY8AHVX1eOjyMMouvrLAJcAcEdmCc647NZ8aPr0cu+3AVFX1qepmYD1OAskPXuLrD4wHUNWFQEmcG7+igafPZobyqyEmTI07RYEfger80fjUIKTMXaRv9BwfRbE1xmk8qx2Nxy6k/Bzyr9HTy7G7AXjPfV8Rp4pdIYri+wxIdt/Xw2nDkHz8/40n80bP9qRv9Ez1vN38+gPCeGBuwvl12QQ84s57CucXG5zMPgHYCKQCNaIoti+Bn4Fl7mtqNB27kLL5ljA8HjvBOWVaA6wEkqLp2OFcGZnvJpNlQNt8jC0F2AX4cGpi/YG/AX8LOnYj3NhX5uT/1bqGG2M8i/U2DGNMPrKEYYzxzBKGMcYzSxjGGM8sYRhjPLOEEUNE5KSILAt6xWdR9nAe7G+UiGx297XE7bGY0228JSL13fcPhyxbkNsY3e34j8sqEflERMpnUz4xP+8eLUjssmoMEZHDqnpWXpfNYhujgGmqOlFE2gIvqmpCLraX65iy266IvAesV9V/ZVE+Gafvwd15HUtBZzWMGCYiZ7njaCwRkZUictrdpiJyvojMDfoFvsqd31ZEFrrrThCR7L7Ic4Fa7rpD3W2tEpG/u/PKiMinIrLcnd/DnT9HRJqJyHNAKTeO0e6yw+6/Y0WkfVDMo0Skq4gUEZEXROR7d9yGOzwcloW4N1KJyGXu37hURBaISB0RKY7TwaqHG0sPN/Z3RCTVLZvRXbsGYr+nZ2F6ASf5o1foJJwuyme7yyri9Gb11xoPu//eyx89EYvg3CNSEScBlHHnPwA8lsH+RgFd3ffdgO+Apji9A8sAZwGrcbq4dwHeDFq3nPvvHNyehP6Ygsr4Y+zMH928i+N08y4FDAAedeeXABYB1TOI83DQ3zcBuMGdPhso6r6/DvjIfZ8MvB60/r+BPu778jg9OMtE+v87Gl92t2psOaaqif4JESkG/FtErgZO4fyyngvsDlrne+Adt+xkVV0mItfgdl12hwYpjvPLnJEXRORRYA9OF+NrgUmqesSN4WPgKmAG8JKIPI9zGvNNDv6uz4BXRKQEzj0ic1X1mHsalCAiXd1y5XBuMNscsn4pEVnm/v1rgS+Cyr8nIrVxxqcolsn+2wIdReQ+d7okUM3dlgliCSO29QYqAU1V1efeVVoyuICqznUTSntglIgMAw4AX6hqTw/7uF9VJ/onROTajAqp6np3/IybgGdE5CtVfcrLH6Gqv4vIHKAd0ANnQBpw7nkYpKqfZ7OJY6qaKCKlgc9xbjh8FWfwn9mq2tltIJ6TyfoCdFHVdV7iLcysDSO2lQN+cZNFa+C0MUHFGSf0Z1V9E3gLZ+i2b4ErRMTfJlFGRC72uM9vgE4iUlpEyuCcTnwjIhcAR1X1Q+AFdz+hfG5NJyPjgFv5o7YCzpd/oH8dEbnY3WeG1Bm9bDBwb9BQBv7btpODih7COTXz+xwYJG51S0QaZ7aPws4SRmwbDTQTkZXAX4AfMijTClguIktxfr1fUdU9OF+gFBFZgXM6UtfLDlV1CU7bRipOm8ZbqroUaAikuqcGjwPPZLD6G8AKf6NniJk4Awh9qc6wd+AkuDXAEnEGtP0/sqkVu7GswBnA5j/As+7fHrzebKC+v9ETpyZSzI1ttTttMmCXVY0xnlkNwxjjmSUMY4xnljCMMZ5ZwjDGeGYJwxjjmSUMY4xnljCMMZ79P39aooDlalmvAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<html>\n",
              "<head><meta charset=\"utf-8\" /></head>\n",
              "<body>\n",
              "    <div>            <script src=\"https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-AMS-MML_SVG\"></script><script type=\"text/javascript\">if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}</script>                <script type=\"text/javascript\">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>\n",
              "        <script src=\"https://cdn.plot.ly/plotly-2.8.3.min.js\"></script>                <div id=\"7530bb58-c43a-4169-b43e-7e542a84e168\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"7530bb58-c43a-4169-b43e-7e542a84e168\")) {                    Plotly.newPlot(                        \"7530bb58-c43a-4169-b43e-7e542a84e168\",                        [{\"coloraxis\":\"coloraxis\",\"name\":\"0\",\"texttemplate\":\"%{z}\",\"z\":[[82,0],[1,120]],\"type\":\"heatmap\",\"xaxis\":\"x\",\"yaxis\":\"y\",\"hovertemplate\":\"x: %{x}<br>y: %{y}<br>color: %{z}<extra></extra>\"}],                        {\"template\":{\"data\":{\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"choropleth\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"contour\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"contourcarpet\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmap\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmapgl\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2d\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2dcontour\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattermapbox\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolar\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolargl\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]],\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"#E5ECF6\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"white\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"mapbox\":{\"style\":\"light\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"#E5ECF6\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"bgcolor\":\"#E5ECF6\",\"radialaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"},\"yaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"},\"zaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\"}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"ternary\":{\"aaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"bgcolor\":\"#E5ECF6\",\"caxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"title\":{\"x\":0.05},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"zerolinewidth\":2},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"zerolinewidth\":2}}},\"xaxis\":{\"anchor\":\"y\",\"domain\":[0.0,1.0],\"scaleanchor\":\"y\",\"constrain\":\"domain\",\"title\":{\"text\":\"Prediction\"}},\"yaxis\":{\"anchor\":\"x\",\"domain\":[0.0,1.0],\"autorange\":\"reversed\",\"constrain\":\"domain\",\"title\":{\"text\":\"Actual Value\"}},\"coloraxis\":{\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"title\":{\"text\":\"Confusion Matrix\"}},                        {\"responsive\": true}                    ).then(function(){\n",
              "                            \n",
              "var gd = document.getElementById('7530bb58-c43a-4169-b43e-7e542a84e168');\n",
              "var x = new MutationObserver(function (mutations, observer) {{\n",
              "        var display = window.getComputedStyle(gd).display;\n",
              "        if (!display || display === 'none') {{\n",
              "            console.log([gd, 'removed!']);\n",
              "            Plotly.purge(gd);\n",
              "            observer.disconnect();\n",
              "        }}\n",
              "}});\n",
              "\n",
              "// Listen for the removal of the full notebook cells\n",
              "var notebookContainer = gd.closest('#notebook-container');\n",
              "if (notebookContainer) {{\n",
              "    x.observe(notebookContainer, {childList: true});\n",
              "}}\n",
              "\n",
              "// Listen for the clearing of the current output cell\n",
              "var outputEl = gd.closest('.output');\n",
              "if (outputEl) {{\n",
              "    x.observe(outputEl, {childList: true});\n",
              "}}\n",
              "\n",
              "                        })                };                            </script>        </div>\n",
              "</body>\n",
              "</html>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "evaluate(net, train_loader)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Analysis"
      ],
      "metadata": {
        "id": "kiwtHb6d4z7b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* The simple classifier model obtains decent classification results, with validation set AUC = 0.82\n",
        "* There is a little bit of overfitting happening, as evidenced by the higher score on the train set compared to the test set. This can be mitigated by using dropout or more weight decay on the optimizer. \n",
        "* In this scenario, I am reluctant to use dropout because the size of my dataset is very limited."
      ],
      "metadata": {
        "id": "XB3TS4cz44OF"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eZqxp9FlvUCf"
      },
      "source": [
        "# AutoEncoder"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NcgyXP9l6d6b"
      },
      "source": [
        "## AutoEncoder Model\n",
        "* Create a model that can reconstruct based on point in latent space\n",
        "* Disentangle a dimension of the latent space for tumor presence\n",
        "* Try to disentangle other dimensions in an unsupervised way"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "nNQDBc-D6cB2"
      },
      "outputs": [],
      "source": [
        "# first I'll do a classifier\n",
        "class VAE(nn.Module):\n",
        "  def __init__(self, res:int =DEFAULT_RES, confidence=0.75):\n",
        "    super(VAE, self).__init__()\n",
        "    self.res = res\n",
        "    self.reshape = 1, 4, 8 # channels for managing conv layers\n",
        "    self.confidence = confidence\n",
        "    self.encoder_conv, self.encoder_linear = [], []\n",
        "    self.decoder_linear, self.decoder_conv = [], []\n",
        "\n",
        "    s = (1, self.res, self.res)\n",
        "\n",
        "    self.encoder_conv.append(nn.Conv2d(1, 4, 5))\n",
        "    self.encoder_conv.append(nn.ReLU())\n",
        "    s = 4, s[1] - 4, s[2]-4 # stride is 2 i believe\n",
        "    self.encoder_conv.append(nn.MaxPool2d((2,2)))\n",
        "    self.encoder_conv.append(nn.ReLU())\n",
        "    s = s[0], s[1]/2, s[2]/2\n",
        "    self.encoder_conv.append(nn.Conv2d(4, 8, 10))\n",
        "    self.encoder_conv.append(nn.ReLU())\n",
        "    s = 8, s[1]-9, s[2] - 9\n",
        "    self.encoder_conv.append(nn.MaxPool2d(2))\n",
        "    self.encoder_conv.append(nn.ReLU())\n",
        "    s = s[0], (s[1]-1)/2, (s[2]-1)/2\n",
        "    self.flatten = nn.Flatten()\n",
        "    s = s[0]*s[1]*s[2], None\n",
        "    self.encoder_linear.append(nn.Linear( int(s[0]), 120))\n",
        "    self.encoder_conv.append(nn.ReLU())\n",
        "    self.encoder_linear.append(nn.Linear(120, 60) )\n",
        "    \n",
        "    self.unflatten = nn.Unflatten(dim=1, unflattened_size=(8,44,44))\n",
        "\n",
        "    self.encoder_conv = nn.Sequential(*self.encoder_conv)\n",
        "    self.encoder_linear = nn.Sequential(*self.encoder_linear)\n",
        "\n",
        "    def app(l):\n",
        "      self.decoder_linear.append(l)\n",
        "    app(nn.Linear(60,120))\n",
        "    app(nn.ReLU())\n",
        "    app(nn.Linear(120, int(s[0])) )\n",
        "    app(nn.ReLU())\n",
        "    self.decoder_linear = nn.Sequential(*self.decoder_linear)\n",
        "\n",
        "    def app(l):\n",
        "      self.decoder_conv.append(l)\n",
        "    #app(nn.Upsample(size=(121,121))) #scale_factor=1.1)) #size=() ))\n",
        "    app(nn.ConvTranspose2d(8, 4, 10, padding=2, output_padding=1, stride=2))\n",
        "    app(nn.ReLU())\n",
        "    app(nn.Upsample(size=(100, 100)))\n",
        "    app(nn.ReLU())\n",
        "    app(nn.ConvTranspose2d(4,1, 5, padding=2, output_padding=1, stride=2))\n",
        "    \"\"\"\n",
        "    app(nn.ConvTranspose2d(8, 6, 10))\n",
        "    app(nn.ConvTranspose2d(6, 4,  8))\n",
        "    app(nn.ConvTranspose2d(4, 1,  8)) #padding=2, output_padding=1, stride=2))\n",
        "    app(nn.ConvTranspose2d(1, 1,  5, padding=2, output_padding=1, stride=2))\n",
        "    \"\"\"\n",
        "    self.decoder_conv = nn.Sequential(*self.decoder_conv)\n",
        "    # todo: add batch norm!\n",
        "    # todo add ReLU or sigmoid, or without it.\n",
        "    # need to de-normalize output to visualize\n",
        "    #self.layers = [self.conv1, self.pool1, self.conv2, self.pool2, self.flatten, self.l1, self.l2, self.l3, self.l4, self.sigmoid]\n",
        "    # dropout?\n",
        "    # self.seq = nn.Sequential(*self.layers)\n",
        "\n",
        "    # TEMP 1\n",
        "    amt = 50*50\n",
        "    self.tmp1 = nn.Sequential(\n",
        "        nn.Flatten(),\n",
        "        nn.Linear(amt, int(amt/10)),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(int(amt/10),amt),\n",
        "        nn.Linear(amt,amt),\n",
        "        nn.Unflatten(dim=1, unflattened_size=(50,50))\n",
        "                              )\n",
        "\n",
        "  def forward(self, x):\n",
        "    \"\"\"\n",
        "    latent = self.encode(x)\n",
        "    #reconstruction = self.decode(x)\n",
        "    reconstruction = self.decode(latent)\n",
        "    return reconstruction # activation fxn. Keep in mind we'll have to transform since input was normalized, gotta transform output to compensate\n",
        "    \"\"\" # TODO UNCOMMENT\n",
        "    x = self.tmp1(x)\n",
        "    return torch.sigmoid(x)\n",
        "\n",
        "  \n",
        "  def encode(self, x):\n",
        "    x = self.encoder_conv(x)\n",
        "    #print(f\"Shape after conv: {x.shape}\")\n",
        "    x = self.flatten(x)\n",
        "    #print(f\"Shape after flattening: {x.shape}\")\n",
        "    return self.encoder_linear(x)\n",
        "  \n",
        "  def decode(self, x):\n",
        "    #x = torch.relu(self.decoder[0](x))\n",
        "    #x = torch.relu(self.decoder[1](x))\n",
        "    x = self.decoder_linear(x)\n",
        "    #x = x.view(x.shape[0], 8, 44, 44) # reshape\n",
        "    x = self.unflatten(x)\n",
        "    x = self.decoder_conv(x)\n",
        "    #print(\"x shape: \", x.shape)\n",
        "    # todo decode linear\n",
        "    # todo activation?\n",
        "    return torch.sigmoid(x)\n",
        "\n",
        "  def inference(self, x, mean=0, std=1):\n",
        "    out = self.forward(x)\n",
        "    #return out.mul(std).add(mean)\n",
        "    return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AtisSTrxQkrt"
      },
      "source": [
        "## Train Autoencoder"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# helper fxns\n",
        "def show_batch(batch, n=None):\n",
        "  device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "  if n is not None:\n",
        "    batch = batch[:n]\n",
        "  sidelen = int(sqrt(len(batch)))+1\n",
        "  f, axarr = plt.subplots(sidelen,sidelen)\n",
        "  #print(batch[0].size())\n",
        "  batch = [ np.squeeze(t.cpu().detach().numpy() , axis=0) if 1 in t.shape else t.cpu().detach().numpy() for t in batch ]\n",
        "  for i in range(sidelen):\n",
        "    for j in range(sidelen):\n",
        "      index = (sidelen*i)+j\n",
        "      if index >= len(batch):\n",
        "        break\n",
        "      axarr[i][j].imshow(batch[index])"
      ],
      "metadata": {
        "id": "fzJO5AlNo1R9"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p8_aNpeIQnnu",
        "outputId": "855e6651-7ada-4b8b-9257-e28fd337d045"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normalization added to transform\n",
            "Train set: 203, Test set: 50\n",
            "Training model at  1678058632_ae.pt\n"
          ]
        }
      ],
      "source": [
        "# constants\n",
        "epochs = 100\n",
        "\n",
        "# data\n",
        "ds = MyDataSet(pos_dir = \"/content/drive/MyDrive/kaggle/brain_tumor_dataset/yes\", neg_dir=\"/content/drive/MyDrive/kaggle/brain_tumor_dataset/no\", res=50)\n",
        "mean, std = ds.get_mean_and_std() # set up normalization with the same mean and td overall for each\n",
        "ds.set_up_normalization(mean, std)\n",
        "train_set, test_set = random_split(ds, [0.8, 0.2], generator=torch.Generator().manual_seed(42)) # manual seed for reproducible result right now\n",
        "\n",
        "print(f\"Train set: {len(train_set)}, Test set: {len(test_set)}\")\n",
        "train_loader = DataLoader(train_set, batch_size=10, shuffle=True, num_workers=2) # for now no extra workers\n",
        "test_loader = DataLoader(test_set, batch_size=10, shuffle = False, num_workers=0)\n",
        "\n",
        "# save info\n",
        "model_save_name = str(int(time.time())) + \"_ae.pt\" # unique name\n",
        "save_path = f\"/content/drive/MyDrive/kaggle/{model_save_name}\"\n",
        "print(\"Training model at \", model_save_name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        },
        "id": "_ydsiz30RDZ2",
        "outputId": "4572103a-9de4-4cb3-823b-dea8daf47428"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 85 train loss: 1.0425246953964233\n",
            " test loss: 1.0386823415756226\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-98a50afb8cdf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     72\u001b[0m   \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_losses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     73\u001b[0m   \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_losses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 74\u001b[0;31m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    385\u001b[0m     \"\"\"\n\u001b[1;32m    386\u001b[0m     \u001b[0m_warn_if_gui_out_of_main_thread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 387\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_get_backend_mod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    388\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    389\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m     39\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mfigure_manager\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mGcf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_all_fig_managers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m             display(\n\u001b[0m\u001b[1;32m     42\u001b[0m                 \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m                 \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m    311\u001b[0m             \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    312\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m             \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    314\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m                 \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m    178\u001b[0m             \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                 \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m                 \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<decorator-gen-2>\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    222\u001b[0m     \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    225\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    226\u001b[0m         \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    339\u001b[0m                 \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    340\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    342\u001b[0m             \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    343\u001b[0m             \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m    242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    243\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    245\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    246\u001b[0m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    129\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2293\u001b[0m                 )\n\u001b[1;32m   2294\u001b[0m                 \u001b[0;32mwith\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"_draw_disabled\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnullcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2295\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2296\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2297\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     73\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdraw_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 74\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     75\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rasterizing\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     76\u001b[0m             \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     49\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   2843\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2844\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2845\u001b[0;31m             mimage._draw_list_compositing_images(\n\u001b[0m\u001b[1;32m   2846\u001b[0m                 renderer, self, artists, self.suppressComposite)\n\u001b[1;32m   2847\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    131\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    133\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m         \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     49\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3053\u001b[0m                 \u001b[0martists\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mspine\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3054\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3055\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_title_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3056\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3057\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxison\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_update_title_position\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3003\u001b[0m                 \u001b[0m_log\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'top of Axes not in the figure, so title not moved'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3004\u001b[0m                 \u001b[0;32mreturn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3005\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_window_extent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mtop\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3006\u001b[0m                 \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransAxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minverted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3007\u001b[0m                 \u001b[0mtitle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/text.py\u001b[0m in \u001b[0;36mget_window_extent\u001b[0;34m(self, renderer, dpi)\u001b[0m\n\u001b[1;32m    897\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_text\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    898\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 899\u001b[0;31m                 \u001b[0mtx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_xy_display\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    900\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mBbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_bounds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    901\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/text.py\u001b[0m in \u001b[0;36m_get_xy_display\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    214\u001b[0m         \"\"\"\n\u001b[1;32m    215\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_unitless_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    218\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_get_multialignment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mtransform\u001b[0;34m(self, values)\u001b[0m\n\u001b[1;32m   1501\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1502\u001b[0m         \u001b[0;31m# Transform the values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1503\u001b[0;31m         \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform_non_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1504\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1505\u001b[0m         \u001b[0;31m# Convert the result back to the shape of the input values.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mtransform_affine\u001b[0;34m(self, points)\u001b[0m\n\u001b[1;32m   2417\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mtransform_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2418\u001b[0m         \u001b[0;31m# docstring inherited\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2419\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2420\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2421\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mtransform_non_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mget_affine\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   2444\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_b\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_affine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2445\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2446\u001b[0;31m             return Affine2D(np.dot(self._b.get_affine().get_matrix(),\n\u001b[0m\u001b[1;32m   2447\u001b[0m                                    self._a.get_affine().get_matrix()))\n\u001b[1;32m   2448\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, matrix, **kwargs)\u001b[0m\n\u001b[1;32m   1908\u001b[0m         \u001b[0mIf\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m*\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitialize\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mthe\u001b[0m \u001b[0midentity\u001b[0m \u001b[0mtransform\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1909\u001b[0m         \"\"\"\n\u001b[0;32m-> 1910\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1911\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mmatrix\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1912\u001b[0m             \u001b[0;31m# A bit faster than np.identity(3).\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1782\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1783\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1784\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1785\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_inverted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1786\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, shorthand_name)\u001b[0m\n\u001b[1;32m    105\u001b[0m     \"\"\"\n\u001b[1;32m    106\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 107\u001b[0;31m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshorthand_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    108\u001b[0m         \"\"\"\n\u001b[1;32m    109\u001b[0m         \u001b[0mParameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "net = VAE()\n",
        "net = net.to(device) # todo remove\n",
        "\n",
        "loss_fxn = nn.MSELoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9) # weight_decay = 1e-5 # todo 0.001 learning rate\n",
        "\n",
        "train_losses = []\n",
        "test_losses = []\n",
        "\n",
        "one_batch = next(iter(train_loader)) ## TODO remove these 2 lines\n",
        "torch.autograd.set_detect_anomaly(True)\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  net.train()\n",
        "  running_loss = 0.\n",
        "  for i, batch in enumerate([one_batch]): #enumerate(train_loader):\n",
        "    X, y = batch\n",
        "    X = X.to(device)\n",
        "    y = y.to(device)\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    output = net(X)\n",
        "    output = torch.squeeze(output, 1)\n",
        "    loss = loss_fxn(output, torch.squeeze(X))\n",
        "    loss.backward() # retain_graph=True for multi losses?\n",
        "    optimizer.step()\n",
        "\n",
        "    running_loss += loss.item()\n",
        "    \"\"\"\"\"\"\n",
        "    \n",
        "\n",
        "    #print(f\"Output: {output}, labels: {y}, loss: {loss.item()}\")\n",
        "    #stats\n",
        "\n",
        "\n",
        "  # save model each epoch\n",
        "  train_losses.append(running_loss)\n",
        "  \"\"\" TODO REMOVE \"\"\"\n",
        "  if epoch % 5 != 0: # gotta remove these lines\n",
        "    continue # next epoch\n",
        "  torch.save(net.state_dict(), save_path)\n",
        "\n",
        "  # see the validation loss\n",
        "  net.eval()\n",
        "  with torch.no_grad():\n",
        "    test_loss = 0.\n",
        "    for i, val_batch in enumerate([one_batch]): #enumerate(test_loader): # todo CHANGE THIS BACK\n",
        "      X, y = val_batch \n",
        "      X = X.to(device)\n",
        "      y = y.to(device)\n",
        "\n",
        "      output = net(X)\n",
        "      output = torch.squeeze(output, 1)\n",
        "      loss = loss_fxn(output, torch.squeeze(X))\n",
        "      test_loss += loss.item()\n",
        "    if len(test_losses) > 0:\n",
        "      test_losses.extend(list(np.linspace(test_losses[-1], test_loss, 5)))\n",
        "    else:\n",
        "      test_losses.append(test_loss) # TODO: SHOULD BE DEFAULT\n",
        "    \"\"\"\"\"\"\n",
        "    #show_batch(X)\n",
        "    #show_batch(net.inference(X))\n",
        "    show_batch(batch[0]) # TODO REMOVE THESE 2 LINES\n",
        "    show_batch(net.inference(batch[0].to(device)))\n",
        "    \n",
        "  # Display output!\n",
        "  clear_output(wait=True)\n",
        "  print(f\"Epoch {epoch} train loss: {train_losses[-1]}\\n test loss: {test_losses[-1]}\")\n",
        "  fig, ax = plt.subplots()\n",
        "  ax.plot(train_losses)\n",
        "  ax.plot(test_losses)\n",
        "  plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Check for vanishing gradients"
      ],
      "metadata": {
        "id": "m1JAIOdpgaZ_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#net = VAE()\n",
        "for name, param in net.named_parameters():\n",
        "  if \"weight\" in name:\n",
        "    print(f\"Name: {name}, mean: {param.mean()}, std: {param.std()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A6IaKpSGgqoL",
        "outputId": "fb2a1267-d6a7-4e49-c6d2-91a80120b8f0"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: encoder_conv.0.weight, mean: -0.007121846545487642, std: 0.11122100055217743\n",
            "Name: encoder_conv.2.weight, mean: 0.0006974564748816192, std: 0.02904246747493744\n",
            "Name: encoder_linear.0.weight, mean: -2.0403147615866146e-08, std: 0.00463792635127902\n",
            "Name: encoder_linear.1.weight, mean: -0.00018398139218334109, std: 0.05261940509080887\n",
            "Name: decoder_linear.0.weight, mean: -0.000797932269051671, std: 0.07415377348661423\n",
            "Name: decoder_linear.1.weight, mean: -3.500385719235055e-05, std: 0.05269685387611389\n",
            "Name: decoder_conv.0.weight, mean: 9.979640890378505e-05, std: 0.02864549309015274\n",
            "Name: decoder_conv.2.weight, mean: 0.007021212950348854, std: 0.11655139178037643\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RH6OvRMjUr53"
      },
      "source": [
        "## Visualize AE outputs"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "output[0].min()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T3nbjBlesWRI",
        "outputId": "7b556087-5aec-499b-b416-253f084f1aab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.5000)"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0cXYyb2JVEPb",
        "outputId": "95e09ccb-ec35-4398-8f02-55ba56b8faa4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Selected model for evaluation:  /content/drive/MyDrive/kaggle/1677616546.pt\n"
          ]
        }
      ],
      "source": [
        "desired_model_name = None\n",
        "desired_model_path = os.path.join(\"/content/drive/MyDrive/kaggle\", sorted([ x for x in os.listdir('/content/drive/MyDrive/kaggle') if len(x)>3 and \"_ae.pt\" in x ])[-1] if desired_model_name is None else desired_model_name)\n",
        "print('Selected model for evaluation: ', desired_model_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 521
        },
        "id": "yLC6XDFrUzO-",
        "outputId": "46d052a4-d0f0-40ce-ad5f-247b9fe6dff9"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "net = VAE()\n",
        "net.load_state_dict(torch.load(desired_model_path))\n",
        "net.eval()\n",
        "\n",
        "for i, batch in enumerate(test_loader):\n",
        "  if i != 0:\n",
        "    break \n",
        "  X, y = batch\n",
        "  reconstruction = net.inference(X)\n",
        "  # show orig\n",
        "  # show reconstruction\n",
        "show_batch(X)\n",
        "show_batch(reconstruction)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bxB8Yx-ezkNA",
        "outputId": "ece35129-070e-4a4a-de51-8c36bb634d7e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "reconstruction.requires_grad"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RMOB72dLUv5o"
      },
      "source": [
        "## Validate Quantitatively"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pv0JvM_fVKjK"
      },
      "outputs": [],
      "source": [
        "net = Classifier()\n",
        "net.load_state_dict(torch.load(desired_model_path))\n",
        "net.confidence = 0.75\n",
        "net.eval()\n",
        "\n",
        "def evaluate(model, loader):\n",
        "  all_preds = []\n",
        "  all_labels = []\n",
        "  for i, batch in enumerate(loader):\n",
        "    X, y = batch\n",
        "    out = model.inference(X)\n",
        "    all_preds += list(out.detach().squeeze(1).numpy())\n",
        "    all_labels += list(y.numpy())\n",
        "  all_preds = np.array(all_preds)\n",
        "  all_labels = np.array(all_labels)\n",
        "  f_neg, f_pos, t_neg, t_pos = (np.logical_and(all_preds==0, all_labels==1).sum(), \n",
        "                              np.logical_and(all_preds==1, all_labels==0).sum(), \n",
        "                              np.logical_and(all_preds==0, all_labels==0).sum(), \n",
        "                              np.logical_and(all_preds==1, all_labels==1).sum()\n",
        "                              )\n",
        "  n = float(len(all_labels))\n",
        "  print(f\"False negatives: {f_neg} ({100*f_neg/n}% of total)\")\n",
        "  print(f\"False positives: {f_pos} ({100*f_pos/n}% of total)\")\n",
        "  print(f\"True negatives:  {t_neg} ({100*t_neg/n}% of total)\")\n",
        "  print(f\"True positives:  {t_pos} ({100*t_pos/n}% of total)\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8kIjR30hVKgD"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4lTbqi87CRlg"
      },
      "source": [
        "## TODO:\n",
        "* reduce kernel sizes to make simpler and lower training time/fewer parameters\n",
        "* Try out simple AE, then VAE, then disentangle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0_9CHjsuPHKL",
        "outputId": "4a28854b-e8c3-4937-8402-02636ed91313"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "x shape:  torch.Size([10, 113288])\n",
            "x shape:  torch.Size([10, 8, 119, 119])\n",
            "x shape:  torch.Size([10, 1, 500, 500])\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "torch.Size([10, 1, 500, 500])"
            ]
          },
          "execution_count": 97,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "net = VAE()\n",
        "X, y = next(iter(train_loader))\n",
        "#latent = net.encode(X)\n",
        "#print(f\"Latent shape: {latent.shape}\")\n",
        "out = net(X)\n",
        "out.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9DsTKpPD81pY",
        "outputId": "50a600ce-d994-44f9-993e-d4508e6f1373"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "253"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(ds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RgXY_hahLh60"
      },
      "source": [
        "## Idea\n",
        "* What if I try characterizing the latent space. In word embeddings, there are concept vectors like gender. Vec_man - Vec_woman is parallel to Vec_king - Vec_king. What if I'm able to visualize the distribution in latent space (perhaps via dimensionality reduction) and get the \"concept vector\" of tumor, and perhaps some other features? \n",
        "* And then demonstrate generation based on variations of adding that feature to embeddings. So if v_tumor is = tumor_centroid - non_tumor_centroid in embedding space, do the following. 1. Embed a non-tumor image, 2. Add v_tumor to the embedding, 3. Decode and hopefully get a very similar image but with a tumor. Can also do the whole process in reverse, subtracting the v_tumor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UpAN-X_hMSw8"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "e0TyY1y6_XMh",
        "CmW-i0D1_euu",
        "GwQVNBJKACJt",
        "nsEvokzKIImo",
        "frx4SoTAvOgB",
        "iLEa6PokUahT",
        "RwNRo_lo6H2D",
        "Id0Rj_hJY1YJ"
      ],
      "provenance": [],
      "mount_file_id": "1vBR3l898pLkKFpwGbnOCL5m6dF0TLTkx",
      "authorship_tag": "ABX9TyNkC0wzmDmj3SzNggWOEU1T",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}