SiameseCNN_Spiculation_Classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "SiameseCNN_Spiculation_Classifier.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "sZ9p1tkD2QqD",
        "jXyUL3AB05lK",
        "QPStKL1I-d_j",
        "36kdgo-qTBNv",
        "xM-cE2oBQABh",
        "adJ-5nlcVb0y",
        "hmxje11QHuiA",
        "MAKmMuyfgsNO",
        "gh5fXsTPXXsc"
      ],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sZ9p1tkD2QqD"
      },
      "source": [
        "## Import Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xvLh8fC2fnmW"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import cv2\n",
        "import os\n",
        "import pickle\n",
        "from glob import glob\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "import datetime\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch import optim\n",
        "from torch.utils.data import Dataset\n",
        "from torchvision.transforms import ToTensor\n",
        "from torch.utils.data import DataLoader, random_split\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "\n",
        "# !pip install cloud-tpu-client==0.10 https://storage.googleapis.com/tpu-pytorch/wheels/torch_xla-1.9-cp37-cp37m-linux_x86_64.whl\n",
        "# import torch_xla\n",
        "# import torch_xla.core.xla_model as xm\n",
        "\n",
        "!pip install torchviz\n",
        "from torchviz import make_dot"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBU5EOplwJY_"
      },
      "source": [
        "## Preprocessing\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXyUL3AB05lK"
      },
      "source": [
        "### Extract Labels and Binning Them\n",
        "\n",
        "We only need the InstanceID (nodule id) and the Spiculation rating (label)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KUe6e6SywWsV"
      },
      "source": [
        "if os.path.isfile(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','dataset.pickle')):\n",
        "  df = pd.read_excel('/content/drive/MyDrive/Colab Notebooks/Research/parsedXMLnew.xlsx')\n",
        "  df = df[['InstanceID', 'spiculation']]\n",
        "  df.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RDaYqfHSh2F"
      },
      "source": [
        "Load the images and match their corresponding labels."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JHYTCYzOPZfp"
      },
      "source": [
        "ds = []\n",
        "if os.path.isfile(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','dataset.pickle')):\n",
        "  with open(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','dataset.pickle'), 'rb') as f:\n",
        "    ds = pickle.load(f)\n",
        "else:\n",
        "  !tar xzf '/content/drive/MyDrive/Colab Notebooks/Research/LIDC/nodules.tar.gz'\n",
        "\n",
        "  file_names = glob(os.path.join('/content/nodules','*.png'))\n",
        "  id_set = set(df['InstanceID'])\n",
        "  for f in file_names:\n",
        "    id = int(f.split('/')[-1].split('.')[0])\n",
        "    # print('InstanceID:', id, end='\\n\\n')\n",
        "    if id in id_set:\n",
        "      label =  df[df['InstanceID']==id]['spiculation'].iloc[0]\n",
        "      img = cv2.imread(f, 0)\n",
        "      ds.append([img.astype(np.float32), label, id])\n",
        "\n",
        "  with open(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','dataset.pickle'), 'wb') as f:\n",
        "    pickle.dump(ds, f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uFcKC8CfT6OR"
      },
      "source": [
        "fig = plt.figure(figsize=(10,5))\n",
        "plt.title('Total Number of Images in Each Category')\n",
        "labels, counts = np.unique([d[1] for d in ds], return_counts='True')\n",
        "bars = plt.bar(labels, counts, align='center')\n",
        "plt.gca().set_xticks(labels)\n",
        "plt.ylabel('Frequency')\n",
        "plt.xlabel('Spiculation Rating')\n",
        "for bar in bars:\n",
        "  yval = bar.get_height()\n",
        "  plt.text(bar.get_x()+0.3, yval + 200, yval)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPStKL1I-d_j"
      },
      "source": [
        "### Scaling Images\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "geth426IZAub"
      },
      "source": [
        "temp = []\n",
        "input_size = (64,64,1)\n",
        "min_size = (12,12)\n",
        "\n",
        "for d in ds:\n",
        "  if d[0].shape >= min_size:\n",
        "    if d[0].shape < input_size[:2]:\n",
        "      # Up-Scaling\n",
        "      d[0] = cv2.resize(d[0], dsize=input_size[:2], interpolation=cv2.INTER_CUBIC)\n",
        "    elif d[0].shape > input_size:\n",
        "      # Down-Scaling\n",
        "      d[0] = cv2.resize(d[0], dsize=input_size[:2], interpolation=cv2.INTER_AREA)\n",
        "    temp.append(d)\n",
        "\n",
        "del(ds)\n",
        "ds = temp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zz3is6ij9Idj"
      },
      "source": [
        "fig = plt.figure(figsize=(10,5))\n",
        "plt.title(f'Total Number of Images Greater than {min_size} in size')\n",
        "labels, counts = np.unique([d[1] for d in ds], return_counts='True')\n",
        "bars = plt.bar(labels, counts, align='center')\n",
        "plt.gca().set_xticks(labels)\n",
        "plt.ylabel('Frequency')\n",
        "plt.xlabel('Spiculation Rating')\n",
        "for bar in bars:\n",
        "  yval = bar.get_height()\n",
        "  plt.text(bar.get_x()+0.3, yval + 10, yval)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sMCc8wyDSvAM"
      },
      "source": [
        "images, labels, nodule_ids = [], [], []\n",
        "for d in ds:\n",
        "  images.append(d[0])\n",
        "  labels.append(d[1])\n",
        "  nodule_ids.append(d[2])\n",
        "images = np.array(images)\n",
        "labels = np.array(labels)\n",
        "nodule_ids = np.array(nodule_ids)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36kdgo-qTBNv"
      },
      "source": [
        "### Create Lung Nodule Dataset Class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rbXMPlgeSsSF"
      },
      "source": [
        "class ToTensor(object):\n",
        "    \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n",
        "\n",
        "    def __call__(self, sample):\n",
        "      return torch.from_numpy(sample)   \n",
        "class LungNoduleDataset(Dataset):\n",
        "  \"\"\" Required Methods \"\"\"\n",
        "  def __init__(self, images, labels, nodule_ids, transform):\n",
        "    self.labels = labels\n",
        "    self.images = images\n",
        "    self.nodule_ids = nodule_ids\n",
        "    self.transform = transform\n",
        "\n",
        "    self.rand_samp = False\n",
        "  def __len__(self):\n",
        "    return len(self.labels)\n",
        "  def __getitem__(self, idx):\n",
        "    return self.transform(self.images[idx]), self.labels[idx]\n",
        "\n",
        "  \"\"\" Custom Methods \"\"\"\n",
        "  def get_image_from_id(self, id):\n",
        "    \"\"\" Returns image and label using Nodule ID \"\"\"\n",
        "    idx = np.where(self.nodule_ids == id)[0][0]\n",
        "    return self.__getitem__(idx)\n",
        "\n",
        "  def split_to_classes(self):\n",
        "    \"\"\" Organizes data into respective classes \"\"\"\n",
        "    if os.path.isfile(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','classes.pickle')):\n",
        "      with open(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','classes.pickle'), 'rb') as f:\n",
        "        self.classes = pickle.load(f)\n",
        "    else:\n",
        "      self.classes = {1: [], 2: [], 3: [], 4: [], 5: []}\n",
        "      for image,label,id in zip(self.images, self.labels, self.nodule_ids):\n",
        "        self.classes[label].append((image, id))\n",
        "      with open(os.path.join('/content/drive/MyDrive/Colab Notebooks/Siamese Network/Datasets','classes.pickle'), 'wb') as f:\n",
        "          pickle.dump(self.classes, f)\n",
        "\n",
        "  def bin_classes(self):\n",
        "    \"\"\" Balance and bin classes by randomly sampling from each class \n",
        "        until the minimum size is met for each class. \"\"\"\n",
        "    self.bins = {1: [], 2: [], 3: [], 4: [], 5: []}\n",
        "    self.min_bin_size = 50\n",
        "    for k in self.classes.keys():\n",
        "      used = set()\n",
        "      while len(self.bins[k]) != self.min_bin_size:\n",
        "        idx = np.random.randint(low=0, high=len(self.classes[k]))\n",
        "        if idx not in used:\n",
        "          self.bins[k].append((self.classes[k])[idx])\n",
        "          used.add(idx)\n",
        "\n",
        "  def random_sampling(self):\n",
        "    self.split_to_classes()\n",
        "    self.bin_classes()\n",
        "    self.rand_samp = True\n",
        "\n",
        "  def get_bins(self):\n",
        "    if self.rand_samp:\n",
        "      return self.bins\n",
        "    else:\n",
        "      print('Have not randomly sample classes. Need to run random_sampling() method.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PsJ2mcUlXkxh"
      },
      "source": [
        "ds = LungNoduleDataset(images, labels, nodule_ids, ToTensor())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e3PZnD103I4F"
      },
      "source": [
        "plt.imshow(ds[100][0],cmap='gray')\n",
        "plt.title(f'Spiculation Label: {ds[100][1]}, nodule: {nodule_ids[100]}')\n",
        "plt.axis('off')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xM-cE2oBQABh"
      },
      "source": [
        "### Random Sampling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wl2psCl_brP-"
      },
      "source": [
        "ds.random_sampling()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ai0qZXiLKsK0"
      },
      "source": [
        "counts = [len(b) for b in ds.get_bins().values()]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5UxRkJKBS8Dd"
      },
      "source": [
        "fig = plt.figure(figsize=(10,5))\n",
        "plt.title(f'Balanced Bins')\n",
        "# labels, counts = np.unique([len(b) for b in ds.get_bins().values()], return_counts='True')\n",
        "bars = plt.bar(range(1,6), counts, align='center')\n",
        "plt.gca().set_xticks(range(1,6))\n",
        "plt.ylabel('Frequency')\n",
        "plt.xlabel('Spiculation Rating')\n",
        "for bar in bars:\n",
        "  yval = bar.get_height()\n",
        "  plt.text(bar.get_x()+0.3, yval + .5, yval)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M-hnrpTuEaql"
      },
      "source": [
        "### Pair Images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RrROlzDK0w_u"
      },
      "source": [
        "class Pairs(Dataset):\n",
        "  \"\"\" Required Methods \"\"\"\n",
        "  def __init__(self, bins, transform):\n",
        "    \"\"\" Pair images by spiculation rating \"\"\"\n",
        "    self.labels = []\n",
        "    self.pairs = []\n",
        "    self.transform = transform\n",
        "\n",
        "    labels = []\n",
        "    samples = []\n",
        "    for label, bin in bins.items():\n",
        "      for sample in bin:\n",
        "        samples.append(sample)\n",
        "        labels.append(label)\n",
        "\n",
        "    used = set()\n",
        "    for sample_a,label_a in zip(samples, labels):\n",
        "      for sample_b,label_b in zip(samples, labels):\n",
        "        if label_a == label_b:\n",
        "          \"\"\" positive pair \"\"\"\n",
        "          self.pairs.append(np.array([sample_a[0], sample_b[0]]))\n",
        "          self.labels.append(1)\n",
        "        else:\n",
        "          \"\"\" negative pair \"\"\"\n",
        "          tup = tuple(sorted((sample_a[1], sample_b[1])))\n",
        "          if tup not in used:\n",
        "            self.pairs.append(np.array([sample_a[0], sample_b[0]]))\n",
        "            self.labels.append(0)\n",
        "            used.add(tup)\n",
        "\n",
        "\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.labels)\n",
        "  def __getitem__(self, idx):\n",
        "    pair = self.transform(self.pairs[idx])\n",
        "    return pair[0][None,...], pair[1][None,...], self.labels[idx]\n",
        "\n",
        "  \"\"\" Custom Methods \"\"\"\n",
        "  def get_labels_and_counts(self):\n",
        "    return np.unique(self.labels, return_counts='True')     "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xMWleYaZEaKH"
      },
      "source": [
        "pairs = Pairs(ds.get_bins(), ToTensor())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6IZ1XD6BkWrd"
      },
      "source": [
        "tp = [(1,2), (2,1)]\n",
        "s = set()\n",
        "for t in tp:\n",
        "  print(t)\n",
        "  s.add(tuple(sorted(t)))\n",
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B5YeY6XzoZBQ"
      },
      "source": [
        "afig = plt.figure(figsize=(10,5))\n",
        "plt.title(f'Total Number of Pairs')\n",
        "labels, counts = pairs.get_labels_and_counts()\n",
        "bars = plt.bar(labels, counts, align='center')\n",
        "plt.gca().set_xticks(labels)\n",
        "plt.ylabel('Frequency')\n",
        "plt.xlabel('Label')\n",
        "for bar in bars:\n",
        "  yval = bar.get_height()\n",
        "  plt.text(bar.get_x()+0.3, yval + 10, yval)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MAKmMuyfgsNO"
      },
      "source": [
        "## SCNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8lUVP_eegu-a"
      },
      "source": [
        "class SCNN(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(SCNN, self).__init__()\n",
        "    self.cnnl = nn.Sequential (\n",
        "        # First Conv Pool \n",
        "        nn.Conv2d(1, 32, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(32, 32, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(2, 2),\n",
        "        # Second Conv Pool\n",
        "        nn.Conv2d(32, 64, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(64, 64, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(2, 2),\n",
        "        # Second Conv Pool\n",
        "        nn.Conv2d(64, 128, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(128, 128, 3, padding='same'),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(2, 2),\n",
        "    )\n",
        "\n",
        "    self.fcl = nn.Sequential(\n",
        "        # Dense Layers\n",
        "        nn.Linear(8 * 8 * 64, 512),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(p=0.5),\n",
        "        nn.Linear(512, 256),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(p=0.5),\n",
        "        nn.Linear(256,128),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(p=0.5),\n",
        "        nn.Linear(128, 5),\n",
        "        # nn.Sigmoid(),\n",
        "        nn.Softmax(),\n",
        "    ) \n",
        "  def forward_once(self, x):\n",
        "    x = self.cnnl(x)\n",
        "    x = x.view(-1,8 * 8 * 64)\n",
        "    output = self.fcl(x)\n",
        "    return output\n",
        "\n",
        "  def forward(self, input_a, input_b):\n",
        "    output1 = self.forward_once(input_a)\n",
        "    output2 = self.forward_once(input_b)\n",
        "    return output1, output2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BgWDxT0I28kX"
      },
      "source": [
        "\"\"\" Loss Functions \"\"\"\n",
        "class ContrastiveLoss(nn.Module):\n",
        "  def __init__(self, margin=2.0):\n",
        "    super(ContrastiveLoss, self).__init__()\n",
        "    self.margin = margin\n",
        "\n",
        "  def forward(self, output1, output2, label):\n",
        "    euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True)\n",
        "    loss = torch.mean((1-label) * torch.pow(euclidean_distance, 2) + (label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2))\n",
        "    return loss\n",
        "class QuadrupletLoss(torch.nn.Module):\n",
        "  def __init__(self, margin_1=2.0, margin_2=1.0):\n",
        "    super(QuadrupletLoss, self).__init__()\n",
        "    self.margin_1 = margin_1\n",
        "    self.margin_2 = margin_2\n",
        "\n",
        "  def forward(self, anchor, positive, negative_1, negative_2):\n",
        "    euclidean_distance_pos = F.pairwise_distance(anchor, positive, keepdim=True)\n",
        "    euclidean_distance_neg = F.pairwise_distance(anchor, negative_1, keepdim=True)\n",
        "    euclidean_distance_neg_b = F.pairwise_distance(negative_1, negative_2, keepdim=True)\n",
        "\n",
        "    quadruplet_loss = \\\n",
        "        F.relu(self.margin_1 + euclidean_distance_pos - euclidean_distance_neg) \\\n",
        "        + F.relu(self.margin_2 + euclidean_distance_pos - euclidean_distance_neg_b)\n",
        "\n",
        "    return quadruplet_loss.mean()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gh5fXsTPXXsc"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "adJ-5nlcVb0y"
      },
      "source": [
        "### Split Dataset into Training, Validation, and Test Sets\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYcO3WhaMiuk"
      },
      "source": [
        "\"\"\" Split Pairs Dataset Into Training, Validation, and Testing Sets \"\"\"\n",
        "train_test_split = .2\n",
        "ds_size = len(pairs)\n",
        "\n",
        "test_size = int(np.floor(train_test_split * ds_size))\n",
        "\n",
        "train_val_split = .2\n",
        "train_size = ds_size - test_size\n",
        "\n",
        "val_size = int(np.floor(train_test_split * train_size))\n",
        "\n",
        "train_size = ds_size - test_size - val_size"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uhLIGFUlDRgk"
      },
      "source": [
        "seed = torch.Generator()\n",
        "seed.manual_seed(1)\n",
        "training_data, val_data, test_data = random_split(pairs, [train_size, val_size, test_size], seed)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i_wXQgEWAxEH"
      },
      "source": [
        "model = SCNN().cuda()\n",
        "criterion = ContrastiveLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.0001)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hmxje11QHuiA"
      },
      "source": [
        "### Dataloaders"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EkiRLJ9rG_ge"
      },
      "source": [
        "train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)\n",
        "val_dataloader = DataLoader(val_data, batch_size=64, shuffle=True)\n",
        "test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FIAOP6YfZmg5"
      },
      "source": [
        "a, b, l = next(iter(train_dataloader))\n",
        "a, b, l = a[0, None,...].cuda(), b[0,None,...].cuda(), l[0].cuda()\n",
        "print(a.size(),b.size())\n",
        "make_dot(model(a,b), params=dict(list(model.named_parameters()))).render(\"SCNN_torchviz\", format=\"png\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aAz5EchxYlDO"
      },
      "source": [
        "def show_plot(epochs,loss):\n",
        "  fig, ax1 = plt.subplots(1,1, figsize=(12,12))\n",
        "    \n",
        "  ax1.plot(range(epochs), loss['training'], 'tab:blue')\n",
        "  ax1.plot(range(epochs), loss['validation'], 'tab:orange')\n",
        "  ax1.set_title('Training Loss')\n",
        "  ax1.set_xlabel('Epochs')\n",
        "  ax1.set_ylabel('Loss')\n",
        "  ax1.set_yticks(np.arange(0,1.1,.1))\n",
        "\n",
        "  # ax2.plot(range(epochs), loss['validation'])\n",
        "  # ax2.set_title('Validation Loss')\n",
        "  # ax2.set_xlabel('Epochs')\n",
        "  # ax2.set_ylabel('Loss')\n",
        "  # ax2.set_yticks(np.arange(0,1.1,.1))\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NcxKryH8Xbiu"
      },
      "source": [
        "loss_history = {'training': [], 'validation': []}\n",
        "iteration_number= 0\n",
        "epochs = 100\n",
        "min_valid_loss = np.inf\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  train_loss = 0.0\n",
        "  for data in train_dataloader:\n",
        "    # Grab images and label. Send them to GPU\n",
        "    img_a, img_b, label = data\n",
        "    img_a, img_b, label = img_a.cuda(), img_b.cuda(), label.cuda()\n",
        "\n",
        "    # Clear the gradients\n",
        "    optimizer.zero_grad()\n",
        "    # Forward Pass the Images\n",
        "    output_a, output_b = model(img_a,img_b)\n",
        "    # Find the Loss\n",
        "    loss = criterion(output_a, output_b, label)\n",
        "    # Backprop\n",
        "    loss.backward()\n",
        "    # Update weights\n",
        "    optimizer.step()\n",
        "    # Calculate Loss\n",
        "    train_loss = loss.item() * data[0].size(0)\n",
        "  loss_history['training'].append(train_loss / len(train_dataloader))\n",
        "\n",
        "  val_loss = 0.0\n",
        "  model.eval()\n",
        "  for data in val_dataloader:\n",
        "    # Grab images and label. Send them to GPU\n",
        "    img_a, img_b, label = data\n",
        "    img_a, img_b, label = img_a.cuda(), img_b.cuda(), label.cuda()\n",
        "\n",
        "    # Forward Pass the Images\n",
        "    output_a, output_b = model(img_a,img_b)\n",
        "    # Find the Loss\n",
        "    loss = criterion(output_a, output_b, label)\n",
        "    # Calculate Loss\n",
        "    valid_loss = loss.item() * data[0].size(0)\n",
        "  loss_history['validation'].append(valid_loss / len(val_dataloader))\n",
        "\n",
        "  show_plot(epoch+1,loss_history)\n",
        "  print(f'Epoch {epoch+1} \\t\\t Training Loss: {train_loss / len(train_dataloader)} \\t\\t Validation Loss: {valid_loss / len(val_dataloader)}')\n",
        "\n",
        "  if min_valid_loss > valid_loss:\n",
        "      print(f'Validation Loss Decreased({min_valid_loss:.6f}--->{valid_loss:.6f}) \\t Saving The Model')\n",
        "      min_valid_loss = valid_loss\n",
        "        \n",
        "      # Saving State Dict\n",
        "      torch.save(model.state_dict(), 'saved_model.pth')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3xa6jCTIQX_"
      },
      "source": [
        "## Testing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EAo1ltwC0W5n"
      },
      "source": [
        "model.eval()\n",
        "for data in test_dataloader:\n",
        "  # Grab images and label. Send them to GPU\n",
        "  img_a, img_b, label = data\n",
        "  img_a, img_b, label = img_a.cuda(), img_b.cuda(), label.cuda()\n",
        "  if img_a.size(0) == 12:\n",
        "    output_a, output_b = model(img_a, img_b)\n",
        "    print(output_a.size(), output_b.size(), label.size())\n",
        "    test_loss = criterion(img_a, img_b, label) \n",
        "# print('test loss is {}'.format(test_loss))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PBmcOEb5V44v"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}