baseline.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f4d52382-74a3-49f1-a824-ff8a6b6aba5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import argparse, random, copy\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "from matplotlib import pyplot as plt\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms as T\n",
    "from torch.optim.lr_scheduler import StepLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5327c469-a797-41c1-9248-e1baa642216a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cf7bea9b-4d73-4592-b7f1-ce23eafbdabd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "class CustomImageDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, base_dir, transform=None, target_transform=None):\n",
    "        self.transform = torchvision.transforms.Normalize(\n",
    "            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
    "        self.fname_list = None\n",
    "        self.base_dir = base_dir\n",
    "        self.target_transform = target_transform\n",
    "        self.create_fname_list()\n",
    "        self.img_labels = self.fname_list\n",
    "\n",
    "    def create_fname_list(self):\n",
    "        self.fname_list = os.listdir(os.path.join(self.base_dir, '2012'))\n",
    "        self.fname_list = list(filter(lambda x: x.find(\"jpg\") != -1, self.fname_list))\n",
    "        self.fname_list = list(map(lambda x: x[5: ], self.fname_list))\n",
    "\n",
    "    def normalize_image(self, img):\n",
    "        return self.transform(img.float() / 255)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.img_labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # TODO: refactor\n",
    "        img_path = os.path.join(self.base_dir, '2012', '2012_' + self.fname_list[idx])\n",
    "        img_path2 = os.path.join(self.base_dir, '2016', '2016_' + self.fname_list[idx])\n",
    "        image = plt.imread(img_path)\n",
    "        image2 = plt.imread(img_path2)\n",
    "        p2 = np.array(np.zeros((3, 256, 256)))\n",
    "        p2[0, ...] = image[..., 0]\n",
    "        p2[1, ...] = image[..., 1]\n",
    "        p2[2, ...] = image[..., 2]\n",
    "        p3 = np.array(np.zeros((3, 256, 256)))\n",
    "        p3[0, ...] = image2[..., 0]\n",
    "        p3[1, ...] = image2[..., 1]\n",
    "        p3[2, ...] = image2[..., 2]\n",
    "        label_path = os.path.join(self.base_dir, 'label', 'label_' + self.fname_list[idx])\n",
    "        image_label = plt.imread(label_path)\n",
    "        label = np.divide(image_label[..., 0], 255).astype(int)\n",
    "        # lab = np.array(np.zeros((1, 256, 256)))\n",
    "        # lab[0, :, :] = label\n",
    "        tor = torch.from_numpy(p2)\n",
    "        tor2 = torch.from_numpy(p3)\n",
    "        feature = self.normalize_image(tor)\n",
    "        feature2 = self.normalize_image(tor2)\n",
    "        print(img_path)\n",
    "\n",
    "        return feature, feature2, torch.from_numpy(label).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3da9e17d-625f-46a7-bc50-19e8e9c39fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(args, model, device, train_loader, optimizer, epoch):\n",
    "    model.train()\n",
    "\n",
    "    # we aren't using `TripletLoss` as the MNIST dataset is simple, so `BCELoss` can do the trick.\n",
    "    criterion = nn.BCELoss()\n",
    "\n",
    "    for batch_idx, (images_1, images_2, targets) in enumerate(train_loader):\n",
    "        images_1, images_2, targets = images_1.to(device), images_2.to(device), targets.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(images_1, images_2).squeeze()\n",
    "        loss = criterion(outputs, targets)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if batch_idx % args.log_interval == 0:\n",
    "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "                epoch, batch_idx * len(images_1), len(train_loader.dataset),\n",
    "                       100. * batch_idx / len(train_loader), loss.item()))\n",
    "            if args.dry_run:\n",
    "                break\n",
    "\n",
    "\n",
    "def test(model, device, test_loader):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "\n",
    "    # we aren't using `TripletLoss` as the MNIST dataset is simple, so `BCELoss` can do the trick.\n",
    "    criterion = nn.BCELoss()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for (images_1, images_2, targets) in test_loader:\n",
    "            images_1, images_2, targets = images_1.to(device), images_2.to(device), targets.to(device)\n",
    "            outputs = model(images_1, images_2).squeeze()\n",
    "            test_loss += criterion(outputs, targets).sum().item()  # sum up batch loss\n",
    "            pred = torch.where(outputs > 0.5, 1, 0)  # get the index of the max log-probability\n",
    "            correct += pred.eq(targets.view_as(pred)).sum().item()\n",
    "\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "\n",
    "    # for the 1st epoch, the average loss is 0.0001 and the accuracy 97-98%\n",
    "    # using default settings. After completing the 10th epoch, the average\n",
    "    # loss is 0.0000 and the accuracy 99.5-100% using default settings.\n",
    "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        test_loss, correct, len(test_loader.dataset),\n",
    "        100. * correct / len(test_loader.dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e7e9598d-e27d-4725-bd16-bf0685abc2ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device(\"cuda\")\n",
    "train_dataset = CustomImageDataset('images/largechange')\n",
    "train_kwargs = {'batch_size': 3}\n",
    "test_kwargs = {'batch_size': 1000}\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, **train_kwargs)\n",
    "\n",
    "model = baseline.SiameseNetwork().to(device)\n",
    "model.load_state_dict(torch.load('siamese_network0.pt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6db92963-ac15-40e7-85d1-4c8f135b190c",
   "metadata": {},
   "outputs": [],
   "source": [
    "loader = train_loader.__iter__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e5d9402c-257a-4183-8c38-156fe1327427",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "images/largechange/2012/2012_6000_6743.jpg\n",
      "images/largechange/2012/2012_11000_17743.jpg\n",
      "images/largechange/2012/2012_1500_17243.jpg\n"
     ]
    }
   ],
   "source": [
    "im1, im2, tar = next(loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6a02a197-399c-4154-ac82-16e56da57e05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 0., 0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tar[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ecb3c844-a036-4b2a-a4bc-cc216849dc7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([256, 256])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im1[0][0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e77f31b5-a52b-46b3-af83-103cf98f5366",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "images/largechange/2012/2012_14500_18243.jpg\n",
      "images/largechange/2012/2012_8000_20243.jpg\n",
      "images/largechange/2012/2012_4000_18743.jpg\n"
     ]
    }
   ],
   "source": [
    "im1, im2, tar = next(loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4f064cc1-dd87-4923-a1f8-8892e1e6c683",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f86ea99efa0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACFCAYAAACg7bhYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAwB0lEQVR4nO3deXzU1b34/9eZyb6SfU8gG5mwhgQERCB6WV2goiJihdalevvrdh/XK7W1ve3jVq21vXjbqlWrdcHt3oqyCAKCaMIWtoQshCyQnWRC9mSSycyc3x9J5gsSIMBMZhLO8/HgweQzn5nPe/LOvOfM+ZzPOUJKiaIoijK6aBwdgKIoimJ7qrgriqKMQqq4K4qijEKquCuKooxCqrgriqKMQqq4K4qijEJ2K+5CiMVCiGIhRKkQYp29jqMML5XX0UnldfQR9hjnLoTQAqeABUA1kAOsklIW2vxgyrBReR2dVF5HJ3u13GcApVLKcimlEfgQWGanYynDR+V1dFJ5HYVc7PS8UUDVeT9XAzddaufg4GAZGxuL0WikpKQEo9F42ScPCwvD09MTrVaLv78/QgjbRN3PbDbT1dVFV1cXra2tGAwGTCbTRfv5+/sTGhqKu7s7Ukrc3NzQaEb2aYwjR440SilDLnH3Ved17NixQz52V1cXUkqEELi4uODm5jbkxyqXZ8u8wtXnVrGPM2fO0NjYOGgBtFdxH+xgF/T/CCEeAx4DCAgIYP78+VgsFurq6mhqarrsk2dmZhIfH09kZCRhYWHMnTuX0NBQmwUvpaSyspIxY8ZQWlrKpk2b+MMf/oDBYLhgP51Ox4IFC/jhD39ISEgIFosFFxd7/UqHhxCi4nJ3D7LtknmNjY3l8OHDVzxmd3c3O3bswNvbm97eXvR6PXq9nh/84Ad4e3tfTfjKJVxvXvuf46pzq9hXRkbGJe+zVyWqBmLO+zkaqD1/Bynla8BrAJGRkRJAo9Hg7u5+xSfv6urCYDBQXFxMfHw8np6eNgscQAhBXFwcAOnp6aSmpvLFF19w+PBhawE3m80EBQURFxfH6dOnaW9vByAxMdGmsTiZq8prRkbGZU/o9PT0UFNTwzfffENdXZ21kHt6etLc3Ex+fj7Tpk3D1dXVpi9CucgV8wpXl1vF8exV3HOAJCHEOKAGuB944JJBuLjg7u7OqVOnrtglA+Dq6kpsbCwBAQGcOHGCW2+91WaBD6axsZEf/vCHHD16lH/+858kJCQQHBzMypUrAaivryc6OpoxY8bYNQ4ncFV5vRSLxUJDQwMffPABGzduJD8/H09PT1pbWwkNDaWhoYFbbrmFyspKHn74YebOnWvr16FcyCZ5VZyLXYq7lNIkhPj/gC8ALfCmlLLgUvv7+/tjNpvJyMjg4MGDV3z+jo4OqqqqOHfuHHPnzqWsrIzU1FTbvYBvCQgIQEpJe3s76enpeHh4AODh4UFiYiIxMTE3RPfB1eZ1MBaLhbKyMv7rv/6Le+65h7a2Npqbm2lubgbg9OnTAISGhhIdHU1HRwcWi2XEn8twZrbIq+J87NZBLKX8HPh8iPvS2dmJv78/3d3d1u1CCOvJ0oEhm0IIvL29Wbp0KcHBwaSkpNi9n9tkMnHs2DECAwNZsmQJM2fOxM3NjeDgYJufzHV2V5PXbz2Ozs5OysvL+fLLLwkMDCQrK4uOjo5B9z927BiJiYl89dVXTJgwgZiYGFXg7eha86o4L6c4+1dcXIxer8doNNLV1QX0FfHvfe97JCYmMnXqVHbv3o2HhwdhYWFMnz6dyZMn27yv/VIaGxvx8fHh1ltvZd68earIXCWDwcC+ffvYv38/tbW1bNu2jba2Nry9vampqRn0MXV1dbz00ktYLBZqa2t54403rN+YFEW5Mqco7iaTiYaGBuvPHh4eLF26FH9/fywWC8ePH+eee+5Bp9Ph6ek57CfYEhISeOaZZ9TQvGvQ0dHB5s2baWpqIicnh/DwcCorK7FYLJcdFdXY2Gi9nZeXx8mTJ9HpdEM64a4oipMU929bvXo1r732GtnZ2QQEBBAdHW2X8exDJYRQhf0anDt3jldeeQWz2YxGoyE8PBxXV1eSk5M5efLkkJ+nqamJHTt2kJeXx/33369yoShD4BTF3d/fn9/+9rfs3LmT5ORkFi5ciNls5uabb1ZdICNYdXU1O3fu5MyZM3R3d+Pj40NzczP19fVX9Ty1tbW8/PLLTJ8+nXvvvddO0SrK6OIUxR36+mVff/11goKC1LjmUcJkMrFz587rfh4pJRUVFTz00EM0NDQQFham+t8V5Qqcolk8duxYHn/8ccLCwkZdYZdSYjKZKCoqcnQoI97vfvc7li1bRmlpqXX0lKIog3OKlruLiwv+/v6ODsOmpJR0dXVRXl5OR0cHLi4u9Pb2jroPr+FksVhoa2vDYDDQ3NxMYGCgo0NSFKflFMV9NDEajVgsFoqKitizZw96vR6DwcCdd95JcXExEydOdHSII1poaChZWVl88sknPPPMM3h5eTk6JEVxSqq420hPTw8HDhygsLAQvV5PXFwcOTk5zJ49G5PJRHV1NQUFBSQkJGA0Gjlw4AATJkwgKirqhrsQ6nrk5eUxffp0UlJSaG5uVsVdUS5BFffrNNBF8NZbb3HmzBmOHTtGQEAA+/fvp6CggPb2dvLz8+nt7WX69OlkZmaSnZ3NwYMHuffee/Hy8lLdC5fg4eFBeHg4np6epKen4+npydGjR0lISGD16tU3wlw+inLNRkVx7+np4dixY0yePHlYW3Lnzp1jx44dSCkpKipiw4YNF+1TVfX/psneu3cv999/P0VFRfj4+GA0GqmsrOTxxx8ftphHku7ubioqKpg9ezZTp06lsrKSn/3sZyxcuHDUnaNRFFsbscVdSonRaKS5uZkdO3ZgMpnQ6/UsXboUrVZ7wVw09uLv709raytnz569aK73wbS0tNDS0gL0TVus0+kwGAwYjUZ1Yc4lLFy4kJ/97GcEBgai0WiYMmXKiJ8zX1GGw4h7l/T09CCE4M033+S2226jvLyc9evXc8stt+Dm5saCBQusiz10d3eTkZFhtwIvhCAtLY0XX3zxklMVR0ZGEhMTQ319PTqdDldXV9zd3amqqqKyspJ58+apPvd+CQkJhIeH09XVhZubG0lJScydO5ebbroJX19ftFqto0NUlBFjRBR3KSXd3d3WCai2bdvG+++/T1BQED4+PuTm5nLs2DEWLVrE+vXrrd0kjz32GEaj0S7zkbS1tVFWVkZubi4xMTHk5+cPul9XVxdr166lpqYGk8mEu7s7Pj4+PPnkk8THxzNmzBhVtPotXryY9vZ2UlNTcXV1JTAwkNtvv/2CvnWTyURFRQUBAQGMGTNGXcGsKJfg9MXdYrGwZ88epJRoNBqKiorYtm3bBV0cA1paWigqKmLs2LHExsZSXFxMcnKyTZfgG3D48GH27duHl5cXJpOJM2fODLpfTEzfAjenT59mzZo1REREkJSUpCbAGkR1dTVz5swhNTWVpKQkxo0bd0EXTGNjIzt27MBoNOLj48OiRYvw9fV1YMSK4rycvri3t7dz4MAB3njjDSZOnEhnZ+egi1VD3wk4IQQHDx4kMTGRiIgIKisrCQkJsXnXx0033cSXX35JU1MToaGhLFy4EKPRSHh4OHV1dXh4eNDZ2cm//uu/Ehsby7//+7+TmJiIt7e36oY5j7e3N7NmzaKxsZHk5GQWLFjAuHHj8PPzs+7T09ODXq/n+PHjHDlyhNLSUubNm8ehQ4eYNWuWGg6pKINw+uKu1WoJCwtj4sSJbNmy5bL75ubmkpubC0BpaSkxMTF0dXUxadIkm7eUXV1dmTNnDjU1NZSVleHm5sZ3v/tdXF1drf9uueUWUlNT8fDwUFemXsLtt9+Ou7s73/nOdxg7diwpKSkX5KqlpYW8vDyqqqo4cOAA2dnZHDt2jH379vGDH/yAiooK1qxZo7q2FOVbnL64+/j4sHjxYl5//fUhPyYwMJCVK1dSUVGBn58fBoPBpsW9u7ub2tpaOjs7sVgsnD59mgceeMD6LWHatGmMHTsWFxcX1Uq/DF9fX7y9vXn00UfR6XQXTOs8sBzf+++/z2233Ya3tzdardY6KqmxsZENGzbwyCOP0NTUREhIiCNfiqI4Hacv7lJKIiMjGTduHIcOHbro/oETagEBAdaTp2lpadx77724ubkRFRV1wVd8W/Dw8CA+Pp6YmBj27duH2Wymq6uL+++/nzFjxqiheoOIiIiwfntxd3ens7OTjRs3otFoSEtLu6Dl3draSlVVFc8//zwdHR20tLTQ2dlJS0sLU6ZMsc4F7+npSXNzM6dOncLPz0+dx1CU8zh1FbJYLJSUlPD3v//d2t3ybZMmTWLGjBl4eXnh5uZGeHg4d911FwkJCXZvNbu4uBAcHMzq1atxcXFRfb+XsWTJEsLDw/H19cXd3Z3w8HDGjRt3UYu7vLyc119/nQMHDvDVV19d9jmllPj5+aHX68nOziYzM1N9U1KUfk5b3A0GA6dOnaKlpYXQ0NALhrx5enpaL/pJTU3l5ptvZsqUKYwbNw5fX99hGx4nhGDChAnDcqyRzmKx4Ofnh8ViYfbs2ResgSulxGAw8M0333D06FGio6OHdFHYwLmO3NxcNBoNOp2OiIgIe78URRkRnLa4e3h4YDabqa2txWAwEBYWxtmzZ2lvb+eVV15hwYIF1n5YNzc3dYWnkwoPD8doNNLR0cGsWbOIjIwkMTHRer/FYiEnJ4e3334bjUaDi4sLNTU11NbWXvG5Q0NDOXv2LK6urpSWlrJlyxZWr16tvkEpCk5c3IUQJCcnU1NTw5w5cwgMDGTx4sV4eHjg4eFBY2MjkZGRjg5TuYwxY8bwne98h8DAQB5//HEiIyMv+FbV1dXFV199RWRkJB0dHRw/fpz8/HyEEFgslis+f21tLf/zP/8DQEhICOPHj2fv3r0sWbLEbq9JUUYKpy3u0DcG2s/Pj48//piIiAh0Oh1TpkwhJiZGnTwbAby8vPjud79LfHw8YWFh1u1ms5menh7y8vKIjIzkwIEDxMbGUlhYiJRyyKssnb+fl5cX06dPp7S0lLKyMhISEmz+ehRlJHHq4i6EIDo6mnvuuYdJkyYREBCgxjOPIL6+vqSlpV2w3qnRaKSkpITXXnsNs9lMbGwsBQUF6PV6zp07d83Hqq+vZ/v27bi6uiKl5PHHH8dgMODn56dOsio3JKcu7tA3mdS4ceNG9RwiUkqqq6sJCQkZVQs/+/j4WF9Pb28vtbW1ZGVl8Yc//IGCggKklLi7u2M0GjGbzdf1wW0wGPj73/9OdHQ0GRkZ/OlPf2LBggUEBAQQHx9vq5ekKCPGiKiYo7Wwd3V1UVtbS3l5Ofv27bvkzJIjXWdnJ1VVVWzbto3m5mbq6uowmUzW6wNMJpN1IfHrIaWkqqqKH//4x5jNZmpqaqyzgyrKjcbpW+6jjZSSjo4OsrKyOHPmDBMmTCA3N5f6+no8PT1ZsmSJtWuht7d3RI8CklKyefNm8vPziY2NpbOzk4CAALt9WLu5uaHRaPD09MTf3599+/YxdepUAgMDSUpKsssxFcVZqeI+THp6esjOzsZoNGIymdi1axfvvPMOvb29+Pj48MQTT1BQUEBmZiYGg4H9+/ezf/9+1q1bN2K7as6dO8eRI0fIzc3lueeeA/q6Z+zRkvby8uJ73/ue9QIpFxcXIiMjufvuu9W8PopNSClH1PmbG6K4m81mqqur8fHxISgoaFiPXV9fz5kzZ8jPzyc3N5ekpCQ8PDzIzs6mubkZ6Jurpq6ujkceeYTc3Fx27tyJv78/kZGRVFdXD8vVtvbQ1dVFRUWF9Xfe3t5u1+P5+PjQ3NxMQUEBTz/9NPHx8WoqCMUmOjo6OHToEOnp6SNmiccrfj8WQrwphGgQQuSfty1QCLFTCFHS/3/Aeff9XAhRKoQoFkIsslfgQ9HZ2Ul5eTmbN2/mk08+uWA90+GMobS0lPb2durq6sjJyaG1tfWCMfq+vr4EBQXx3//937z//vs0Njbi5+fHjh072Ldv35CHBl6N73//+4SGhjJx4kTrtqamJoAkW+VVq9USHh6Oq6sr3t7eNn8N/XHh6uqKj48PCxYsIDMzk7/85S8kJyffsIV9sNwC2pHwnnVGBoOBjRs30tLSQm5u7nWfGxouQ+n8/Aew+Fvb1gFfSimTgC/7f0YIkQrcD0zof8zLQohhH7vY3t7OwYMHaWpqoqysjL/+9a94eHiwefNmOjo6sFgsnD17dlhOtIWEhKDVaqmvr0er1bJx40b+8pe/sHfvXus+bW1tvPTSS2zYsIG//e1vnDhxgp6eHnx9fSktLbW28G1p7dq1bN++/YJtzz//PEC7rfJaX1/Pu+++y2effXZdwxwvRaPRMGfOHJ577jm+//3vExsby7Jly/Dx8bH5sUaSwXILRODE71lnVl5eTmVlJR988AEnTpygpqbG0SENyRWbNlLKr4UQY7+1eRkwv//228BXwFP92z+UUvYAp4UQpcAMYL+N4r0ss9lMfX09e/fu5aOPPmLnzp309vYyceJEzp49i6+vL19++SUBAQF88cUXpKamsmrVKruOxvH09CQlJQW9Xm+dJrijo+OiuAe2ubm5sWTJEhobG5k9ezb19fXo9XqbdyfNnTv3otWjPvvsM4CBKnzdeZVS2vWNEBcXx4QJE0hNTWX8+PGMHTt21I6suhqD5RYYQ19OwYnes87MbDZz6NAhXn31VQIDAxk/fjwFBQUkJCTg5+eHj4+PU5/PudbvrWFSyjoAKWWdEGJgHbso4MB5+1X3b7uIEOIx4DGA2NjYawyjb03NwsJCGhoaOHPmDL6+vnR0dFBZWUlXVxfQ118WHByMh4cHeXl5ZGRkEBwcTFtbG21tbRes0WkrUkpKS0vZsGEDBoMBDw+Pi8ZxCyGsJ2mklLi5ufGLX/yCxsZGbr75ZuLj40lOTrZOsGVv9fX1AL398V93Xu1h4Hc1c+ZM7rnnHiIiIliwYMEN2wVzFVyc5T07EnR3d3Pw4EFOnDhBeHg4UkqCg4ORUvLxxx/zwQcf8Otf/5rY2Fin/duzdVSDnfUbtMNYSvka8BpARkbGNXcq5+Xl8fHHH1NWVkZJSQk1NTUXFdGzZ8/ym9/8Bl9fX9rb2xFCcPPNN/PrX/+a1tZW/Pz8bN7iGxjyWFtby/79+ykqKiImJoaHH36Y1tZWPDw8CAkJobu7m5aWFtzd3bFYLNxzzz1oNBrr0D0nOZF6TXkVQtjkZIFOp+OBBx6go6ODmJgYsrOz+dGPfkRCQgIBAQFO++YaIYb9Pevs9Ho95eXl1NTU8MYbb9DW1kZraytjxoyhsrISi8WCr68vmZmZzJ07l3HjxjnL+/QC1/quqBdCRPS3ACKAhv7t1UDMeftFA1ee3o9rH2aUkpJCUlKS9UKZxsbGi/YZGKUx0O8bFBTE1q1bCQ4O5sEHHyQiIsLm48k1Gg3+/v5ERUWRn993LtrHxwedTkdOTg4JCQmkpKRQX19PcnIy6enp+Pj4DFsrfTBhYWG0tra6Atgqr7bg4eFBREQE1dXVxMXF4erqetG0BsoVmWz9nh2N2traePXVVwkJCSEkJITZs2fzyiuvANYBB1a5ubn09vYyY8YMJkyY4HSNjGttrm4C1vTfXgN8dt72+4UQ7kKIcUAScPHySd9iMpk4duwYR44cueqTnF5eXkRGRjJnzpwhf1VcuHAhS5cuRUrJiRMnLkqarXh7e9Pb22v9uaGhgeLiYsLCwpg0aRJms5lly5Zx2223ERIS4tDCDnDXXXcBDHTuX3debeXUqVNs376dxMREZsyYwWOPPaYK+9VrwYbv2dFGSsnx48d5++23mTx5MkeOHGHPnj2XPGdksVjYtWsXhw4doqio6JKLCTnSFT9qhBAf0HfyNFgIUQ38Gnge+FgI8TBQCdwLIKUsEEJ8DBQCJuCHUkrzlY5RXFzMfffdR1NTE1lZWaSmpl7Vi9DpdLz88suDLsMHEBMTw6xZs2hoaCA2NpbU1FS6urp46KGH0Gq1dlt/MygoiBkzZvDII4+g1+sZP348UVFRPPjgg9aVmxz1ab9q1Sq++uorGhsbiY6O5je/+Q3r1q3jxRdf9BNClGCDvF4PnU7HnDlzKCkpITk5maSkJFasWKGK+hAMllugDlhgq/fsaNPa2sp7773Hn//8Z6KiomhubiYgIACzefBfRUdHB8XFxXR1dXH48GHWr19Pb2+vU51gFfYYQ33VQfT3zQ6sqpOSkjKkx3V3d7Nnzx5aW1s5ePAgn3766WCjBEhKSuKXv/wlBQUFTJ48mZiYGCZOnIi/vz8FBQV4eHiQlJRkl36zb775hr179+Lq6sp9991HbGysU89sKYQ4IqXMsNFzXfMf14MPPsi//Mu/4Ovry/z58/H19bXbG6enpwc3Nzen7De1FVvmFfr63A8fPmyrp3MYKSWNjY384x//4IUXXhi0W/dKhBD86le/wmAwsGrVKiZOnDhsjbaMjAwOHz486B+u03QSaTQali1bxo4dO4iIiLjiVWBdXV1s2rQJrVZrHZ4UHx8/aHE/d+4cdXV1rFq1iuTkZNra2mhvb6e5uZkDBw4we/ZsLBaLXYru5MmTmThxImPGjBnVxcNWNBoNU6ZMIS0tjYCAAObOnWuX0UzQ1x1YWVlJdXU1EydOJDAw0C7HUZyTlJL6+nrKysrYvXv3NRV26FtLuaqqit7eXrKysvDx8blgtTFHcYri7u7uzkMPPcSTTz5JYWEhubm5zJ0797KP8fT0ZOrUqZw8eZKEhATy8vJobm4mLS0NKSVz5syhuLiY9PR0brrpJubNm4enpydGo5FNmzaxYcMGIiIiCAkJQQiBVqtFp9PZ/LWNlEuVHSUoKIg77riDI0eOEBUVhaenJw8//DC33XYbJpMJX19fmx9TSklbWxuvvPIKH374IT09Paxbt45Vq1aN6InalKtjNBp59tln2bdvHw0NDVd+wCX09vaSk5NDb28v7e3t6PV67rvvPoevr+wUxT06OpqHHnoId3f3gZN6VySEICIigu3bt9Pa2sqiRYtYvnw5zc3N5OTkoNPp+OUvf0lgYCDV1dVs3rwZk8lEWVkZWVlZfP3114SGhvLUU0/h7u7O7t27SUhIUG/uYRYZGUl6err1YrN58+YxdepU3Nzc7HKC2WKxsH37dj799FMMBgO5ubkEBQVx9uxZ6urqiIuLs/kxFedTW1vLiRMn+Prrr21yMvTEiRNA36Ltc+bMYevWrURHRzu0cecUxd3X15fZs2df9Vhzb29vfH19qa2tpaenh4iICKKioli0aBEuLi7WdTmLioooKChAo9FgMBjIysoC+uZ92bNnDy4uLjz55JOUlZXZpfWuXNqMGTNISEhAo9Gg0+lIT0+32xKKDQ0N9PT0sHfvXqKjo1m/fj3Q12338ssv4+Pjw4MPPqi+bY1iUkr0ej319fVs3brV5qNcBtYRqKqqYv78+UyfPt1h3bFOUdy1Wu01XUTk4uLC7bffjtFoZPr06URERFjvG0hiYWEhjY2N5OTkIIRAo9FYF1/u6elBo9HQ3d2NEMJuo2aUC+l0OkJCQggODqa3t5fU1FQmTJhAbGysXd4IJpOJ06dP8+mnn7Jt2zbrKIienh7rPmvXruXcuXM8/fTTPPvss6rAj1Ld3d2UlJTw5ptvsmvXLrsc44477sDLy4vJkyc79DybUxT36xEWFsZjjz026KX9MTExTJ06lV/84hfs2bPnosf6+vqi0+lISUnB29sbLy+v4Qr7hiWEYMmSJYSEhKDRaLjrrruIioqyy0iYgb71kpISDhw4wJtvvklJScmgw9uqq6vx9vZWS/KNUmazmZKSEkpKSnj55ZcHm1jNJoQQ5OTk4O3tTVpaml2OMVQjfpalgZOhg/Hw8LjsSAspJUajEU9PT5KTk1VxHwaJiYkEBgayePFi7rrrLlJSUuxS2C0WC7W1tbz11lts376d8vJynnrqqUtOwNbV1YWrq6v1pHtdXZ3NY1Ico7u7m6+++oqPPvqIn/70p3Yr7ND3IfLCCy9QVFTEwYMHLzlOfjiM+Jb7pRiNRqqrq3nnnXcoKyu74L7Y2Fja2tqIi4uju7ubwsJCJk+erPrbbczf35958+ZhNpvR6/WEh4fzt7/9jba2NrsupNHV1cXPf/5zTpw4QWdnJ0IIfH19aWxspK2tbdDHZGdnc+edd7J371727dvH2rVr8fPzs9s89MrwMBqN9Pb2snHjRlpbWy/oirMHjUbDqlWr8Pb25vPPP6epqYnly5fb9ZiXMqqKu5SS7u5ujh49SmFhIX5+fmi12otahhkZGcycOZPS0lI6OztpbW2loqKC5ORkp77AaKRxdXUlPj6eefPmUV5ejtFotG6zR2E3m83k5uaya9cu/vrXv15Vq6mqqoqXX34ZgKeeegpfX1/279/Pbbfdpq5PGKGMRiOHDh3i5MmTfPTRR9c8jv1qSCmxWCyYzWZSU1MdOgX1qCnura2t6PV66wVL+fn5PPDAA9TV1Vmn/oW+q2C7uro4deoUK1eupKGhgUmTJlnHuyu2093dTUZGBgaDgYyMDCZPnmy3C5IAcnJyyM7O5vTp09e1elVPTw96vZ5Tp04RFxenFtcegXp6emhoaCArK4tXXnllWAr7gPz8fFauXElUVBSZmZnDdtxvGzXFvaysjMOHD/Ppp5+i0+mIi4ujqKiIjo4OoqKiqKioIDExkbi4OKZMmUJKSgpxcXFkZmaq1rqdDHRppKWlER8fb5drCKSUNDc3U1VVxX/+53+SnJxMXl4eWq3WOirqam3cuBEpJRqNhpycHKKiotT5mBFkYL6X//u//6O1tXVY53vRaDTMnDmTadOmMWPGDIfWllFT3D08PHj77bfZt28f27ZtIzMzk/j4eJqbm2loaGD58uWMHz+eJ598Eikl3t7eTjXJz2jk6+tr18m+pJQUFxdTX1/Pjh072LFjB1988cV1P29lZSXZ2dmUl5ezcuVK6/z7apUn5yel5K233iIvL49PPvlkWFvsA1JTU0lPT3d4o3HUFPfAwEDGjh3Lvn37gL6vZY899hjl5eX09PSQkpLChAkTbvj1NYeTr6+vXQq72WymtraW2tpajh07htls5ujRozZ7fiklhw8fRqPR8OqrrzJ//nwWLlx4wXUUivPp7e0lNzeX8PBwfvvb3zqksENfQ9MZ5nZ3fAQ2Eh4ezu23305OTg4WiwWTyURPTw/Lly/H1dXV4Z+iNyJ7tHTNZjPvvfceW7ZsITw8nPb2ds6dO0dSUpJNWu3ns1gs7NixAx8fH1xcXFi1ahXQt6BDZ2cnUVGDrkanOEBnZydnz56ltLSUrVu30tLSYvdjarVapJSEhYWh1+uJiIggODgYV1dXOjo68PPzs3sMlzNqijvArFmzeOedd5g4cSLQN7mYKuqjh16vp729nT/+8Y+cOHHCup6qPUVHRxMcHGydk6ipqYnx48eTn5/PsmXL1FxETqC2tpZt27YREhLCmjVrMBqNdj+mRqPhV7/6Fb29vfT09JCamkplZSVjxoxh0aJFTjGEdlQV97FjxxIdHa360kcRKSVdXV0cPXqU48eP880331iXLRyOtQjCw8P5/PPP6e3txWQyERcXx4cffoher2fChAnodDo1ysqBqqqqrJPAPf3008NS2AECAgKYMGEC8fHxVFRU0N7ejk6nY9KkSU7T9TuqirsQQhX2UcRisdDY2MjmzZsxm83k5ORw5MiRYSnqA/bu3cu8efNoaWmhubmZQ4cOERISgru7O4cOHcLb21vNJOlAnZ2dREZGkp2dfV3T9g6Fm5sbISEhWCwW6wSFPj4+JCQkkJWVxfz5851qVNWoKu7K6GE2myksLOTdd99ly5YtlJSUYLFYhrWwQ9/1E5s2bUKj0ZCdnW1dyD0tLY2lS5fy2Wef8cQTT6hGhYOkpKQQGhpKS0sLS5YsYcaMGTQ3N/Pee+/ZfG3khIQEHn30UetEdwMtdD8/P5YsWeJ03+BUcVecjsFgYOfOndTU1GCxWEhISKCoqMihMX17zHxDQwM7d+4kPDycM2fOqAudHCgwMJBZs2bh4uJCa2srXl5edjmZ39XVxfTp05k6depFXS/OVthhFEwcpowe3d3dnDx5ks8++4wvvviCvLw89u/fz4EDBxwd2kXa29txcXFBCMHmzZupqalxdEg3NJ1Oxx133EFLSwt1dXUEBATg6elJcHDwdRVeV1dX/P398fT0ZMyYMZw4cYKjR486dEKwoVItd8XhpJRUVVXxH//xH2zduhXou07B3d2dzs7OYe+KGYrm5mZee+013NzcCA4OZsqUKURERKgLnRxECEFgYCBr167ljTfeYM6cORw4cICkpCQOHTrE2bNnr+l5Y2NjWbFiBVJKYmJicHNzw83NDZPJ5PQj8VRxVxyqra2NxsZGDh48SF5eHh0dHdb7ent7HRjZlRmNRoxGIz4+PjQ1NVFTU0NMTIyjw7phCSEIDQ3l1ltvpbCwELPZzNixY6moqLjm4u7u7o7RaKSlpYWamhqmT5/O5MmT7bZamC2p4q44hMVioa6ujnfffZfOzk5CQ0MJCAhwdFjXxGKxUFBQgNFoZObMmSQkJDg6pBuWh4cH8+fPt7awCwsLqaysHPI1EW5ublgsFoQQuLm50d7eTmdnJ8888wy+vr4EBgY6fYt9gCruyrDr7u4mJyeH7du3s2PHDgoKChwd0nVpaWnhhRdesA6LzMrKstt8OsrQzJo1i87OTo4ePYq/vz9Go5Hk5GRKS0tpb2+/aH9/f3+WLVtGdHQ0ubm5pKens3btWlpaWjAYDISGhjrN+PWhUsVdGVZVVVUUFxdjMBhIS0vjf//3fzEYDI4O67oMXDhjMBhoaWkhKytLzQPvYEIIbrnlFhoaGpg6dSqbNm3iwIEDdHd3D7r/lClTSEtL48svv2TixIn86Ec/Ijg42NraH4m5VMVdGRZms5n29nb27NnD9u3biYiIIDw8/II+9tEgKiqK2tpa6urqiIyMdHQ4NzQPDw+WLFmCVqulra2Nzz///JJdM21tbZjNZtatW8e4ceMIDg4GRmZRH6CKu2J3Z8+e5dFHHyU/P5/29nbrXOlms5nm5mZHh2dTra2tlJWVMXbsWCIiIkZ0cRgNAgMD0ev1uLi48MQTT7BlyxYqKysv2m9gJbaYmBhrYR/p1Lgtxa6amprYu3cvR48e5cyZM5w7d46mpiYaGxtHXWGHvr5bf39/ysvL2b9//zUvGKLYTkhICHfddReRkZFER0cPOtlbd3c3+fn57N69+5pH1jgbVdwVu+np6WH79u2YzWa7L0zsLCwWCxUVFRQXF5OdnU1VVZWjQ1KA+Ph4Fi9ezO9//3veeOONi65HSElJ4eTJk9TU1LB79+4RcZHSlVyxuAshYoQQe4QQRUKIAiHET/q3BwohdgohSvr/DzjvMT8XQpQKIYqFEIvs+QKUa1NVVUVmZiY6nY4JEybw0ksvDdyltVVeT506xbp16/jxj39MZ2envV6KUzl37hzffPMN77zzDv/4xz+GfSTQcOR1pJo6dSqRkZHk5+dz6623EhQUZL2vqKiIzz//nOeee46vv/56xFyFellSysv+AyKAaf23fYFTQCrwArCuf/s64Pf9t1OBXMAdGAeUAdrLHSM9PV0qw6u2tlYeOXJESillW1ubTEpKkgUFBRI4a6u8AvJG/hcUFCT//Oc/y6amJmmxWEZNXuUIfs+aTCaZnZ0tX3zxRTl37txB8xYXFyd///vfy+rqamkymRwd8mX152HQHF2x5S6lrJNSHu2/3Q4UAVHAMuDt/t3eBpb3314GfCil7JFSngZKgRlXOo4yvCIiIpg2bRrQtxyeTqcbmB9lDCqvNtHZ2UlJSQm7d+8etmOqvF6eVqvlpptuIjMzk/Dw8EH3sVgsBAYGkpeXN6KvwbiqPnchxFggDTgIhEkp66DvAwAI7d8tCji/o7G6f9u3n+sxIcRhIcRhvV5/DaErtnLmzBmOHTvGTTfdBOBiq7zaOewR4Z///CdZWVkUFxdjMpmG9di2zCuMnvesVqslJSWFe++9l6effppbbrnlgmkj9Ho9f/zjH9mwYQOBgYGDXvQ0Egy5uAshfIB/Aj+VUrZdbtdBtl00uFRK+ZqUMkNKmRESEjLUMBQb6+joYMWKFaxfv/5Kaz5edV5tFuQI1d3dTU1NDevXryc9PZ3CwsJhO7at8wqj6z3r5eXFnXfeyeOPP87y5cu59957rfcNzE66YcMGVqxYweHDh4f9g9kWhlTchRCu9BX2DVLKT/o31wshIvrvjwAGlkGpBs6fPSkaqLVNuIot9fb2smLFClavXs3dd989sNmk8mp7FouF8vLyYbkaV+V1aNzd3fHy8qKpqemSF9PV19dz5MgRjhw5MszRXb+hjJYRwN+BIinln867axOwpv/2GuCz87bfL4RwF0KMA5KAQ7YLWbEFKSUPP/wwOp2Of/u3fzv/rhZUXm3OYrFQW1tLdXW1XY+j8np1goKCeOKJJ4iNjeXWW29lxYoVLF++nNmzZ5OWlsa8efNwcXGhre1ynRXOaShXqN4MfBc4IYQ43r/taeB54GMhxMNAJXAvgJSyQAjxMVAImIAfSilH+Jii0Sc7O5t3332XSZMmMXXqVACeffZZgDpggcqrbRmNRj7//HPc3d3x8fEhIiLCLsdReb16UVFR/OQnP2HSpEls3bqVqKgoLBYLZrOZzs5OYmNjyczMdHSYV+2KxV1KmcXg/XIAt13iMb8DfncdcSl2NmfOnEvNs2GWUqq82phWq6W5uZnu7m62bt3KtGnTrKNabEnl9dp4e3szc+ZMTCYTe/fuZfbs2TQ3NyOlZOnSpbi4jLyZWkZexIoyAkkpqaurY8uWLYSFhdHb28vUqVPVyk1OYmChj7vvvpvGxkba2toYN24cU6ZMGbHTN6virijDwGKxcPr0aU6fPo1GoyE9PZ3y8nISExMdHZryLWvWrOH06dMkJiaOyBb7gJEbuaKMYCUlJWi1WmJjYwedyEpxHFdXVyIjI0d0YQc1cZiiOERRURFFRUW8+uqrI/YimdFKo9Fc6dqAEWFkfzQpyghksVjYtWsXu3btAmDmzJlkZGSo/nfFptRfk6I42MaNGzl37pyjw1BGGVXcFcXB/P39rStUKYqtqOKuKA72xRdf8MADD1BaWqoKvGIzqrgrioN5eHiwYMECPvnkE+rq6hwdjjJKqOKuKA5WX19PbW0tFRUVfPjhh44ORxkl1GgZRXGwY8eOcfz4cQBWr15NbW0tYWFhaLVaxwamjGiq5a4oTmBgabTAwEC2bNkyLFMDK6ObarkrduXj44OUkp6enhG54IEj1NXV0dvb6+gwlBFOtdwVu4mMjOSFF15g0aJF+Pv7OzqcEeHQoUMUFxdz7Ngxuru7HR2OMoKp4q7YTWhoKElJSQQGBqpuhiEyGAwkJSVx6NAh3n33XTU0UrlmqrgrdqPVaunt7SUgIACLxeLocEYEb29vpJQIIVi5ciV9C6EpytUTztAyEELogU6g0dGxDCKYGyuuOCmlTVY/Vnm9ZvaIzWZ5BRBCtAPFtno+G1J57ecUxR1ACHFYSpnh6Di+TcV1fZw1TmeNC5w7tgHOGqOzxgXDH5vqllEURRmFVHFXFEUZhZypuL/m6AAuQcV1fZw1TmeNC5w7tgHOGqOzxgXDHJvT9LkriqIotuNMLXdFURTFRhxe3IUQi4UQxUKIUiHEOgcc/00hRIMQIv+8bYFCiJ1CiJL+/wPOu+/n/bEWCyEW2TGuGCHEHiFEkRCiQAjxE2eJbShUXi8Zl8rr9R1f5XWoBiYscsQ/QAuUAfGAG5ALpA5zDHOBaUD+edteANb1314H/L7/dmp/jO7AuP7YtXaKKwKY1n/bFzjVf3yHx6byqvKq8ur8eXV0y30GUCqlLJdSGoEPgWXDGYCU8mug6VublwFv999+G1h+3vYPpZQ9UsrTQCl9r8EecdVJKY/2324HioAoZ4htCFReLx2Xyut1UHkdOkcX9yig6ryfq/u3OVqYlLIO+pIGhPZvd0i8QoixQBpw0NliuwRniuV8TvW7U3m1Gaf63TlLXh1d3AebOMOZh+8Me7xCCB/gn8BPpZRtl9t1kG2O+l06UyxDofI6NM4Uy1Dc0Hl1dHGvBmLO+zkaqHVQLOerF0JEAPT/39C/fVjjFUK40veHskFK+YkzxXYFzhTL+Zzid6fyanNO8btztrw6urjnAElCiHFCCDfgfmCTg2OCvhjW9N9eA3x23vb7hRDuQohxQBJwyB4BCCEE8HegSEr5J2eKbQhUXi9B5dUuHP67c8q8DueZ7kucZV5K35nlMuAXDjj+B0Ad0Evfp+nDQBDwJVDS/3/gefv/oj/WYmCJHeOaQ9/XtDzgeP+/pc4Qm8qryqvKq/PnVV2hqiiKMgo5ultGURRFsQNV3BVFUUYhVdwVRVFGIVXcFUVRRiFV3BVFUUYhVdwVRVFGIVXcFUVRRiFV3BVFUUah/x+Fk/N190T6rwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num = 2\n",
    "# plt.subplot(1, 3, 1)\n",
    "# narr = np.zeros((256, 256, 3))\n",
    "# narr[...,0] = im1[num, 0, ...]\n",
    "# narr[...,1] = im1[num, 1, ...]\n",
    "# narr[...,2] = im1[num, 2, ...]\n",
    "# plt.imshow(narr)\n",
    "# plt.subplot(1, 3, 2)\n",
    "# narr1 = np.zeros((256, 256, 3))\n",
    "# narr1[...,0] = im2[num, 0, ...]\n",
    "# narr1[...,1] = im2[num, 1, ...]\n",
    "# narr1[...,2] = im2[num, 2, ...]\n",
    "# plt.imshow(narr1)\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(tar[0], cmap = 'Greys')\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.imshow(tar[1], cmap = 'Greys')\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.imshow(tar[num], cmap = 'Greys')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cbf9defb-7e07-4f27-8d92-c957aa06530f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 1, 256, 256])\n"
     ]
    }
   ],
   "source": [
    "# plt.imshow(tar[num])\n",
    "result = model(im1.to('cuda'), im2.to('cuda'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cd4eb116-a664-4ddc-9493-c396b11f72af",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f86ea8a08b0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(result[0][0].cpu().detach().numpy(), cmap = 'Greys')\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.imshow(result[1][0].cpu().detach().numpy(), cmap = 'Greys')\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.imshow(result[num][0].cpu().detach().numpy(), cmap = 'Greys')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "8edea4fe-87b8-4e06-8f28-9c76de9f23f3",
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'torchinfo'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_1021/1357982964.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mtorchinfo\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msummary\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'torchinfo'"
     ]
    }
   ],
   "source": [
    "from torchinfo import summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06276dc3-8510-4303-b220-6664b71a2fb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "summary(model, [(1, 3, 256, 256), (1, 3, 256, 256)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db304448-4ab2-4bcf-a194-15011198d963",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "447eaa9a-f001-483c-8db0-389b1d797266",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}