Siamese-networks-defect.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One Shot Learning with Siamese Networks\n",
    "\n",
    "This is the jupyter notebook that accompanies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "All the imports are defined here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\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 torchsummary.torchsummary import summary\n",
    "from skimage.color import rgb2gray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "Set of helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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)), cmap=plt.cm.gray)\n",
    "    plt.show()    \n",
    "\n",
    "def show_plot(iteration,loss):\n",
    "    plt.plot(iteration,loss)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration Class\n",
    "A simple class to manage configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config():\n",
    "    training_dir = \"./dataset/training/\"\n",
    "    testing_dir = \"./dataset/testing/\"\n",
    "    train_batch_size = 64\n",
    "    train_number_epochs = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# dataaug Augmentor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import imgaug as ia\n",
    "from PIL import Image\n",
    "\n",
    "class Augmenter():\n",
    "\n",
    "    def __init__(self, seq):\n",
    "        self.seq = seq\n",
    "\n",
    "    def __call__(self, img_and_annotation):\n",
    "\n",
    "        normal_image = img_and_annotation[0]\n",
    "        defect_image = img_and_annotation[1]\n",
    "        box_annotation_dict = img_and_annotation[2]\n",
    "\n",
    "        normal_image = np.array(normal_image)\n",
    "        defect_image = np.array(defect_image)\n",
    "        \n",
    "        normal_image_aug, defect_image_aug, bbs_aug = self.augment_image(normal_image, defect_image, box_annotation_dict, self.seq)\n",
    "        \n",
    "        normal_image_aug = Image.fromarray(normal_image_aug)\n",
    "        defect_image_aug = Image.fromarray(defect_image_aug)\n",
    "\n",
    "        return normal_image_aug, defect_image_aug, bbs_aug\n",
    "\n",
    "    def augment_image(self, normal_image, defect_image, box_annotation_dict, seq):\n",
    "        bbs = self.transform_imgaug_style_boxes(box_annotation_dict)\n",
    "        seq_det = seq.to_deterministic()\n",
    "\n",
    "        normal_image_aug = seq_det.augment_images([normal_image])[0]\n",
    "        defect_image_aug = seq_det.augment_images([defect_image])[0]\n",
    "        bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]\n",
    "        bbs_aug = bbs_aug.remove_out_of_image().cut_out_of_image()\n",
    "        augmented_box = self.transofrm_annotation_information_style(box_annotation_dict, bbs_aug)\n",
    "\n",
    "        return normal_image_aug, defect_image_aug, augmented_box\n",
    "\n",
    "    @staticmethod\n",
    "    def transofrm_annotation_information_style(box_annotation_dict, bbs_aug):\n",
    "        assert isinstance(box_annotation_dict, dict)\n",
    "\n",
    "        box_annotation_keys = box_annotation_dict.keys()\n",
    "        assert \"size\" in box_annotation_keys\n",
    "        assert \"object\" in box_annotation_keys\n",
    "\n",
    "        size_tag_keys = box_annotation_dict[\"size\"].keys()\n",
    "        assert \"width\" in size_tag_keys\n",
    "        assert \"height\" in size_tag_keys\n",
    "        assert \"depth\" in size_tag_keys\n",
    "\n",
    "        assert isinstance(box_annotation_dict[\"object\"], list)\n",
    "        for _object in box_annotation_dict[\"object\"]:\n",
    "            _object_keys = _object.keys()\n",
    "            assert \"name\" in _object_keys\n",
    "            assert \"xmin\" in _object_keys\n",
    "            assert \"ymin\" in _object_keys\n",
    "            assert \"xmax\" in _object_keys\n",
    "            assert \"ymax\" in _object_keys\n",
    "\n",
    "        assert isinstance(bbs_aug, ia.BoundingBoxesOnImage)\n",
    "\n",
    "        objects = box_annotation_dict[\"object\"]\n",
    "        objects.clear()\n",
    "\n",
    "        for i in range(len(bbs_aug.bounding_boxes)):\n",
    "            augmented_box = bbs_aug.bounding_boxes[i]\n",
    "            objects.append(\n",
    "                {\n",
    "                    \"name\": augmented_box.label,\n",
    "                    \"xmin\": augmented_box.x1,\n",
    "                    \"ymin\": augmented_box.y1,\n",
    "                    \"xmax\": augmented_box.x2,\n",
    "                    \"ymax\": augmented_box.y2\n",
    "                }\n",
    "            )\n",
    "\n",
    "        return box_annotation_dict\n",
    "\n",
    "    @staticmethod\n",
    "    def transform_imgaug_style_boxes(box_annotation_dict):\n",
    "        assert isinstance(box_annotation_dict, dict)\n",
    "\n",
    "        box_annotation_keys = box_annotation_dict.keys()\n",
    "        assert \"size\" in box_annotation_keys\n",
    "        assert \"object\" in box_annotation_keys\n",
    "\n",
    "        size_tag_keys = box_annotation_dict[\"size\"].keys()\n",
    "        assert \"width\" in size_tag_keys\n",
    "        assert \"height\" in size_tag_keys\n",
    "        assert \"depth\" in size_tag_keys\n",
    "\n",
    "        assert isinstance(box_annotation_dict[\"object\"], list)\n",
    "        for _object in box_annotation_dict[\"object\"]:\n",
    "            _object_keys = _object.keys()\n",
    "            assert \"name\" in _object_keys\n",
    "            assert \"xmin\" in _object_keys\n",
    "            assert \"ymin\" in _object_keys\n",
    "            assert \"xmax\" in _object_keys\n",
    "            assert \"ymax\" in _object_keys\n",
    "\n",
    "        image_width = int(box_annotation_dict[\"size\"][\"width\"])\n",
    "        image_height = int(box_annotation_dict[\"size\"][\"height\"])\n",
    "\n",
    "        bbs = ia.BoundingBoxesOnImage([], shape=(image_height, image_width))\n",
    "\n",
    "        for _object in box_annotation_dict[\"object\"]:\n",
    "            name = _object[\"name\"]\n",
    "            xmin = int(_object[\"xmin\"])\n",
    "            ymin = int(_object[\"ymin\"])\n",
    "            xmax = int(_object[\"xmax\"])\n",
    "            ymax = int(_object[\"ymax\"])\n",
    "            bbs.bounding_boxes.append(ia.BoundingBox(x1=xmin,\n",
    "                                                     x2=xmax,\n",
    "                                                     y1=ymin,\n",
    "                                                     y2=ymax,\n",
    "                                                     label=name))\n",
    "\n",
    "        return bbs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom Dataset Class\n",
    "This dataset generates a pair of images. 0 for geniune pair and 1 for imposter pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "from PIL import Image\n",
    "\n",
    "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', 'webp']\n",
    "LABEL_EXTENSIONS = ['.xml']\n",
    "\n",
    "def has_file_allowed_extension(filename, extensions):\n",
    "    \"\"\"Checks if a file is an allowed extension.\n",
    "    Args:\n",
    "        filename (string): path to a file\n",
    "        extensions (iterable of strings): extensions to consider (lowercase)\n",
    "    Returns:\n",
    "        bool: True if the filename ends with one of given extensions\n",
    "    \"\"\"\n",
    "    filename_lower = filename.lower()\n",
    "    return any(filename_lower.endswith(ext) for ext in extensions)\n",
    "\n",
    "\n",
    "class DefectDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, root, transform=None):\n",
    "        self.folder = self._find_each_folder(root)\n",
    "        self.root = root\n",
    "        self.transform = transform\n",
    "        self.samples = self.load_data()\n",
    "        self.classes = [\"defect\"]\n",
    "        \n",
    "    def load_data(self):\n",
    "        datas = list()\n",
    "        \n",
    "        directory = os.path.expanduser(self.root)\n",
    "        \n",
    "        for target in sorted(self.folder.keys()):\n",
    "            d = os.path.join(directory, target)\n",
    "            \n",
    "            imgs = dict()\n",
    "            label = None\n",
    "            for a in os.scandir(d):\n",
    "                name = a.name.split(\".\")[0]\n",
    "                ext = a.name.split(\".\")[-1]\n",
    "                \n",
    "                if ext == \"tif\":\n",
    "                    imgs[name] = os.path.join(d, a.name)\n",
    "                \n",
    "                elif ext == \"xml\":\n",
    "                    label = os.path.join(d, a.name)\n",
    "                \n",
    "            datas.append([imgs, label])\n",
    "        \n",
    "        return datas\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        imgs, label = self.samples[index]\n",
    "        label = self._parse_voc(label)\n",
    "        \n",
    "        normal_img = self.pil_loader(imgs[\"normal\"])\n",
    "        defect_img = self.pil_loader(imgs[\"defect\"])\n",
    "        \n",
    "        if self.transform:\n",
    "            normal_aug_img, defect_aug_img, aug_label = self.transform([normal_img, defect_img, label])\n",
    "        \n",
    "            if random.choice([True, False]):\n",
    "                # same image\n",
    "                image1 = normal_img.resize((100, 100), Image.ANTIALIAS)\n",
    "                image2 = normal_aug_img\n",
    "                label = np.array([0.], dtype=np.float)\n",
    "            else:\n",
    "                # difference image\n",
    "                image1 = normal_img.resize((100, 100), Image.ANTIALIAS)\n",
    "                image2 = defect_img.resize((100, 100), Image.ANTIALIAS)\n",
    "                label = np.array([1.], dtype=np.float)\n",
    "        else:\n",
    "            image1 = normal_img.resize((100, 100), Image.ANTIALIAS)\n",
    "            image2 = defect_img.resize((100, 100), Image.ANTIALIAS)\n",
    "            \n",
    "        image1 = image1.convert('L')\n",
    "        image2 = image2.convert('L')\n",
    "        \n",
    "        image1 = torchvision.transforms.ToTensor()(image1)\n",
    "        image2 = torchvision.transforms.ToTensor()(image2)\n",
    "        label = torch.from_numpy(label)\n",
    "        \n",
    "        return image1, image2, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.samples)\n",
    "    \n",
    "    def pil_loader(self, path):\n",
    "        # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)\n",
    "        with open(path, 'rb') as f:\n",
    "            img = Image.open(f)\n",
    "            return img.convert('RGB')\n",
    "    \n",
    "    def _find_each_folder(self, dir):\n",
    "        \n",
    "        if sys.version_info >= (3, 5):\n",
    "            # Faster and available in Python 3.5 and above\n",
    "            classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n",
    "        else:\n",
    "            classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]\n",
    "        classes.sort()\n",
    "        class_to_idx = {classes[i]: i for i in range(len(classes))}\n",
    "        return class_to_idx\n",
    "    \n",
    "    def _convert_box_label_to_yolo_label(self, label, classes_list):\n",
    "        assert isinstance(label, dict)\n",
    "        assert isinstance(classes_list, list)\n",
    "        for cls in classes_list:\n",
    "            assert isinstance(cls, str)\n",
    "\n",
    "        root_keys = label.keys()\n",
    "        size_keys = label[\"size\"].keys()\n",
    "        number_of_objects = len(label[\"object\"])\n",
    "\n",
    "        assert \"size\" in root_keys\n",
    "        assert \"object\" in root_keys\n",
    "        assert \"width\" in size_keys\n",
    "        assert \"height\" in size_keys\n",
    "        \n",
    "        if number_of_objects == 0:\n",
    "            print(\"here\")\n",
    "            return []\n",
    "\n",
    "        yolo_label = list()\n",
    "\n",
    "        image_size = {\n",
    "            \"width\": float(label[\"size\"][\"width\"]),\n",
    "            \"height\": float(label[\"size\"][\"height\"]),\n",
    "        }\n",
    "\n",
    "        for _object in label[\"object\"]:\n",
    "            _object_keys = _object.keys()\n",
    "            assert \"name\" in _object_keys\n",
    "            assert \"xmin\" in _object_keys\n",
    "            assert \"ymin\" in _object_keys\n",
    "            assert \"xmax\" in _object_keys\n",
    "            assert \"ymax\" in _object_keys\n",
    "\n",
    "            name = _object[\"name\"]\n",
    "            cls = float(classes_list.index(name))\n",
    "            box_coordinate = {\n",
    "                \"xmin\": float(_object[\"xmin\"]),\n",
    "                \"ymin\": float(_object[\"ymin\"]),\n",
    "                \"xmax\": float(_object[\"xmax\"]),\n",
    "                \"ymax\": float(_object[\"ymax\"]),\n",
    "            }\n",
    "\n",
    "            yolo_coordinate = self._convert_coordinate(image_size, box_coordinate)\n",
    "            yolo_coordinate.insert(0, cls)\n",
    "            yolo_label.append(yolo_coordinate)\n",
    "\n",
    "        return yolo_label\n",
    "    \n",
    "    @staticmethod\n",
    "    def _parse_voc(annotation_path):\n",
    "        import xml.etree.ElementTree as Et\n",
    "        assert isinstance(annotation_path, str)\n",
    "\n",
    "        xml_file = open(annotation_path, \"r\")\n",
    "        tree = Et.parse(xml_file)\n",
    "\n",
    "        element_list = list()\n",
    "        for elem in tree.iter():\n",
    "            element_list.append(elem.tag)\n",
    "\n",
    "        assert \"size\" in element_list\n",
    "        assert \"width\" in element_list\n",
    "        assert \"height\" in element_list\n",
    "        assert \"object\" in element_list\n",
    "        assert \"name\" in element_list\n",
    "        assert \"bndbox\" in element_list\n",
    "        assert \"xmin\" in element_list\n",
    "        assert \"ymin\" in element_list\n",
    "        assert \"xmax\" in element_list\n",
    "        assert \"ymax\" in element_list\n",
    "\n",
    "        result = dict()\n",
    "        root = tree.getroot()\n",
    "\n",
    "        size_tag = root.find(\"size\")\n",
    "\n",
    "        result[\"size\"] = {\n",
    "            \"width\": size_tag.find(\"width\").text,\n",
    "            \"height\": size_tag.find(\"height\").text,\n",
    "            \"depth\": size_tag.find(\"depth\").text\n",
    "        }\n",
    "\n",
    "        result[\"object\"] = list()\n",
    "\n",
    "        objects = root.findall(\"object\")\n",
    "        assert objects\n",
    "\n",
    "        for _object in objects:\n",
    "\n",
    "            result[\"object\"].append({\n",
    "                \"name\": _object.find(\"name\").text,\n",
    "                \"xmin\": _object.find(\"bndbox\").find(\"xmin\").text,\n",
    "                \"ymin\": _object.find(\"bndbox\").find(\"ymin\").text,\n",
    "                \"xmax\": _object.find(\"bndbox\").find(\"xmax\").text,\n",
    "                \"ymax\": _object.find(\"bndbox\").find(\"ymax\").text\n",
    "            })\n",
    "\n",
    "        return result\n",
    "    \n",
    "    @staticmethod\n",
    "    def _convert_coordinate(image_size, box_coordinate):\n",
    "        image_size_keys = image_size.keys()\n",
    "        box_coordinate_keys = box_coordinate.keys()\n",
    "        assert \"width\" in image_size_keys\n",
    "        assert \"height\" in image_size_keys\n",
    "        assert \"xmin\" in box_coordinate_keys\n",
    "        assert \"ymin\" in box_coordinate_keys\n",
    "        assert \"xmax\" in box_coordinate_keys\n",
    "        assert \"ymax\" in box_coordinate_keys\n",
    "        assert isinstance(image_size, dict)\n",
    "        assert isinstance(box_coordinate, dict)\n",
    "        assert isinstance(image_size[\"width\"], float)\n",
    "        assert isinstance(image_size[\"height\"], float)\n",
    "        assert isinstance(box_coordinate[\"xmin\"], float)\n",
    "        assert isinstance(box_coordinate[\"ymin\"], float)\n",
    "        assert isinstance(box_coordinate[\"xmax\"], float)\n",
    "        assert isinstance(box_coordinate[\"ymax\"], float)\n",
    "\n",
    "        x_of_box = (box_coordinate[\"xmin\"] + box_coordinate[\"xmax\"]) / 2.0\n",
    "        y_of_box = (box_coordinate[\"ymin\"] + box_coordinate[\"ymax\"]) / 2.0\n",
    "        width_of_box = box_coordinate[\"xmax\"] - box_coordinate[\"xmin\"]\n",
    "        height_of_box = box_coordinate[\"ymax\"] - box_coordinate[\"ymin\"]\n",
    "\n",
    "        relative_x_of_center = x_of_box / image_size[\"width\"]\n",
    "        relative_y_of_center = y_of_box / image_size[\"height\"]\n",
    "        relative_box_width = width_of_box / image_size[\"width\"]\n",
    "        relative_box_height = height_of_box / image_size[\"height\"]\n",
    "\n",
    "        return [relative_x_of_center, relative_y_of_center,\n",
    "                relative_box_width, relative_box_height]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test code (doesn't need execute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from imgaug import augmenters as iaa\n",
    "\n",
    "\n",
    "# Augmentation Demo\n",
    "seq = iaa.Sequential([\n",
    "            iaa.Resize({\"height\": 100, \"width\": 100}),\n",
    "            iaa.SomeOf(2, [iaa.Multiply((1, 1.1)),  # change brightness, doesn't affect BBs\n",
    "                            iaa.Affine(\n",
    "                                translate_px={\"x\": 5, \"y\": 5},\n",
    "                                scale=(1, 1)\n",
    "                            ),  # translate by 40/60px on x/y axis, and scale to 50-70%, affects BBs\n",
    "                            iaa.GaussianBlur(sigma=(0.0, 0.1)),\n",
    "                            iaa.Affine(rotate=(-10, 10)),\n",
    "                            ])\n",
    "            #iaa.Sharpen(alpha=(0, 0.0001)),\n",
    "            #iaa.Fliplr(0.5)\n",
    "            ])\n",
    "\n",
    "#seq = iaa.Sometimes(0.5, iaa.Crop(percent=(0.4)))\n",
    "#seq = iaa.Sequential([iaa.Crop(percent=(0.3))])\n",
    "composed = transforms.Compose([Augmenter(seq)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from PIL import ImageDraw\n",
    "import random\n",
    "\n",
    "def convert_yolo_label_to_box_label(coordinate, image_size, classes_list):\n",
    "    assert isinstance(coordinate, list)\n",
    "    assert len(coordinate) == 5\n",
    "    for element in coordinate:\n",
    "        assert isinstance(element, float)\n",
    "    assert isinstance(image_size, tuple)\n",
    "    assert isinstance(classes_list, list)\n",
    "    for cls in classes_list:\n",
    "        isinstance(cls, str)\n",
    "\n",
    "    image_width, image_height = image_size\n",
    "\n",
    "    cls = classes_list[int(coordinate[0])]\n",
    "    x_of_center = int(coordinate[1] * image_width)\n",
    "    y_of_center = int(coordinate[2] * image_height)\n",
    "    width = coordinate[3] * image_width\n",
    "    height = coordinate[4] * image_height\n",
    "\n",
    "    xmin = int(x_of_center - (width / 2))\n",
    "    ymin = int(y_of_center - (height / 2))\n",
    "    xmax = int(xmin + width)\n",
    "    ymax = int(ymin + height)\n",
    "\n",
    "    return [cls, xmin, ymin, xmax, ymax]\n",
    "\n",
    "def draw_yolo_information(draw_image_obj, coordinate, image_size, classes_list):\n",
    "    assert isinstance(draw_image_obj, ImageDraw.ImageDraw)\n",
    "    assert isinstance(image_size, tuple)\n",
    "    assert isinstance(coordinate, list)\n",
    "    assert len(coordinate) == 5\n",
    "    for element in coordinate:\n",
    "        assert isinstance(element, float)\n",
    "\n",
    "    image_width, image_height = image_size\n",
    "\n",
    "    x_of_center = int(coordinate[1] * image_width)\n",
    "    y_of_center = int(coordinate[2] * image_height)\n",
    "\n",
    "    cls, xmin, ymin, xmax, ymax = \\\n",
    "        convert_yolo_label_to_box_label(coordinate, image_size, classes_list)\n",
    "\n",
    "    draw_image_obj.rectangle(((xmin, ymin), (xmax, ymax)), outline=\"blue\")\n",
    "    draw_image_obj.ellipse(((x_of_center - 2, y_of_center - 2),\n",
    "                  (x_of_center + 2, y_of_center + 2)),\n",
    "                 fill='blue')\n",
    "    draw_image_obj.text((xmin, ymin), cls)\n",
    "\n",
    "dataset = DefectDataset(root=Config.training_dir, transform=composed)\n",
    "print(dataset)\n",
    "index = [i for i in range(len(dataset))]\n",
    "\n",
    "figsize = (10, 10)\n",
    "random.shuffle(index)\n",
    "\n",
    "print(index)\n",
    "\n",
    "for j in range(5):\n",
    "    i = index[j]\n",
    "    normal_image, defect_image, target = dataset.__getitem__(i)\n",
    "    \n",
    "    print(normal_image)\n",
    "    print(normal_image.shape)\n",
    "    #draw = ImageDraw.Draw(defect_image)\n",
    "\n",
    "    #if len(target) != 0:\n",
    "    #    for coordinate in target:\n",
    "    #        draw_yolo_information(draw, coordinate, defect_image.size, [\"defect\"])\n",
    "\n",
    "    plt.figure(figsize=figsize)\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(normal_image, cmap=plt.get_cmap('gray'))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.imshow(defect_image, cmap=plt.get_cmap('gray'))\n",
    "    print(target)\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Image Folder Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from imgaug import augmenters as iaa\n",
    "\n",
    "\n",
    "# Augmentation Demo\n",
    "seq = iaa.Sequential([\n",
    "            iaa.Resize({\"height\": 100, \"width\": 100}),\n",
    "            iaa.SomeOf(2, [iaa.Multiply((1, 1.1)),  # change brightness, doesn't affect BBs\n",
    "                            iaa.Affine(\n",
    "                                translate_px={\"x\": 5, \"y\": 5},\n",
    "                                scale=(1, 1)\n",
    "                            ),  # translate by 40/60px on x/y axis, and scale to 50-70%, affects BBs\n",
    "                            iaa.GaussianBlur(sigma=(0.0, 0.1)),\n",
    "                            iaa.Affine(rotate=(-10, 10)),\n",
    "                            ])\n",
    "            #iaa.Sharpen(alpha=(0, 0.0001)),\n",
    "            #iaa.Fliplr(0.5)\n",
    "            ])\n",
    "\n",
    "#seq = iaa.Sometimes(0.5, iaa.Crop(percent=(0.4)))\n",
    "#seq = iaa.Sequential([iaa.Crop(percent=(0.3))])\n",
    "composed = transforms.Compose([Augmenter(seq)])\n",
    "\n",
    "siamese_dataset = DefectDataset(root=Config.training_dir, transform=composed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualising some of the data\n",
    "The top row and the bottom row of any column is one pair. The 0s and 1s correspond to the column of the image.\n",
    "1 indiciates dissimilar, and 0 indicates similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.]\n",
      " [0.]\n",
      " [1.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [1.]]\n",
      "torch.Size([8, 1, 100, 100])\n"
     ]
    }
   ],
   "source": [
    "vis_dataloader = DataLoader(siamese_dataset,\n",
    "                        shuffle=True,\n",
    "                        num_workers=1,\n",
    "                        batch_size=8)\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[2].numpy())\n",
    "print(example_batch[0].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Neural Net Definition\n",
    "We will use a standard convolutional neural network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SiameseNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SiameseNetwork, self).__init__()\n",
    "        self.device = 'cpu'\n",
    "        self.cnn1 = nn.Sequential(\n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(1, 4, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.BatchNorm2d(4),\n",
    "            \n",
    "            nn.ReflectionPad2d(1),\n",
    "            nn.Conv2d(4, 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*100*100, 500),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Linear(500, 500),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Linear(500, 5))\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):\n",
    "        output1 = self.forward_once(input1)\n",
    "        output2 = self.forward_once(input2)\n",
    "        return output1, output2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contrastive Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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)\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": "markdown",
   "metadata": {},
   "source": [
    "## Training Time!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = SiameseNetwork().cpu()\n",
    "criterion = ContrastiveLoss()\n",
    "optimizer = optim.Adam(net.parameters(),lr = 0.0005 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = []\n",
    "loss_history = [] \n",
    "iteration_number= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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.cpu(), img1.cpu() , label.cpu()\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        output1,output2 = net(img0,img1)\n",
    "        \n",
    "        label = label.double()\n",
    "        output1 = output1.double()\n",
    "        output2 = output2.double()\n",
    "        \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": "markdown",
   "metadata": {},
   "source": [
    "## Some simple testing\n",
    "The last 3 subjects were held out from the training, and will be used to test. The Distance between each image pair denotes the degree of similarity the model found between the two images. Less means it found more similar, while higher values indicate it found them to be dissimilar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "run_control": {
     "marked": true
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "folder_dataset_test = dset.ImageFolder(root=Config.testing_dir)\n",
    "siamese_dataset = SiameseNetworkDataset(imageFolderDataset=folder_dataset_test,\n",
    "                                        transform=transforms.Compose([transforms.Resize((100,100)),\n",
    "                                                                      transforms.ToTensor()\n",
    "                                                                      ])\n",
    "                                       ,should_invert=False)\n",
    "\n",
    "test_dataloader = DataLoader(siamese_dataset,num_workers=6,batch_size=1,shuffle=True)\n",
    "dataiter = iter(test_dataloader)\n",
    "x0,_,_ = next(dataiter)\n",
    "\n",
    "for i in range(10):\n",
    "    _,x1,label2 = next(dataiter)\n",
    "    concatenated = torch.cat((x0,x1),0)\n",
    "    \n",
    "    output1,output2 = net(Variable(x0).cuda(),Variable(x1).cuda())\n",
    "    euclidean_distance = F.pairwise_distance(output1, output2)\n",
    "    imshow(torchvision.utils.make_grid(concatenated),'Dissimilarity: {:.2f}'.format(euclidean_distance.item()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}