AE.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "AE.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxElr7JuG2eh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac8b9c77-4c99-4cf5-d129-8b4778f62394"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Wed Feb  3 07:06:02 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.39       Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   42C    P0    28W / 250W |      0MiB / 16280MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F5luZ8m2G2Ti"
      },
      "source": [
        "import cv2\r\n",
        "import glob\r\n",
        "import pandas as pd\r\n",
        "import torch\r\n",
        "import torch.nn as nn\r\n",
        "import torch.optim as optim\r\n",
        "from torch import cuda\r\n",
        "from torch.optim import lr_scheduler\r\n",
        "from torch.autograd import Variable\r\n",
        "import numpy as np\r\n",
        "import torchvision\r\n",
        "from torchvision import datasets, models, transforms\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import time\r\n",
        "import os\r\n",
        "import copy\r\n",
        "from PIL import Image\r\n",
        "from sklearn.metrics import roc_auc_score, average_precision_score\r\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 966
        },
        "id": "5c2n76k9mZQ5",
        "outputId": "8e4f58de-134f-45ab-b4ab-fc1ee1160f15"
      },
      "source": [
        "print('==> Preparing data..')\r\n",
        "from sklearn.model_selection import GroupShuffleSplit\r\n",
        "from torch.utils.data import Dataset, DataLoader\r\n",
        "import pandas as pd\r\n",
        "import numpy as np\r\n",
        "import glob\r\n",
        "import re\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import seaborn as sns\r\n",
        "\r\n",
        "class TrainValTestSplitter:\r\n",
        "\r\n",
        "    def __init__(self, path_to_data, test=False, split='train/val', show_labels_dist=False, random_state=42):\r\n",
        "        \"\"\"\r\n",
        "        Train-validation-test splitter, stores all the filenames\r\n",
        "        :param path_to_data: for glob.glob to find all the images path\r\n",
        "        :param show_labels_dist: show plot of distributions of labels\r\n",
        "        \"\"\"\r\n",
        "        path_to_data = f'{path_to_data}/*/*/*'\r\n",
        "        self.random_state = random_state\r\n",
        "        self.show_labels_dist = show_labels_dist\r\n",
        "        self.data = pd.DataFrame()\r\n",
        "        self.data['path'] = glob.glob(path_to_data)\r\n",
        "        self.data['label'] = self.data['path'].apply(lambda path: len(re.findall('positive', path)))\r\n",
        "        self.data['patient'] = self.data['path'].apply(lambda path: re.findall('[0-9]{5}', path)[0])\r\n",
        "        if test:\r\n",
        "            self._split_stats(self.data)\r\n",
        "        else:\r\n",
        "            self._split_data(split)\r\n",
        "\r\n",
        "    def _split_stats(self, df):\r\n",
        "        print(f'Size: {len(df)}')\r\n",
        "        print(f'Percentage from original data: {len(df)/len(self.data)}')\r\n",
        "        print(f'Percentage of negatives: {len(df[df.label == 0])/len(df)}')\r\n",
        "        print(f'Percentage of positives: {1-(len(df[df.label == 0])/len(df))}')\r\n",
        "        print(f'Number of patients: {len(df.patient.unique())}')\r\n",
        "        if self.show_labels_dist:\r\n",
        "            import seaborn as sns\r\n",
        "            sns.countplot(df['label'])\r\n",
        "            plt.title('Labels distribution')\r\n",
        "            plt.show()\r\n",
        "\r\n",
        "    def train_val(self):\r\n",
        "            # train | validate split\r\n",
        "            splitter = GroupShuffleSplit(n_splits=1, test_size=0.15, random_state=self.random_state)\r\n",
        "            negative_data = self.data[self.data.label == 0]\r\n",
        "            generator = splitter.split(negative_data.label, groups=negative_data['patient'])\r\n",
        "            idx_train, idx_validate_test = next(generator)\r\n",
        "\r\n",
        "            print('\\n=================Train subset=================')\r\n",
        "            self.data_train = negative_data.iloc[idx_train, :].reset_index(drop=True)\r\n",
        "            self._split_stats(self.data_train)\r\n",
        "            \r\n",
        "            # validate split\r\n",
        "            print('\\n=============Validation subset===============')\r\n",
        "            data_val_test = pd.concat([self.data[self.data.label == 1], self.data.iloc[negative_data.iloc[idx_validate_test, :].index]]) \r\n",
        "            self.data_val = data_val_test.sample(len(data_val_test)).reset_index(drop=True)\r\n",
        "            self._split_stats(data_val_test)\r\n",
        "            \r\n",
        "    def train_val_test(self): \r\n",
        "            # train | validate test split\r\n",
        "            splitter = GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=self.random_state)\r\n",
        "            negative_data = self.data[self.data.label == 0]\r\n",
        "            generator = splitter.split(negative_data.label, groups=negative_data['patient'])\r\n",
        "            idx_train, idx_validate_test = next(generator)\r\n",
        "\r\n",
        "            print('\\n=================Train subset=================')\r\n",
        "            data_val_test = pd.concat([self.data[self.data.label == 1], self.data.iloc[negative_data.iloc[idx_validate_test, :].index]])\r\n",
        "            self.data_train = negative_data.iloc[idx_train, :].reset_index(drop=True)\r\n",
        "            self._split_stats(data_val_test)\r\n",
        "\r\n",
        "            # validate | test split\r\n",
        "            data_val_test = pd.concat([self.data[self.data.label == 1], self.data.iloc[negative_data.iloc[idx_validate_test, :].index]])\r\n",
        "            splitter = GroupShuffleSplit(n_splits=1, test_size=0.50, random_state=self.random_state)\r\n",
        "            generator = splitter.split(data_val_test.label, groups=data_val_test['patient'])\r\n",
        "            idx_val, idx_test = next(generator)\r\n",
        "\r\n",
        "            print('\\n=============Validation subset===============')\r\n",
        "            self.data_val = data_val_test.iloc[idx_val, :]\r\n",
        "            self.data_val = self.data_val.sample(len(self.data_val)).reset_index(drop=True)\r\n",
        "            self._split_stats(self.data_val)\r\n",
        "\r\n",
        "            print('\\n=================Test subset=================')\r\n",
        "            self.data_test = data_val_test.iloc[idx_test, :]\r\n",
        "            self.data_test = self.data_test.sample(len(self.data_test)).reset_index(drop=True)\r\n",
        "            self._split_stats(self.data_test)      \r\n",
        "          \r\n",
        "    def _split_data(self, split='train/val'):\r\n",
        "        \"\"\"\r\n",
        "        Creates data_train, data_val, data_test dataframes with filenames\r\n",
        "        \"\"\"\r\n",
        "        if split == 'train/val': self.train_val()\r\n",
        "        elif split == 'train/val/test': self.train_val_test()\r\n",
        "\r\n",
        "class MURASubset(Dataset):\r\n",
        "\r\n",
        "    def __init__(self, filenames, transform=None, n_channels=1, true_labels=None, patients=None):\r\n",
        "        \"\"\"Initialization\r\n",
        "        :param filenames: list of filenames, e.g. from TrainValTestSplitter\r\n",
        "        :param true_labels: list of true labels (for validation and split)\r\n",
        "        \"\"\"\r\n",
        "        self.transform = transform\r\n",
        "        self.filenames = list(filenames)\r\n",
        "        self.n_channels = n_channels\r\n",
        "        self.true_labels = true_labels\r\n",
        "        self.patients = patients\r\n",
        "\r\n",
        "    def __len__(self) -> int:\r\n",
        "        \"\"\"Denotes the number of batches per epoch\"\"\"\r\n",
        "        return len(self.filenames)\r\n",
        "\r\n",
        "    def __getitem__(self, index) -> np.array:\r\n",
        "        \"\"\"Reads sample\"\"\"\r\n",
        "        if self.n_channels == 1: image = cv2.imread(self.filenames[index])\r\n",
        "        image = cv2.imread(self.filenames[index])\r\n",
        "        label = self.true_labels[index] if self.true_labels is not None else None\r\n",
        "        patient = self.patients[index] if self.true_labels is not None else None\r\n",
        "        filenames = self.filenames[index]\r\n",
        "\r\n",
        "        if self.transform:\r\n",
        "            image = self.transform(image)\r\n",
        "\r\n",
        "        return image, label, index\r\n",
        "\r\n",
        "ROOT_PATH = './drive/MyDrive/MURA-v1.1'\r\n",
        "print(ROOT_PATH)\r\n",
        "DATA_PATH = f'{ROOT_PATH}/train'\r\n",
        "VALID_PATH = f'{ROOT_PATH}/valid'\r\n",
        "print(DATA_PATH, VALID_PATH)\r\n",
        "\r\n",
        "run_params = {\r\n",
        "    'pipeline': {\r\n",
        "        'data_source': 'XR_SHOULDER',\r\n",
        "    }\r\n",
        "}\r\n",
        "\r\n",
        "data_path = f'{DATA_PATH}/{run_params[\"pipeline\"][\"data_source\"]}'\r\n",
        "splitter = TrainValTestSplitter(path_to_data=data_path, test=False, split='train/val', show_labels_dist=True)\r\n",
        "\r\n",
        "train_transform = transforms.Compose([\r\n",
        "                                transforms.ToPILImage(),                                      \r\n",
        "                                transforms.Resize((256,256)),\r\n",
        "                                transforms.ToTensor()])\r\n",
        "\r\n",
        "trainset = MURASubset(splitter.data_train.path, train_transform, n_channels=3, true_labels=splitter.data_train.label, patients=splitter.data_train.patient)\r\n",
        "trainloader = DataLoader(trainset, batch_size=8, shuffle=True)\r\n",
        "valset = MURASubset(splitter.data_val.path, train_transform, n_channels=3, true_labels=splitter.data_val.label, patients=splitter.data_val.patient)\r\n",
        "valloader = DataLoader(valset, batch_size=32, shuffle=True)\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "==> Preparing data..\n",
            "./drive/MyDrive/MURA-v1.1\n",
            "./drive/MyDrive/MURA-v1.1/train ./drive/MyDrive/MURA-v1.1/valid\n",
            "\n",
            "=================Train subset=================\n",
            "Size: 3601\n",
            "Percentage from original data: 0.42976488841150495\n",
            "Percentage of negatives: 1.0\n",
            "Percentage of positives: 0.0\n",
            "Number of patients: 1130\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
            "  FutureWarning\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAW7UlEQVR4nO3de7RedX3n8ffHELyhEsoZhCQQxLQ2dmrUI6B1Oogjt9UutAtdMCopWqNrwqpdyzpFXV2oiLUzWqd4oZPWyMULZaSOGZuRpngbpuUSnIgEZDiDMEnkEgkXEWUEv/PH8zv6eDgn+wTO85xzkvdrrb3Ofr77t/f+Plkr53P25dlPqgpJknblSbPdgCRp7jMsJEmdDAtJUifDQpLUybCQJHUyLCRJnQwL7VGSfD3JHwx73QnbuS3Jv2nz707yN090m33bfjDJc9r8BUk+MIPb/qskfzpT29OexbDQnNT/C3c+q6oPVlVnAE03qKpqv6q69Yn2leT3k1w5Ydtvq6pznui2tWcyLKR5IMk+s92D9m6GheaVJIuSfDnJjiT3tvklE4YdkeSaJA8k+VKSA/rWPzrJPyW5L8m3kxwzxX6em+QbSe5P8oMkf7uLnt6Y5PYk9yR5z4Rl703ymTb/lCSfaePuS3JtkoOSnAv8K+Dj7TTTx9v4SrImyS3ALX215/bt4sAkG5P8sPV7WBu3rI3dp6+Xryf5gyS/DvwV8NK2v/va8l86rZXkLUnGkuxMsj7JIX3LKsnbktzS3ssnkmSqfyPNf4aF5psnAZ8GDgMOBX4MfHzCmNOBNwEHA48A5wEkWQz8PfAB4ADgj4HLkoxMsp9zgH8AFgFLgI9N1kySFcD5wBuBQ4BfaeMnswp4FrC0jXsb8OOqeg/wP4Az22mmM/vWeTVwFLBiim2+vvV6ILAZ+OwU436uqm5q+/7ntr/9J3lfxwJ/BryO3r/j7cAlE4b9DvAS4DfbuOO79q35y7DQvFJV91TVZVX1UFX9EDgX+NcThl1cVTdU1Y+APwVel2QB8AZgQ1VtqKqfVdVGYBNw0iS7+im9QDqkqn5SVVdOMgbgFODLVfXNqnq47e9nU4z9Kb2QeG5VPVpV11XVAx1v+c+qamdV/XiK5X/ft+/30DtaWNqxzel4PbCuqr7Vtv2utu1lfWM+VFX3VdX/Bb4GrJyB/WqOMiw0ryR5WpL/3E77PAB8E9i/hcG4rX3ztwML6f3lfRjw2nba5L52+uXl9P5ynujfAwGuSbIlyZumaOmQ/v21gLpnirEXA5cDlyT5fpL/kGRhx1veOt3lVfUgsLP19EQdQu/frn/b9wCL+8bc2Tf/ELDfDOxXc5RhofnmHcCvAUdV1TOB3271/vPl/X9ZH0rvL/of0PvFenFV7d83Pb2qPjRxJ1V1Z1W9paoOAd4KfHLCtYJxd/TvL8nT6B09PEZV/bSq3ldVK4CX0TuNc/r44ineb9djofv3vR+902vfB37Uyk/rG/vs3dju9+mF6/i2n07vfW3vWE97KMNCc9nCdlF4fNoHeAa96xT3tQvXZ0+y3huSrGi/uN8PfKGqHgU+A/xukuOTLGjbPGaSC+QkeW1f/V56v1wnO730BeB3krw8yb5tf5P+v0ryiiT/sh0FPUAvxMa3eRfwnGn9q/yyk/r2fQ5wVVVtraod9H6xv6G91zcBR/StdxewpK03mc8DZyRZmeTJwAeBq6vqtsfRo/YAhoXmsg30gmF8ei/wn4Cn0jtSuAr4yiTrXQxcQO80yVOAPwSoqq3AycC7gR30jjTeyeT/D14CXJ3kQWA98PbJPt9QVVuANcDn6B1l3Atsm+L9PJteuDwA3AR8o/UK8JfAKe0Or/OmWH8yn6MXmDuBF9O7LjPuLe393QM8H/invmVfBbYAdyb5wSTv6x/pXX+5rL2vI4BTd6Mv7WHilx9Jkrp4ZCFJ6mRYSJI6GRaSpE6GhSSp0x75cLIDDzywli1bNtttSNK8ct111/2gqiZ7/M2eGRbLli1j06ZNs92GJM0rSW6fapmnoSRJnQwLSVInw0KS1MmwkCR1MiwkSZ0MC0lSJ8NCktTJsJAkdTIsJEmd9shPcM8VL37nRbPdgqR54rr/eHr3oFnkkYUkqdPAwqJ9v/E1Sb6dZEuS97X6BUm+l2Rzm1a2epKcl2QsyfVJXtS3rVVJbmnTqkH1LEma3CBPQz0MHFtVDyZZCFyZ5L+3Ze+sqi9MGH8isLxNRwHnA0clOYDedwyPAgVcl2R9Vd07wN4lSX0GdmRRPQ+2lwvbtKsv/D4ZuKitdxWwf5KDgeOBjVW1swXERuCEQfUtSXqsgV6zSLIgyWbgbnq/8K9ui85tp5o+muTJrbYY2Nq3+rZWm6ouSRqSgYZFVT1aVSuBJcCRSX4DeBfwPOAlwAHAn8zEvpKsTrIpyaYdO3bMxCYlSc1Q7oaqqvuArwEnVNUd7VTTw8CngSPbsO3A0r7VlrTaVPWJ+1hbVaNVNToyMukXPUmSHqdB3g01kmT/Nv9U4FXAd9t1CJIEeDVwQ1tlPXB6uyvqaOD+qroDuBw4LsmiJIuA41pNkjQkg7wb6mDgwiQL6IXSpVX15SRfTTICBNgMvK2N3wCcBIwBDwFnAFTVziTnANe2ce+vqp0D7FuSNMHAwqKqrgdeOEn92CnGF7BmimXrgHUz2qAkadr8BLckqZNhIUnqZFhIkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqROhoUkqZNhIUnqZFhIkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE4DC4skT0lyTZJvJ9mS5H2tfniSq5OMJfnbJPu2+pPb67G2fFnftt7V6jcnOX5QPUuSJjfII4uHgWOr6gXASuCEJEcDfw58tKqeC9wLvLmNfzNwb6t/tI0jyQrgVOD5wAnAJ5MsGGDfkqQJBhYW1fNge7mwTQUcC3yh1S8EXt3mT26vactfmSStfklVPVxV3wPGgCMH1bck6bEGes0iyYIkm4G7gY3A/wHuq6pH2pBtwOI2vxjYCtCW3w/8Sn99knX697U6yaYkm3bs2DGItyNJe62BhkVVPVpVK4El9I4GnjfAfa2tqtGqGh0ZGRnUbiRprzSUu6Gq6j7ga8BLgf2T7NMWLQG2t/ntwFKAtvxZwD399UnWkSQNwSDvhhpJsn+bfyrwKuAmeqFxShu2CvhSm1/fXtOWf7WqqtVPbXdLHQ4sB64ZVN+SpMfap3vI43YwcGG7c+lJwKVV9eUkNwKXJPkA8L+AT7XxnwIuTjIG7KR3BxRVtSXJpcCNwCPAmqp6dIB9S5ImGFhYVNX1wAsnqd/KJHczVdVPgNdOsa1zgXNnukdJ0vT4CW5JUifDQpLUybCQJHUyLCRJnQwLSVInw0KS1MmwkCR1MiwkSZ0MC0lSJ8NCktTJsJAkdTIsJEmdDAtJUifDQpLUybCQJHUyLCRJnQwLSVInw0KS1MmwkCR1MiwkSZ0GFhZJlib5WpIbk2xJ8vZWf2+S7Uk2t+mkvnXelWQsyc1Jju+rn9BqY0nOGlTPkqTJ7TPAbT8CvKOqvpXkGcB1STa2ZR+tqg/3D06yAjgVeD5wCPCPSX61Lf4E8CpgG3BtkvVVdeMAe5ck9RlYWFTVHcAdbf6HSW4CFu9ilZOBS6rqYeB7ScaAI9uysaq6FSDJJW2sYSFJQzKUaxZJlgEvBK5upTOTXJ9kXZJFrbYY2Nq32rZWm6o+cR+rk2xKsmnHjh0z/A4kae828LBIsh9wGfBHVfUAcD5wBLCS3pHHR2ZiP1W1tqpGq2p0ZGRkJjYpSWoGec2CJAvpBcVnq+rvAKrqrr7lfw18ub3cDiztW31Jq7GLuiRpCAZ5N1SATwE3VdVf9NUP7hv2GuCGNr8eODXJk5McDiwHrgGuBZYnOTzJvvQugq8fVN+SpMca5JHFbwFvBL6TZHOrvRs4LclKoIDbgLcCVNWWJJfSu3D9CLCmqh4FSHImcDmwAFhXVVsG2LckaYJB3g11JZBJFm3YxTrnAudOUt+wq/UkSYPlJ7glSZ0MC0lSJ8NCktTJsJAkdTIsJEmdDAtJUifDQpLUybCQJHUyLCRJnQwLSVInw0KS1MmwkCR1MiwkSZ0MC0lSJ8NCktTJsJAkdTIsJEmdDAtJUqdphUWSK6ZTkyTtmXb5HdxJngI8DTgwySJ+8Z3azwQWD7g3SdIc0XVk8VbgOuB57ef49CXg47taMcnSJF9LcmOSLUne3uoHJNmY5Jb2c1GrJ8l5ScaSXJ/kRX3bWtXG35Jk1eN/u5Kkx2OXYVFVf1lVhwN/XFXPqarD2/SCqtplWACPAO+oqhXA0cCaJCuAs4Arqmo5cEV7DXAisLxNq4HzoRcuwNnAUcCRwNnjASNJGo5dnoYaV1UfS/IyYFn/OlV10S7WuQO4o83/MMlN9E5dnQwc04ZdCHwd+JNWv6iqCrgqyf5JDm5jN1bVToAkG4ETgM9P901Kkp6YaYVFkouBI4DNwKOtXMCUYTFh/WXAC4GrgYNakADcCRzU5hcDW/tW29ZqU9Un7mM1vSMSDj300Om0JUmapmmFBTAKrGh/9e+WJPsBlwF/VFUPJPn5sqqqJLu9zclU1VpgLcDo6OiMbFOS1DPdz1ncADx7dzeeZCG9oPhsVf1dK9/VTi/Rft7d6tuBpX2rL2m1qeqSpCGZblgcCNyY5PIk68enXa2Q3iHEp4Cbquov+hatB8bvaFpF786q8frp7a6oo4H72+mqy4HjkixqF7aPazVJ0pBM9zTUex/Htn8LeCPwnSSbW+3dwIeAS5O8GbgdeF1btgE4CRgDHgLOAKiqnUnOAa5t494/frFbkjQc070b6hu7u+GqupJffIhvoldOMr6ANVNsax2wbnd7kCTNjOneDfVDenc/AewLLAR+VFXPHFRjkqS5Y7pHFs8Yn2/XIk6m90E7SdJeYLefOls9/xU4fgD9SJLmoOmehvq9vpdPove5i58MpCNJ0pwz3buhfrdv/hHgNnqnoiRJe4HpXrM4Y9CNSJLmrul++dGSJF9McnebLkuyZNDNSZLmhule4P40vU9YH9Km/9ZqkqS9wHTDYqSqPl1Vj7TpAmBkgH1JkuaQ6YbFPUnekGRBm94A3DPIxiRJc8d0w+JN9J7hdCe9LzQ6Bfj9AfUkSZpjpnvr7PuBVVV1L/z8q04/TC9EJEl7uOkeWfzmeFBA70mw9L75TpK0F5huWDypfZcE8PMji+kelUiS5rnp/sL/CPDPSf5Le/1a4NzBtCRJmmum+wnui5JsAo5tpd+rqhsH15YkaS6Z9qmkFg4GhCTthXb7EeWSpL2PYSFJ6jSwsEiyrj108Ia+2nuTbE+yuU0n9S17V5KxJDcnOb6vfkKrjSU5a1D9SpKmNsgjiwuAEyapf7SqVrZpA0CSFcCpwPPbOp8cf7QI8AngRGAFcFobK0kaooF9VqKqvplk2TSHnwxcUlUPA99LMgYc2ZaNVdWtAEkuaWO90C5JQzQb1yzOTHJ9O001/kG/xcDWvjHbWm2quiRpiIYdFucDRwAr6T2Q8CMzteEkq5NsSrJpx44dM7VZSRJDDouququqHq2qnwF/zS9ONW0HlvYNXdJqU9Un2/baqhqtqtGREb9qQ5Jm0lDDIsnBfS9fA4zfKbUeODXJk5McDiwHrgGuBZYnOTzJvvQugq8fZs+SpAFe4E7yeeAY4MAk24CzgWOSrAQKuA14K0BVbUlyKb0L148Aa6rq0badM4HLgQXAuqraMqieJUmTG+TdUKdNUv7ULsafyyQPJ2y3126YwdYkSbvJT3BLkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqROhoUkqZNhIUnqZFhIkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSeo0sLBIsi7J3Ulu6KsdkGRjklvaz0WtniTnJRlLcn2SF/Wts6qNvyXJqkH1K0ma2iCPLC4ATphQOwu4oqqWA1e01wAnAsvbtBo4H3rhApwNHAUcCZw9HjCSpOEZWFhU1TeBnRPKJwMXtvkLgVf31S+qnquA/ZMcDBwPbKyqnVV1L7CRxwaQJGnAhn3N4qCquqPN3wkc1OYXA1v7xm1rtanqj5FkdZJNSTbt2LFjZruWpL3crF3grqoCaga3t7aqRqtqdGRkZKY2K0li+GFxVzu9RPt5d6tvB5b2jVvSalPVJUlDNOywWA+M39G0CvhSX/30dlfU0cD97XTV5cBxSRa1C9vHtZokaYj2GdSGk3weOAY4MMk2enc1fQi4NMmbgduB17XhG4CTgDHgIeAMgKrameQc4No27v1VNfGiuSRpwAYWFlV12hSLXjnJ2ALWTLGddcC6GWxNkrSb/AS3JKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqROhoUkqZNhIUnqZFhIkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqROsxIWSW5L8p0km5NsarUDkmxMckv7uajVk+S8JGNJrk/yotnoWZL2ZrN5ZPGKqlpZVaPt9VnAFVW1HLiivQY4EVjeptXA+UPvVJL2cnPpNNTJwIVt/kLg1X31i6rnKmD/JAfPRoOStLearbAo4B+SXJdkdasdVFV3tPk7gYPa/GJga9+621rtlyRZnWRTkk07duwYVN+StFfaZ5b2+/Kq2p7kXwAbk3y3f2FVVZLanQ1W1VpgLcDo6OhurStJ2rVZObKoqu3t593AF4EjgbvGTy+1n3e34duBpX2rL2k1SdKQDD0skjw9yTPG54HjgBuA9cCqNmwV8KU2vx44vd0VdTRwf9/pKknSEMzGaaiDgC8mGd//56rqK0muBS5N8mbgduB1bfwG4CRgDHgIOGP4LUvS3m3oYVFVtwIvmKR+D/DKSeoFrBlCa5KkKcylW2clSXOUYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqROhoUkqZNhIUnqZFhIkjoZFpKkToaFJKmTYSFJ6mRYSJI6GRaSpE6GhSSpk2EhSepkWEiSOhkWkqRO8yYskpyQ5OYkY0nOmu1+JGlvMi/CIskC4BPAicAK4LQkK2a3K0nae8yLsACOBMaq6taq+n/AJcDJs9yTJO019pntBqZpMbC17/U24Kj+AUlWA6vbyweT3Dyk3qTddSDwg9luQnNLPrxqtlsAOGyqBfMlLDpV1Vpg7Wz3IXVJsqmqRme7D2l3zJfTUNuBpX2vl7SaJGkI5ktYXAssT3J4kn2BU4H1s9yTJO015sVpqKp6JMmZwOXAAmBdVW2Z5bakx8vTpZp3UlWz3YMkaY6bL6ehJEmzyLCQJHUyLKQh8ZE1ms+8ZiENQXtkzf8GXkXvQ6XXAqdV1Y2z2pg0TR5ZSMPhI2s0rxkW0nBM9siaxbPUi7TbDAtJUifDQhoOH1mjec2wkIbDR9ZoXpsXj/uQ5jsfWaP5zltnJUmdPA0lSepkWEiSOhkWkqROhoUkqZNhIUnqZFhIMyDJgx3LlyW5YTe3eUGSU55YZ9LMMCwkSZ0MC2kGJdkvyRVJvpXkO0n6nyy7T5LPJrkpyReSPK2t8+Ik30hyXZLLkxw8S+1LUzIspJn1E+A1VfUi4BXAR5KkLfs14JNV9evAA8C/S7IQ+BhwSlW9GFgHnDsLfUu75OM+pJkV4INJfhv4Gb3HkB/Ulm2tqv/Z5j8D/CHwFeA3gI0tUxYAdwy1Y2kaDAtpZr0eGAFeXFU/TXIb8JS2bOKzdYpeuGypqpcOr0Vp93kaSppZzwLubkHxCuCwvmWHJhkPhX8LXAncDIyM15MsTPL8oXYsTYNhIc2szwKjSb4DnA58t2/ZzcCaJDcBi4Dz21esngL8eZJvA5uBlw25Z6mTT52VJHXyyEKS1MmwkCR1MiwkSZ0MC0lSJ8NCktTJsJAkdTIsJEmd/j/Yb4eEYeacfAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "=============Validation subset===============\n",
            "Size: 4778\n",
            "Percentage from original data: 0.570235111588495\n",
            "Percentage of negatives: 0.12766848053578903\n",
            "Percentage of positives: 0.872331519464211\n",
            "Number of patients: 1610\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
            "  FutureWarning\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b4unqnKeLiIo"
      },
      "source": [
        "def imshow(inp, title=None):\r\n",
        "    inp = inp.numpy().transpose((1, 2, 0))\r\n",
        "    plt.figure(figsize=(6,6))\r\n",
        "    plt.axis('off')\r\n",
        "    plt.imshow(inp)\r\n",
        "    if title is not None:\r\n",
        "        plt.title(title)\r\n",
        "    plt.pause(0.001)\r\n",
        "\r\n",
        "def show_databatch(inputs):\r\n",
        "    out = torchvision.utils.make_grid(inputs[:16])\r\n",
        "    imshow(out)\r\n",
        "\r\n",
        "# Get a batch of training data\r\n",
        "inp, tr, _ = next(iter(valloader))\r\n",
        "show_databatch(inp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ex_TKvxLD60C"
      },
      "source": [
        "  \r\n",
        "import torch\r\n",
        "import torch.nn as nn\r\n",
        "import torch.nn.functional as F\r\n",
        "import torchvision\r\n",
        "import torchvision.models as models\r\n",
        "\r\n",
        "import logging\r\n",
        "import torch.nn as nn\r\n",
        "import numpy as np\r\n",
        "\r\n",
        "\r\n",
        "class BaseNet(nn.Module):\r\n",
        "    \"\"\"Base class for all neural networks.\"\"\"\r\n",
        "\r\n",
        "    def __init__(self):\r\n",
        "        super().__init__()\r\n",
        "        self.logger = logging.getLogger(self.__class__.__name__)\r\n",
        "        self.rep_dim = None  # representation dimensionality, i.e. dim of the last layer\r\n",
        "\r\n",
        "    def forward(self, *input):\r\n",
        "        \"\"\"\r\n",
        "        Forward pass logic\r\n",
        "        :return: Network output\r\n",
        "        \"\"\"\r\n",
        "        raise NotImplementedError\r\n",
        "\r\n",
        "    def summary(self):\r\n",
        "        \"\"\"Network summary.\"\"\"\r\n",
        "        net_parameters = filter(lambda p: p.requires_grad, self.parameters())\r\n",
        "        params = sum([np.prod(p.size()) for p in net_parameters])\r\n",
        "        self.logger.info('Trainable parameters: {}'.format(params))\r\n",
        "        self.logger.info(self)\r\n",
        "\r\n",
        "class Normalize(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self, power=2):\r\n",
        "        super(Normalize, self).__init__()\r\n",
        "        self.power = power\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        norm = x.pow(self.power).sum(1, keepdim=True).pow(1. / self.power)\r\n",
        "        out = x.div(norm)\r\n",
        "        return out\r\n",
        "\r\n",
        "class ResNet18(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self, rep_dim):\r\n",
        "        super(ResNet18, self).__init__()\r\n",
        "        \r\n",
        "        model = models.resnet18(pretrained=True)\r\n",
        "        self.conv1 = model.conv1\r\n",
        "        self.bn1 = model.bn1\r\n",
        "        self.relu = model.relu\r\n",
        "        self.layer1 = model.layer1\r\n",
        "        self.layer2 = model.layer2\r\n",
        "        self.layer3 = model.layer3\r\n",
        "        self.layer4 = model.layer4\r\n",
        "        self.avgpool = model.avgpool\r\n",
        "        self.fc = nn.Linear(in_features=512, out_features=rep_dim, bias=True)\r\n",
        "        self.l2norm = Normalize(2)\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        x = self.conv1(x)\r\n",
        "        x = self.bn1(x)\r\n",
        "        x = self.relu(x)\r\n",
        "        x = self.layer1(x)\r\n",
        "        x = self.layer2(x)\r\n",
        "        x = self.layer3(x)\r\n",
        "        feature = self.layer4(x)\r\n",
        "        x = self.avgpool(feature)\r\n",
        "        x = x.view(-1, 512)\r\n",
        "        x = self.fc(x)\r\n",
        "        x = self.l2norm(x)\r\n",
        "        return x, feature\r\n",
        "        \r\n",
        "        \r\n",
        "class UPBlock(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self, ich, och, upsample=False):\r\n",
        "        super(UPBlock, self).__init__()\r\n",
        "        \r\n",
        "        self.upsample = upsample\r\n",
        "        self.upsampleLayer = nn.Sequential(nn.Upsample(mode='bilinear', scale_factor=2, align_corners=True),\r\n",
        "                                        nn.Conv2d(ich, och, kernel_size=1, bias=False),\r\n",
        "                                        nn.BatchNorm2d(och, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)) if upsample else  None\r\n",
        "                                        \r\n",
        "        self.conv1 = nn.Sequential(nn.Conv2d(ich, och, 3, 1, 1, bias=False),\r\n",
        "                nn.BatchNorm2d(och, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\r\n",
        "        self.relu = nn.ReLU(True)           \r\n",
        "        self.conv2 = nn.Conv2d(och, och, 3, 1, 1, bias=False)\r\n",
        "        self.bnrm = nn.BatchNorm2d(och, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\r\n",
        "                                    \r\n",
        "    def forward(self, x):\r\n",
        "        if self.upsample:\r\n",
        "            identity = self.upsampleLayer(x)\r\n",
        "            out = identity\r\n",
        "        else:\r\n",
        "            identity = x\r\n",
        "            out = self.conv1(x)\r\n",
        "            \r\n",
        "        out = self.relu(out)\r\n",
        "        out = self.conv2(out)\r\n",
        "        out = self.bnrm(out)\r\n",
        "        \r\n",
        "        out += identity\r\n",
        "        out = self.relu(out)\r\n",
        "        return out\r\n",
        "        \r\n",
        "        \r\n",
        "class ResNetDecoderSymmetric(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self):\r\n",
        "        super(ResNetDecoderSymmetric, self).__init__()\r\n",
        "        \r\n",
        "        self.decoder = nn.Sequential(UPBlock(512, 512),\r\n",
        "                                    UPBlock(512, 512),\r\n",
        "                                    UPBlock(512, 256, True),\r\n",
        "                                    UPBlock(256, 256),\r\n",
        "                                    UPBlock(256, 128, True),\r\n",
        "                                    UPBlock(128, 128),\r\n",
        "                                    UPBlock(128, 64, True),\r\n",
        "                                    UPBlock(64, 64))\r\n",
        "                                    \r\n",
        "        self.output = nn.Sequential(nn.Upsample(mode='bilinear', scale_factor=2, align_corners=True),\r\n",
        "                        nn.Conv2d(64, 3, kernel_size=1, bias=False),\r\n",
        "                        nn.Tanh())                               \r\n",
        "                                    \r\n",
        "    def forward(self, x):\r\n",
        "        out = self.decoder(x)\r\n",
        "        out = self.output(out)\r\n",
        "        return out\r\n",
        "\r\n",
        "\r\n",
        "class ResNet18Autoencoder(BaseNet):\r\n",
        "\r\n",
        "    def __init__(self, rep_dim):\r\n",
        "        super().__init__()\r\n",
        "        self.encoder = ResNet18(rep_dim)\r\n",
        "        self.decoder = ResNetDecoderSymmetric()\r\n",
        "        # self.encoder2 = ResNet18(rep_dim)\r\n",
        "        \r\n",
        "    def forward(self, x):\r\n",
        "        latent1, feature = self.encoder(x)\r\n",
        "        rec_image = self.decoder(feature)\r\n",
        "        #latent2, _ = self.encoder2(rec_image)\r\n",
        "        return latent1, rec_image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9kFk7xCezr5b"
      },
      "source": [
        "\r\n",
        "# Refer to https://github.com/milesial/Pytorch-UNet/blob/master/unet/unet_parts.py\r\n",
        "class DoubleConv(nn.Module):\r\n",
        "    \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels):\r\n",
        "        super().__init__()\r\n",
        "        self.double_conv = nn.Sequential(\r\n",
        "            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),\r\n",
        "            nn.BatchNorm2d(out_channels),\r\n",
        "            nn.ReLU(inplace=True),\r\n",
        "            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),\r\n",
        "            nn.BatchNorm2d(out_channels),\r\n",
        "            nn.ReLU(inplace=True)\r\n",
        "        )\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        return self.double_conv(x)\r\n",
        "\r\n",
        "\r\n",
        "class Down(nn.Module):\r\n",
        "    \"\"\"Downscaling with maxpool then double conv\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels):\r\n",
        "        super().__init__()\r\n",
        "        self.maxpool_conv = nn.Sequential(\r\n",
        "            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),\r\n",
        "            DoubleConv(in_channels, out_channels)\r\n",
        "        )\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        return self.maxpool_conv(x)\r\n",
        "\r\n",
        "\r\n",
        "class Up(nn.Module):\r\n",
        "    \"\"\"Upscaling then double conv\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels, bilinear=True):\r\n",
        "        super().__init__()\r\n",
        "\r\n",
        "        # if bilinear, use the normal convolutions to reduce the number of channels\r\n",
        "        if bilinear:\r\n",
        "            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\r\n",
        "        else:\r\n",
        "            self.up = nn.ConvTranspose2d(in_channels // 2, in_channels // 2, kernel_size=2, stride=2)\r\n",
        "\r\n",
        "        self.conv = DoubleConv(in_channels, out_channels)\r\n",
        "\r\n",
        "    def forward(self, x1, x2):\r\n",
        "        x1 = self.up(x1)\r\n",
        "        # input is CHW\r\n",
        "        diffY = x2.size()[2] - x1.size()[2]\r\n",
        "        diffX = x2.size()[3] - x1.size()[3]\r\n",
        "\r\n",
        "        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,\r\n",
        "                        diffY // 2, diffY - diffY // 2])\r\n",
        "        # if you have padding issues, see\r\n",
        "        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a\r\n",
        "        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd\r\n",
        "        x = torch.cat([x2, x1], dim=1)\r\n",
        "        return self.conv(x)\r\n",
        "\r\n",
        "class Normalize(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self, power=2):\r\n",
        "        super(Normalize, self).__init__()\r\n",
        "        self.power = power\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        norm = x.pow(self.power).sum(1, keepdim=True).pow(1. / self.power)\r\n",
        "        out = x.div(norm)\r\n",
        "        return out\r\n",
        "\r\n",
        "class Model(nn.Module):\r\n",
        "    \"\"\" ITAE model \"\"\"\r\n",
        "\r\n",
        "    def __init__(self, n_channels=1, h_dim=756, z_dim=512, bilinear=True):\r\n",
        "        super(Model, self).__init__()\r\n",
        "        self.h_dim = h_dim\r\n",
        "        self.z_dim = z_dim\r\n",
        "        self.in_conv = DoubleConv(1, 64)\r\n",
        "        self.down1 = Down(64, 128)\r\n",
        "        self.down2 = Down(128, 256)\r\n",
        "        self.down3 = Down(256, 512)\r\n",
        "        #self.down4 = Down(512, 512)\r\n",
        "        self.flatten = nn.Flatten()\r\n",
        "        self.z = nn.Sequential(nn.Linear(131072,self.h_dim),nn.ReLU(),nn.Linear(self.h_dim,self.z_dim))\r\n",
        "        self.l2 = Normalize()\r\n",
        "        self.up1 = Up(1024, 256, bilinear)\r\n",
        "        self.up2 = Up(512, 128, bilinear)\r\n",
        "        self.up3 = Up(256, 64, bilinear)\r\n",
        "        self.up4 = Up(128, 64)\r\n",
        "        # seems that the structure in paper does not contain 'tanh'\r\n",
        "        self.out_conv = nn.Conv2d(64, n_channels, kernel_size=3, stride=1, padding=1, bias=False)# Unet use 1*1conv to be out_conv\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        x0_2 = self.in_conv(x)\r\n",
        "        x1_3 = self.down1(x0_2)\r\n",
        "        x2_3 = self.down2(x1_3)\r\n",
        "        x3_3 = self.down3(x2_3)\r\n",
        "        x_flat = self.flatten(x3_3)\r\n",
        "        z = self.z(x_flat)\r\n",
        "        l2 = self.l2(z).unsqueeze(2).unsqueeze(3)\r\n",
        "        x = self.up1(l2, x3_3)\r\n",
        "        x = self.up2(x, x2_3)\r\n",
        "        x = self.up3(x, x1_3)\r\n",
        "        x = self.up4(x, x0_2)\r\n",
        "        out = torch.tanh(self.out_conv(x))\r\n",
        "        return l2.squeeze(), out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpy37Pq-SJEt"
      },
      "source": [
        "import torch\r\n",
        "import torch.nn as nn\r\n",
        "\r\n",
        "\r\n",
        "class Double_conv(nn.Module):\r\n",
        "    \"\"\"\r\n",
        "    Apply a double convolution on the input x\r\n",
        "    args:\r\n",
        "        - ich: Number of channel of the input\r\n",
        "        - och: Number of channel of the output\r\n",
        "    \"\"\"\r\n",
        "\r\n",
        "    def __init__(self, ich, och):\r\n",
        "        super(Double_conv, self).__init__()\r\n",
        "\r\n",
        "        self.conv = nn.Sequential(nn.Conv2d(ich, och, 3, 1, 1, bias=False),\r\n",
        "                                nn.BatchNorm2d(och),\r\n",
        "                                nn.ReLU(),\r\n",
        "                                nn.Conv2d(och, och, 3, 1, 1, bias=False),\r\n",
        "                                nn.BatchNorm2d(och),\r\n",
        "                                nn.ReLU())\r\n",
        "        \"\"\"\r\n",
        "        self.conv = nn.Sequential(nn.Conv2d(ich, och, 3, 1, 1, bias=False),\r\n",
        "                                  nn.LeakyReLU(0.1),\r\n",
        "                                  nn.Conv2d(och, och, 3, 1, 1, bias=False),\r\n",
        "                                  nn.LeakyReLU(0.1))\r\n",
        "        \"\"\"\r\n",
        "                                \r\n",
        "    def forward(self, x):\r\n",
        "        x = self.conv(x)\r\n",
        "        return x\r\n",
        "        \r\n",
        "        \r\n",
        "class Down(nn.Module):\r\n",
        "\r\n",
        "    \"\"\"\r\n",
        "    Apply an encoding convolution, divides the image size by two\r\n",
        "    args:\r\n",
        "        - ich: Number of channel of the input\r\n",
        "        - och: Number of channel of the output\r\n",
        "    \"\"\"\r\n",
        "    def __init__(self, ich, och):\r\n",
        "        super(Down, self).__init__()\r\n",
        "        \r\n",
        "        self.pool = nn.MaxPool2d(2)\r\n",
        "        self.conv = Double_conv(ich, och)\r\n",
        "        \r\n",
        "    def forward(self,x):\r\n",
        "        x = self.pool(x)\r\n",
        "        x = self.conv(x)\r\n",
        "        return x\r\n",
        "        \r\n",
        "class Up(nn.Module):\r\n",
        "\r\n",
        "    \"\"\"\r\n",
        "    Apply a decoding deconvolution, multiplies the image size by two\r\n",
        "    args:\r\n",
        "        - ich: Number of channel of the input\r\n",
        "        - och: Number of channel of the output\r\n",
        "    \"\"\"\r\n",
        "    def __init__(self, ich, och):\r\n",
        "        super(Up, self).__init__()\r\n",
        "        self.up = nn.Sequential(nn.Upsample(mode='bilinear', scale_factor=2, align_corners=True),\r\n",
        "                                nn.Conv2d(ich, ich // 2, kernel_size=1, bias=False),\r\n",
        "                                nn.BatchNorm2d(ich // 2))\r\n",
        "        \"\"\"\r\n",
        "        self.up = nn.Sequential(nn.Upsample(mode='bilinear', scale_factor=2, align_corners=True),\r\n",
        "                                nn.Conv2d(ich, ich // 2, kernel_size=1, bias=False))\r\n",
        "        \"\"\"\r\n",
        "        #self.conv = Double_conv(och + ich // 2, och)\r\n",
        "        self.conv = Double_conv(ich // 2, och)\r\n",
        "        \r\n",
        "    def forward(self, enc_layer, dec_layer):\r\n",
        "        dec = self.up(dec_layer)\r\n",
        "        #x = torch.cat([enc_layer, dec], dim=1)\r\n",
        "        #x = self.conv(x)\r\n",
        "        x = self.conv(dec)\r\n",
        "        return x        \r\n",
        "\r\n",
        "class Normalize(nn.Module):\r\n",
        "\r\n",
        "    def __init__(self, power=2):\r\n",
        "        super(Normalize, self).__init__()\r\n",
        "        self.power = power\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        norm = x.pow(self.power).sum(1, keepdim=True).pow(1. / self.power)\r\n",
        "        out = x.div(norm)\r\n",
        "        return out\r\n",
        "\r\n",
        "class UNET(nn.Module):\r\n",
        "\r\n",
        "    \"\"\"\r\n",
        "    Implements a unet network with convolutional encoding and deconvolutional decoding.\r\n",
        "    The forward method implements skip connections between encoder and decoder to keep consistency in the features\r\n",
        "    arg:\r\n",
        "        n_classes: The number of channel output\r\n",
        "    \"\"\"\r\n",
        "    def __init__(self, rep_dim, inp_channel, out_channel):\r\n",
        "        super(UNET, self).__init__()\r\n",
        "\r\n",
        "        self.input = Double_conv(inp_channel, 32)\r\n",
        "        self.e1 = Down(32, 64)\r\n",
        "        self.e2 = Down(64, 128)\r\n",
        "        self.e3 = Down(128, 256)\r\n",
        "        self.e4 = Down(256, 512)\r\n",
        "        self.e5 = Down(512, 1024)\r\n",
        "        self.feat = nn.Conv2d(1024, rep_dim, 8, bias=False)\r\n",
        "        self.l2norm = Normalize()\r\n",
        "\r\n",
        "        self.defeat = nn.ConvTranspose2d(rep_dim, 1024, 8, bias=False)\r\n",
        "        self.d2 = Up(1024, 512)\r\n",
        "        self.d3 = Up(512, 256)\r\n",
        "        self.d4 = Up(256, 128)\r\n",
        "        self.d5 = Up(128, 64)\r\n",
        "        self.d6 = Up(64, 32)\r\n",
        "        \r\n",
        "        self.final = nn.Conv2d(32, out_channel, 1, 1, 0, bias=False)\r\n",
        "        self.activation = nn.ReLU()\r\n",
        "        \r\n",
        "    def forward(self, x):\r\n",
        "        e1 = self.input(x)\r\n",
        "        e2 = self.e1(e1)\r\n",
        "        e3 = self.e2(e2)\r\n",
        "        e4 = self.e3(e3)\r\n",
        "        e5 = self.e4(e4)\r\n",
        "        e6 = self.e5(e5)\r\n",
        "        feature = self.l2norm(self.feat(e6))\r\n",
        "        defeature = self.defeat(feature)\r\n",
        "        x = self.d2(e5, defeature)\r\n",
        "        x = self.d3(e4, x)\r\n",
        "        x = self.d4(e3, x)\r\n",
        "        x = self.d5(e2, x)\r\n",
        "        x = self.d6(e1, x)\r\n",
        "        x = self.final(x)\r\n",
        "        x = self.activation(x)\r\n",
        "        \r\n",
        "        return feature.squeeze(), x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Bn8lCFTSZ5k"
      },
      "source": [
        "#model = Model(1,1024,128,True).to('cuda')\r\n",
        "#model = UNET(256,1,1).to('cuda')\r\n",
        "model = ResNet18Autoencoder(256).to('cuda')\r\n",
        "#model = UNet(1,1,512,False).to('cuda')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DQsYyKsuStSb"
      },
      "source": [
        "from torchsummary import summary\r\n",
        "import torch.nn.functional as F\r\n",
        "summary(model, (3,256,256), 2, 'cuda')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jbQw8gHGx1D6"
      },
      "source": [
        "def plotCurves(stats):\r\n",
        "    for c in ['train_loss','test_loss']:\r\n",
        "        try:plt.plot(stats[c], label=c)\r\n",
        "        except: pass\r\n",
        "    plt.legend()\r\n",
        "    plt.xlabel('Epochs')\r\n",
        "    plt.ylabel('Error')\r\n",
        "    plt.title('Training Loss Curve')\r\n",
        "    plt.show()\r\n",
        "    try:\r\n",
        "      for c in ['AUC score','AP score']:\r\n",
        "        plt.plot(stats[c], label=c)\r\n",
        "      plt.legend()\r\n",
        "      plt.xlabel('Epochs')\r\n",
        "      plt.ylabel('AUC')\r\n",
        "      plt.title('AUC Curve')\r\n",
        "      plt.show()\r\n",
        "    except: pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AY3bLhUw3EU6"
      },
      "source": [
        "import torch.nn.functional as F"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdZ912IzfoRP"
      },
      "source": [
        "import logging\r\n",
        "import time\r\n",
        "import torch\r\n",
        "import torch.optim as optim\r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        "from tqdm import tqdm\r\n",
        "\r\n",
        "class Solver():\r\n",
        "\r\n",
        "    def __init__(self, tr_dataset, te_dataset, network, k : int, lr: float, n_epochs: int, rep_dim:int,\r\n",
        "                 weight_decay: float, device: str, w_rec : float):\r\n",
        "\r\n",
        "        self.model = network.to(device)\r\n",
        "        self.trainloader = tr_dataset\r\n",
        "        self.testloader = te_dataset\r\n",
        "        self.n_epochs = n_epochs\r\n",
        "        self.optimizer = optim.Adam(self.model.parameters(), lr=lr)\r\n",
        "        self.rec_loss = torch.nn.L1Loss()\r\n",
        "        self.feat_loss = torch.nn.MSELoss()\r\n",
        "        self.best_score = 0\r\n",
        "        self.w_rec = 0.5\r\n",
        "        self.min_loss = 0.003\r\n",
        "        self.k = k\r\n",
        "        self.device=device\r\n",
        "        self.logger = logging.getLogger()\r\n",
        "        self.memory = torch.randn(size=(len(self.trainloader.dataset), rep_dim)).to(self.device)\r\n",
        "\r\n",
        "    def train(self, load=False):\r\n",
        "        stats = []\r\n",
        "        print('Started Training..\\n')\r\n",
        "        if load: \r\n",
        "          print('Loading model....')\r\n",
        "          self.model.load_state_dict(torch.load('./drive/MyDrive/model.tar'))\r\n",
        "        for e in range(1, self.n_epochs+1):\r\n",
        "            loss = 0\r\n",
        "            latent = torch.randn(size=(len(self.trainloader.dataset), 512)).to(self.device)\r\n",
        "            self.model.train()\r\n",
        "            for i, (img, _, indexes) in enumerate(self.trainloader):\r\n",
        "                inp =  img.clone().type(torch.float)\r\n",
        "                inputs = inp.to(self.device)\r\n",
        "                self.optimizer.zero_grad()\r\n",
        "\r\n",
        "                latent1, rec_images = self.model(inputs)\r\n",
        "                rec_loss = self.w_rec*self.rec_loss(inputs, rec_images)\r\n",
        "                rec_loss.backward()\r\n",
        "\r\n",
        "                loss += rec_loss.item()*inputs.shape[0]\r\n",
        "                self.optimizer.step()\r\n",
        "\r\n",
        "                self.memory[indexes] = latent1\r\n",
        "                if i  == 449:\r\n",
        "                    show_databatch(inputs.detach().cpu())\r\n",
        "                    show_databatch(rec_images.detach().cpu())\r\n",
        "\r\n",
        "            t_loss = loss/len(self.trainloader.dataset)\r\n",
        "            \r\n",
        "            if e > 10:\r\n",
        "              score, ap_score, test_loss = self.test()\r\n",
        "              stats.append([t_loss, test_loss, score, ap_score])\r\n",
        "              stat = pd.DataFrame(stats, columns=['train_loss', 'test_loss', 'AUC score', 'AP score'])\r\n",
        "              if ap_score > 0.50: \r\n",
        "                torch.save({'state_dict' : self.model.state_dict()}, 'state_dict.pt')\r\n",
        "                #torch.save(self.model, 'model.pt')\r\n",
        "              if test_loss < self.min_loss:\r\n",
        "                  self.min_loss = test_loss\r\n",
        "                  torch.save({'state_dict' : self.model.state_dict()}, './drive/MyDrive/model.tar')\r\n",
        "              print(\"Epoch %d/%d : Train Loss = %f | Test Loss = %f | AUC = %.4f | AP = %.4f \" % (e, self.n_epochs, t_loss, test_loss, score, ap_score))\r\n",
        "            else:\r\n",
        "              stats.append([t_loss])\r\n",
        "              stat = pd.DataFrame(stats, columns=['train_loss'])\r\n",
        "              print(\"Epoch %d/%d : Train Loss = %f | \" % (e, self.n_epochs, t_loss))          \r\n",
        "            if e % 10 == 0: plotCurves(stat)\r\n",
        "\r\n",
        "\r\n",
        "    def test(self, load=False, load_memory=False):\r\n",
        "\r\n",
        "        idx_label_score = []\r\n",
        "        self.model.eval()\r\n",
        "        if load: self.model.load_state_dict(torch.load('model.pt'))\r\n",
        "        with torch.no_grad():\r\n",
        "            if load_memory:\r\n",
        "                for i, (img, _, indexes) in enumerate(self.trainloader):\r\n",
        "                    inp =  img.clone().type(torch.float)\r\n",
        "                    inputs = inp.to(self.device)\r\n",
        "                    latent1, rec_images = self.model(inputs)\r\n",
        "\r\n",
        "                    self.memory[indexes] = latent1\r\n",
        "\r\n",
        "            loss = 0\r\n",
        "            trainfeatures = self.memory.t()\r\n",
        "            for i, data in enumerate(self.testloader):\r\n",
        "                imgs, labels, _ = data\r\n",
        "                inputs =  imgs.clone().type(torch.float).to(self.device)\r\n",
        "                latent1, rec_images = self.model(inputs)\r\n",
        "\r\n",
        "                dist = torch.acos(torch.mm(latent1, trainfeatures)) / math.pi\r\n",
        "\r\n",
        "                scores, _ = dist.topk(self.k, dim=1, largest=False, sorted=True)\r\n",
        "                scores = torch.mean(scores, dim=1)\r\n",
        "                loss += self.rec_loss(inputs, rec_images).item()*inputs.shape[0]\r\n",
        "\r\n",
        "                # Save tuple of (label, score) in a list\r\n",
        "                idx_label_score += list(zip(\r\n",
        "                                            labels.cpu().data.numpy().tolist(),\r\n",
        "                                            scores.cpu().data.numpy().tolist()))\r\n",
        "        print(scores.max(), scores.min())\r\n",
        "        self.test_scores = idx_label_score\r\n",
        "        test_loss = loss / len(self.testloader.dataset)\r\n",
        "        # Compute AUC\r\n",
        "        labels, scores = zip(*idx_label_score)\r\n",
        "        scores = (scores - np.min(scores)) / (np.max(scores) - np.min(scores))\r\n",
        "        labels = np.array(labels)\r\n",
        "        scores = np.array(scores)\r\n",
        "        return roc_auc_score(labels, scores), average_precision_score(labels, scores), test_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "heH82ZH2d0y2"
      },
      "source": [
        "t = Solver(trainloader, valloader, model, 100, 1e-3, 500, 256, 0.5, 'cuda', 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvAD_D2qfMSJ"
      },
      "source": [
        "t.train()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 443
        },
        "id": "5fSU-FFAb1wq",
        "outputId": "e4d1d0f3-ac76-47f1-dde3-85ef47cd6db5"
      },
      "source": [
        "# run t-SNE\r\n",
        "from sklearn.manifold import TSNE\r\n",
        "# perplexity parameter can be changed based on the input datatset\r\n",
        "# dataset with larger number of variables requires larger perplexity\r\n",
        "# set this value between 5 and 50 (sklearn documentation)\r\n",
        "# verbose=1 displays run time messages\r\n",
        "# set n_iter sufficiently high to resolve the well stabilized cluster\r\n",
        "# get embeddings\r\n",
        "tsne_em = TSNE(n_components=2, perplexity=30.0, n_iter=5000, verbose=1).fit_transform(t.memory.detach().cpu().numpy())\r\n",
        "\r\n",
        "from mpl_toolkits.mplot3d import Axes3D\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "\r\n",
        "fig = plt.figure()\r\n",
        "ax = fig.add_subplot(111, projection='3d')\r\n",
        "plt.figure(figsize=(12,12))\r\n",
        "ax.scatter(*zip(*tsne_em))\r\n",
        "plt.show()\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[t-SNE] Computing 91 nearest neighbors...\n",
            "[t-SNE] Indexed 3601 samples in 0.090s...\n",
            "[t-SNE] Computed neighbors for 3601 samples in 4.621s...\n",
            "[t-SNE] Computed conditional probabilities for sample 1000 / 3601\n",
            "[t-SNE] Computed conditional probabilities for sample 2000 / 3601\n",
            "[t-SNE] Computed conditional probabilities for sample 3000 / 3601\n",
            "[t-SNE] Computed conditional probabilities for sample 3601 / 3601\n",
            "[t-SNE] Mean sigma: 0.084255\n",
            "[t-SNE] KL divergence after 250 iterations with early exaggeration: 76.407837\n",
            "[t-SNE] KL divergence after 5000 iterations: 1.544995\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x864 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FP0ksLCviP-S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b264febe-deb4-4a59-ec90-48b13f30f7cb"
      },
      "source": [
        "# plot t-SNE clusters\r\n",
        "from bioinfokit.visuz import cluster\r\n",
        "color_class = ['0']\r\n",
        "cluster.tsneplot(score=tsne_em, colordot=('#713e5a'), \r\n",
        "    legendpos='upper right', legendanchor=(1.15, 1) )\r\n",
        "# plot will be saved in same directory (tsne_2d.png) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "NtZinF_Wb6vz",
        "outputId": "a8d3e372-2937-4933-87bc-d0c62e455e88"
      },
      "source": [
        "import cv2\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "im = cv2.imread('tsne_2d.png')\r\n",
        "plt.imshow(im)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f75600b1d30>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lORtHrk7b6sH"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}