Siamese_data_balanced.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "lPAu45JujmVq",
    "outputId": "b3a9fa61-b25f-49bf-a31f-38c963da67c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount(\"/content/drive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "6EMELZ15jyyW"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pickle\n",
    "import torchvision\n",
    "import torchvision.datasets as dset\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader,Dataset\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision.utils\n",
    "import numpy as np\n",
    "import random\n",
    "from PIL import Image\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import PIL.ImageOps    \n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Lt4Nh2YQj7yG",
    "outputId": "46f53448-fa6f-4d6a-8376-8c32668b06bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/drive\n"
     ]
    }
   ],
   "source": [
    "%cd drive/My\\ Drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cd SiameseNets-experiments/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "Axq_bIM1s7qR"
   },
   "outputs": [],
   "source": [
    "def imshow(img,text=None,should_save=False):\n",
    "    npimg = img.numpy()\n",
    "    plt.axis(\"off\")\n",
    "    if text:\n",
    "        plt.text(75, 8, text, style='italic',fontweight='bold',\n",
    "            bbox={'facecolor':'white', 'alpha':0.8, 'pad':10})\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()    \n",
    "\n",
    "def show_plot(iteration,loss):\n",
    "    plt.plot(iteration,loss)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "KeBmtXn4tDlJ"
   },
   "outputs": [],
   "source": [
    "class Config():\n",
    "    training_dir = \"./data/rg-balanced/train/\"\n",
    "    testing_dir = \"./data/rg-balanced/val/\"\n",
    "    custom_testing_dir = \"./data/rg-balanced/custom_testing/test\"\n",
    "    custom_labeled_dir = \"./data/rg-balanced/custom_testing/labeled\"\n",
    "    train_batch_size = 64\n",
    "    train_number_epochs = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "0PsfA_6UtF43"
   },
   "outputs": [],
   "source": [
    "class SiameseNetworkDataset(Dataset):\n",
    "    \n",
    "    def __init__(self,imageFolderDataset,transform=None,should_invert=True):\n",
    "        self.imageFolderDataset = imageFolderDataset    \n",
    "        self.transform = transform\n",
    "        self.should_invert = should_invert\n",
    "        \n",
    "    def __getitem__(self,index):\n",
    "        img0_tuple = random.choice(self.imageFolderDataset.imgs)\n",
    "        #we need to make sure approx 50% of images are in the same class\n",
    "        should_get_same_class = random.randint(0,1) \n",
    "        if should_get_same_class:\n",
    "            while True:\n",
    "                #keep looping till the same class image is found\n",
    "                img1_tuple = random.choice(self.imageFolderDataset.imgs) \n",
    "#                 print(img1_tuple[0])\n",
    "                if img0_tuple[1]==img1_tuple[1]:\n",
    "                    break\n",
    "        else:\n",
    "            while True:\n",
    "                #keep looping till a different class image is found\n",
    "                \n",
    "                img1_tuple = random.choice(self.imageFolderDataset.imgs) \n",
    "                if img0_tuple[1] !=img1_tuple[1]:\n",
    "                    break\n",
    "\n",
    "        img0 = Image.open(img0_tuple[0])\n",
    "#         print(img0)\n",
    "        img1 = Image.open(img1_tuple[0])\n",
    "        img0 = img0.convert(\"L\")\n",
    "        img1 = img1.convert(\"L\")\n",
    "#         print(img0)\n",
    "        if self.should_invert:\n",
    "            img0 = PIL.ImageOps.invert(img0)\n",
    "            img1 = PIL.ImageOps.invert(img1)\n",
    "\n",
    "        if self.transform is not None:\n",
    "            img0 = self.transform(img0)\n",
    "            img1 = self.transform(img1)\n",
    "        \n",
    "        return img0, img1 , torch.from_numpy(np.array([int(img1_tuple[1]!=img0_tuple[1])],dtype=np.float32))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.imageFolderDataset.imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "QuVraBuPtIJH"
   },
   "outputs": [],
   "source": [
    "class SiameseNetworkDatasetMyTest(Dataset):\n",
    "    \n",
    "    def __init__(self,imageFolderDataset,transform=None,should_invert=True):\n",
    "        self.imageFolderDataset = imageFolderDataset    \n",
    "        self.transform = transform\n",
    "        self.should_invert = should_invert\n",
    "        \n",
    "    def __getitem__(self,index):\n",
    "        img0_tuple = self.imageFolderDataset.imgs[index]#random.choice(self.imageFolderDataset.imgs)\n",
    "#         print(\"Image tuple 0 : \",img0_tuple)\n",
    "        img0 = Image.open(img0_tuple[0])\n",
    "        img0 = img0.convert(\"L\")\n",
    "        if self.transform is not None:\n",
    "            img0 = self.transform(img0)        \n",
    "        return img0, torch.from_numpy(np.array([int(img0_tuple[1])],dtype=np.int32))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.imageFolderDataset.imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "knxrmPNctKqX"
   },
   "outputs": [],
   "source": [
    "class SiameseNetworkDatasetMyLabel(Dataset):\n",
    "    \n",
    "    def __init__(self,imageFolderDataset,transform=None,should_invert=True):\n",
    "        self.imageFolderDataset = imageFolderDataset    \n",
    "        self.transform = transform\n",
    "        self.should_invert = should_invert\n",
    "        \n",
    "    def __getitem__(self,index):\n",
    "        img0_tuple = self.imageFolderDataset.imgs[index]#random.choice(self.imageFolderDataset.imgs)\n",
    "#         print(\"Label: \",img0_tuple, img0_tuple[1])\n",
    "        img0 = Image.open(img0_tuple[0])\n",
    "        img0 = img0.convert(\"L\")\n",
    "        if self.transform is not None:\n",
    "            img0 = self.transform(img0)        \n",
    "        return img0, torch.from_numpy(np.array([int(img0_tuple[1])],dtype=np.int32))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.imageFolderDataset.imgs)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "kxACCQs_tMbD"
   },
   "outputs": [],
   "source": [
    "folder_dataset = dset.ImageFolder(root=Config.training_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "kqsQZIBjtVeb"
   },
   "outputs": [],
   "source": [
    "siamese_dataset = SiameseNetworkDataset(imageFolderDataset=folder_dataset,\n",
    "                                        transform=transforms.Compose([transforms.CenterCrop((50,50)),\n",
    "                                                                      transforms.ToTensor(),\n",
    "#                                                                       transforms.Normalize((0.5), (0.5))\n",
    "                                                                      ])\n",
    "                                       ,should_invert=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "id": "pHo8bX8ItXlL",
    "outputId": "e906888d-bef5-4d09-ae48-d366f80a8134"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 1, 50, 50)\n"
     ]
    }
   ],
   "source": [
    "vis_dataloader = DataLoader(siamese_dataset,\n",
    "                        shuffle=True,\n",
    "                        num_workers=0,\n",
    "                        batch_size=2)\n",
    "dataiter = iter(vis_dataloader)\n",
    "\n",
    "\n",
    "example_batch = next(dataiter)\n",
    "concatenated = torch.cat((example_batch[0],example_batch[1]),0)\n",
    "imshow(torchvision.utils.make_grid(concatenated))\n",
    "print(example_batch[1].numpy().shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "NDUSH_aOtaOE"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "class SiameseNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SiameseNetwork, self).__init__()\n",
    "        self.cnn1 = nn.Sequential(\n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(1, 64, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(64),\n",
    "            \n",
    "            \n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(64, 32, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(32),\n",
    "\n",
    "            \n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(32, 16, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(16),\n",
    "            \n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(16, 8, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(8),\n",
    "\n",
    "\n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(8, 8, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(8),\n",
    "\n",
    "\n",
    "        )\n",
    "\n",
    "        self.fc1 = nn.Sequential(\n",
    "            nn.Linear(8*50*50, 500),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Linear(500, 500),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Linear(500, 4))\n",
    "\n",
    "    def forward_once(self, x):\n",
    "        output = self.cnn1(x)\n",
    "        output = output.view(output.size()[0], -1)\n",
    "        output = self.fc1(output)\n",
    "        return output\n",
    "\n",
    "    def forward(self, input1, input2=None):\n",
    "        output1 = self.forward_once(input1)\n",
    "        if input2 is None:\n",
    "          return output1\n",
    "        output2 = self.forward_once(input2)\n",
    "        return output1, output2\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "HXfLyjw5txxb"
   },
   "outputs": [],
   "source": [
    "class ContrastiveLoss(torch.nn.Module):\n",
    "    \"\"\"\n",
    "    Contrastive loss function.\n",
    "    Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf\n",
    "    \"\"\"\n",
    "\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_contrastive = torch.mean((1-label) * torch.pow(euclidean_distance, 2) +\n",
    "                                      (label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2))\n",
    "\n",
    "\n",
    "        return loss_contrastive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "ilOApY3_tz19"
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "F8WAxZqUt1o0"
   },
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(siamese_dataset,\n",
    "                        shuffle=True,\n",
    "                        num_workers=8,\n",
    "                        batch_size=Config.train_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "NvMpZPQ9t4t8"
   },
   "outputs": [],
   "source": [
    "net = SiameseNetwork()\n",
    "net.to(device)\n",
    "criterion = ContrastiveLoss()\n",
    "optimizer = optim.Adam(net.parameters(),lr = 0.0005 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "xxbbm5Zmt6Qw"
   },
   "outputs": [],
   "source": [
    "counter = []\n",
    "loss_history = [] \n",
    "iteration_number= 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "9x_IkzTjt7wb",
    "outputId": "ddc17bb5-aacf-4f72-f239-e023b85aaf9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch number 0\n",
      " Current loss 1.535538673400879\n",
      "\n",
      "Epoch number 0\n",
      " Current loss 0.7785950303077698\n",
      "\n",
      "Epoch number 0\n",
      " Current loss 0.6384725570678711\n",
      "\n",
      "Epoch number 1\n",
      " Current loss 0.6142445802688599\n",
      "\n",
      "Epoch number 1\n",
      " Current loss 0.829912543296814\n",
      "\n",
      "Epoch number 1\n",
      " Current loss 0.6562427282333374\n",
      "\n",
      "Epoch number 2\n",
      " Current loss 0.5074901580810547\n",
      "\n",
      "Epoch number 2\n",
      " Current loss 0.4253218472003937\n",
      "\n",
      "Epoch number 2\n",
      " Current loss 0.6422855257987976\n",
      "\n",
      "Epoch number 3\n",
      " Current loss 0.49142909049987793\n",
      "\n",
      "Epoch number 3\n",
      " Current loss 0.5528755187988281\n",
      "\n",
      "Epoch number 3\n",
      " Current loss 0.3719410300254822\n",
      "\n",
      "Epoch number 4\n",
      " Current loss 0.3466765284538269\n",
      "\n",
      "Epoch number 4\n",
      " Current loss 0.306918740272522\n",
      "\n",
      "Epoch number 4\n",
      " Current loss 0.3084432780742645\n",
      "\n",
      "Epoch number 5\n",
      " Current loss 0.2633016109466553\n",
      "\n",
      "Epoch number 5\n",
      " Current loss 0.23517654836177826\n",
      "\n",
      "Epoch number 5\n",
      " Current loss 0.2814372479915619\n",
      "\n",
      "Epoch number 6\n",
      " Current loss 0.28428491950035095\n",
      "\n",
      "Epoch number 6\n",
      " Current loss 0.18068808317184448\n",
      "\n",
      "Epoch number 6\n",
      " Current loss 0.11091490089893341\n",
      "\n",
      "Epoch number 7\n",
      " Current loss 0.09801778197288513\n",
      "\n",
      "Epoch number 7\n",
      " Current loss 0.15629848837852478\n",
      "\n",
      "Epoch number 7\n",
      " Current loss 0.0701712891459465\n",
      "\n",
      "Epoch number 8\n",
      " Current loss 0.08002164214849472\n",
      "\n",
      "Epoch number 8\n",
      " Current loss 0.0698123499751091\n",
      "\n",
      "Epoch number 8\n",
      " Current loss 0.11323140561580658\n",
      "\n",
      "Epoch number 9\n",
      " Current loss 0.04466347396373749\n",
      "\n",
      "Epoch number 9\n",
      " Current loss 0.07793527841567993\n",
      "\n",
      "Epoch number 9\n",
      " Current loss 0.09028737246990204\n",
      "\n",
      "Epoch number 10\n",
      " Current loss 0.06907181441783905\n",
      "\n",
      "Epoch number 10\n",
      " Current loss 0.05207715556025505\n",
      "\n",
      "Epoch number 10\n",
      " Current loss 0.041759882122278214\n",
      "\n",
      "Epoch number 11\n",
      " Current loss 0.01891087368130684\n",
      "\n",
      "Epoch number 11\n",
      " Current loss 0.04074879735708237\n",
      "\n",
      "Epoch number 11\n",
      " Current loss 0.020412612706422806\n",
      "\n",
      "Epoch number 12\n",
      " Current loss 0.013601308688521385\n",
      "\n",
      "Epoch number 12\n",
      " Current loss 0.007447578012943268\n",
      "\n",
      "Epoch number 12\n",
      " Current loss 0.017303355038166046\n",
      "\n",
      "Epoch number 13\n",
      " Current loss 0.015306377783417702\n",
      "\n",
      "Epoch number 13\n",
      " Current loss 0.02225133590400219\n",
      "\n",
      "Epoch number 13\n",
      " Current loss 0.009067034348845482\n",
      "\n",
      "Epoch number 14\n",
      " Current loss 0.014881987124681473\n",
      "\n",
      "Epoch number 14\n",
      " Current loss 0.009691374376416206\n",
      "\n",
      "Epoch number 14\n",
      " Current loss 0.0052038757130503654\n",
      "\n",
      "Epoch number 15\n",
      " Current loss 0.009048335254192352\n",
      "\n",
      "Epoch number 15\n",
      " Current loss 0.005158960819244385\n",
      "\n",
      "Epoch number 15\n",
      " Current loss 0.004702648613601923\n",
      "\n",
      "Epoch number 16\n",
      " Current loss 0.005600603297352791\n",
      "\n",
      "Epoch number 16\n",
      " Current loss 0.007504652254283428\n",
      "\n",
      "Epoch number 16\n",
      " Current loss 0.006265203468501568\n",
      "\n",
      "Epoch number 17\n",
      " Current loss 0.005694945342838764\n",
      "\n",
      "Epoch number 17\n",
      " Current loss 0.005757787264883518\n",
      "\n",
      "Epoch number 17\n",
      " Current loss 0.0047564636915922165\n",
      "\n",
      "Epoch number 18\n",
      " Current loss 0.006048227660357952\n",
      "\n",
      "Epoch number 18\n",
      " Current loss 0.007423567585647106\n",
      "\n",
      "Epoch number 18\n",
      " Current loss 0.004805549513548613\n",
      "\n",
      "Epoch number 19\n",
      " Current loss 0.003273795126006007\n",
      "\n",
      "Epoch number 19\n",
      " Current loss 0.006761778611689806\n",
      "\n",
      "Epoch number 19\n",
      " Current loss 0.003609958104789257\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for epoch in range(0,Config.train_number_epochs):\n",
    "    for i, data in enumerate(train_dataloader,0):\n",
    "        img0, img1 , label = data\n",
    "        img0, img1 , label = img0.to(device), img1.to(device) , label.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        output1,output2 = net(img0,img1)\n",
    "        loss_contrastive = criterion(output1,output2,label)\n",
    "        loss_contrastive.backward()\n",
    "        optimizer.step()\n",
    "        if i %10 == 0 :\n",
    "            print(\"Epoch number {}\\n Current loss {}\\n\".format(epoch,loss_contrastive.item()))\n",
    "            iteration_number +=10\n",
    "            counter.append(iteration_number)\n",
    "            loss_history.append(loss_contrastive.item())\n",
    "show_plot(counter,loss_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "NHxaYpVnt_6j"
   },
   "outputs": [],
   "source": [
    "torch.save(net, 'siam-2.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "3D4pDQx6A_Gs"
   },
   "outputs": [],
   "source": [
    "folder_dataset_test = dset.ImageFolder(root=Config.training_dir)\n",
    "siamese_dataset = SiameseNetworkDatasetMyTest(imageFolderDataset=folder_dataset_test,\n",
    "                                        transform=transforms.Compose([transforms.CenterCrop((50,50)),\n",
    "                                                                      transforms.ToTensor()\n",
    "                                                                      ])\n",
    "                                       ,should_invert=False)\n",
    "dataloader = DataLoader(siamese_dataset,num_workers=1,batch_size=1,shuffle=False)\n",
    "dataiter = iter(dataloader)\n",
    "# print(len(dataloader))\n",
    "training_embedding = []\n",
    "for i in range(len(dataloader)):\n",
    "  x0,label_test= next(dataiter)\n",
    "  label_test = label_test.cuda()\n",
    "  label_test = (label_test.tolist())[0][0]\n",
    "  x0 = x0.cuda() \n",
    "  output1 = net(Variable(x0))\n",
    "  training_embedding.append([output1.cpu().detach().numpy().tolist()[0],label_test])\n",
    "# print(training_embedding)\n",
    "with open('train_embedding_newb.pkl','wb') as f:\n",
    "  pickle.dump(training_embedding, f)\n",
    "  \n",
    "with open('train_embedding_newb.pkl','rb') as f:\n",
    "  l = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "mw9tzb5YAw9B"
   },
   "outputs": [],
   "source": [
    "with open('train_embedding_newb.pkl','rb') as f:\n",
    "  l = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "uV0Qz3Ueu1Lc",
    "outputId": "d6afdaac-4fca-47fc-e495-f3ac3090fb11"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12613015398943636\n"
     ]
    }
   ],
   "source": [
    "a = np.array(l[0][0])\n",
    "b = np.array(l[1][0])\n",
    "\n",
    "dist = np.linalg.norm(a-b)\n",
    "print(dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "glLlOp4su7cw"
   },
   "outputs": [],
   "source": [
    "k = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "H3Yn84dru_Sn"
   },
   "outputs": [],
   "source": [
    "import operator\n",
    "def getResponse(neighbors):\n",
    "\t  classVotes = {}\n",
    "#     print(neighbors)\n",
    "\t  for x in range(len(neighbors)):\n",
    "\t\t  response = neighbors[x][1]\n",
    "\t\t  if response in classVotes:\n",
    "\t\t\t  classVotes[response] += 1\n",
    "\t\t  else:\n",
    "\t\t\t  classVotes[response] = 1\n",
    "\t  sortedVotes = sorted(classVotes.items(), key=operator.itemgetter(1), reverse=True)\n",
    "\t  return sortedVotes[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "id": "Dp0iLdEZvBuK",
    "outputId": "b656cfa5-1f21-44d8-963d-4ad0dbe9b261"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/404 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "404\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 404/404 [02:10<00:00,  3.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74.25742574257426\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "folder_dataset_test = dset.ImageFolder(root=Config.custom_testing_dir)\n",
    "# folder_dataset_label = dset.ImageFolder(root=Config.custom_labeled_dir)\n",
    "siamese_dataset = SiameseNetworkDatasetMyTest(imageFolderDataset=folder_dataset_test,\n",
    "                                        transform=transforms.Compose([transforms.CenterCrop((50,50)),\n",
    "                                                                      transforms.ToTensor()\n",
    "                                                                      ])\n",
    "                                       ,should_invert=False)\n",
    "\n",
    "\n",
    "test_dataloader = DataLoader(siamese_dataset,num_workers=0,batch_size=1,shuffle=False)\n",
    "test_len = len(test_dataloader)\n",
    "print(test_len)\n",
    "test_dataiter = iter(test_dataloader)\n",
    "y_true = []\n",
    "prediction = []\n",
    "correct = 0\n",
    "for i in tqdm(range(test_len)):\n",
    "    x0,label_test= next(test_dataiter)\n",
    "    label_test = label_test.cuda()\n",
    "    label_test = (label_test.tolist())[0][0]\n",
    "    x0 = x0.cuda()\n",
    "    test_embedding = net(Variable(x0))\n",
    "    test_embedding = test_embedding.cpu().detach().numpy()\n",
    "    dist_list = [] \n",
    "    label_list = []\n",
    "    for j in range(len(l)):\n",
    "      train_embedding = l[j][0]\n",
    "      train_embedding = np.array(train_embedding)\n",
    "      train_label = l[j][1]\n",
    "      dist = np.linalg.norm(test_embedding-train_embedding)      \n",
    "      dist_list.append(dist)\n",
    "      label_list.append(train_label)\n",
    "#     print(dist_list, label_list)\n",
    "    zipped = zip(dist_list, label_list) \n",
    "    # Converting to list \n",
    "    zipped = list(zipped) \n",
    "    # Using sorted and lambda \n",
    "    final_list = sorted(zipped, key = lambda x: x[0]) \n",
    "    \n",
    "    predicted_label = getResponse(final_list[0:k])\n",
    "#     print(predicted_label, label_test)\n",
    "    if predicted_label == label_test:\n",
    "        correct += 1\n",
    "    prediction.append(predicted_label)\n",
    "    y_true.append(label_test)\n",
    "# print(len(y_true), len(prediction))    \n",
    "accuracy = correct*100.0/test_len\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "id": "rZNa4uiUvEo_",
    "outputId": "7b0bfa2f-3215-4edb-e779-645e94ad0764"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[47,  1, 34, 21],\n",
       "       [ 0, 89,  9,  2],\n",
       "       [ 6,  0, 89,  5],\n",
       "       [24,  0,  2, 75]])"
      ]
     },
     "execution_count": 29,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_true, prediction)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TLDajcTEwF1F"
   },
   "outputs": [],
   "source": [
    "print(len(y_true),prediction)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_9Gtwm0dwIcL"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Siamese-newdata-balanced.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}