MaskInpainting_I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matching the unmasked imgs with  masked imgs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '/Users/c.l.beothucus/Downloads/masked2/30000'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-46629c2d0ed0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmasked\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mdelete\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmasked_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mmasked\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0munmasked_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/c.l.beothucus/Downloads/masked2/30000'"
     ]
    }
   ],
   "source": [
    "unmasked_path = \"/Users/c.l.beothucus/Downloads/unmasked2/30000\"\n",
    "masked_path = \"/Users/c.l.beothucus/Downloads/masked2/30000\"\n",
    "masked=[]\n",
    "delete=[]\n",
    "for i in os.listdir(masked_path):\n",
    "    masked.append(i[:5])\n",
    "for i in os.listdir(unmasked_path):\n",
    "    if i[:5] not in masked:\n",
    "        delete.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in delete:\n",
    "    path = os.path.join(unmasked_path,i)\n",
    "    try:\n",
    "        os.remove(path)\n",
    "    except Exception as e:\n",
    "        print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "delete"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. process imgs to size 224\n",
    "2. MaskTheFace\n",
    "3. ps black-white imgs\n",
    "4. clean up black-white imgs to binary segmentation map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path=\"/Users/c.l.beothucus/Desktop/testing.jpg\"\n",
    "img = cv2.imread(path)\n",
    "img = cv2.resize(img,(224,224))\n",
    "cv2.imwrite(\"/Users/c.l.beothucus/Desktop/Elon Musk.jpg\",img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1\n",
    "path = \"/Users/c.l.beothucus/Downloads/unmasked2/30000\"\n",
    "for i in os.listdir(path):\n",
    "    try:\n",
    "        img = cv2.imread( os.path.join(path,i) )\n",
    "        img = cv2.resize(img,(224,224))\n",
    "        cv2.imwrite(\"/Users/c.l.beothucus/Downloads/unmasked_dataset2/30000/\"+str(i),img)\n",
    "    except Exception as e:\n",
    "        print(i)\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3 \n",
    "import pyautogui as gui\n",
    "gui.moveTo(300,300,duration=0.1)\n",
    "gui.click()\n",
    "\n",
    "for i in range(5):\n",
    "    for j in range(7):\n",
    "        gui.hotkey('command','+')\n",
    "\n",
    "    gui.moveTo(1290,205,duration=0.2) #copy\n",
    "    gui.click()\n",
    "    gui.moveTo(1234,384,duration=0.15) #play\n",
    "    gui.click()\n",
    "\n",
    "    gui.moveTo(700,700,duration=0.2)\n",
    "    gui.click()\n",
    "\n",
    "    gui.moveTo(1290,224,duration=0.2) #blackwhite\n",
    "    gui.click()\n",
    "    gui.moveTo(1234,384,duration=0.15) #play\n",
    "    gui.click()\n",
    "    gui.moveTo(1290,248,duration=0.15) #save\n",
    "    gui.click()\n",
    "    gui.moveTo(1234,384,duration=0.15) #play\n",
    "    gui.click()\n",
    "    gui.moveTo(1290,268,duration=0.15) #new\n",
    "    gui.click()\n",
    "    gui.moveTo(1234,384,duration=0.15) #play\n",
    "    gui.click()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/c.l.beothucus/Downloads/bluemask_binary/.DS_Store\n"
     ]
    }
   ],
   "source": [
    "#4\n",
    "path = \"/Users/c.l.beothucus/Downloads/bluemask_binary\"\n",
    "pathh = \"/Users/c.l.beothucus/Downloads/bluemask_binary_pros/\"\n",
    "for i in os.listdir(path):\n",
    "    img_path = os.path.join(path,i)\n",
    "    try:\n",
    "        img = cv2.imread(img_path,cv2.IMREAD_GRAYSCALE)\n",
    "        ret, imgg = cv2.threshold(img,225,255,cv2.THRESH_BINARY)\n",
    "        cv2.imwrite(pathh+str(i[:10])+\".png\", imgg)\n",
    "    except Exception as e:\n",
    "        print(img_path)\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## part 1: U-Net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7ff5f4ddeb50>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "from torchvision.utils import make_grid\n",
    "from tqdm.auto import tqdm\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import Dataset\n",
    "import glob\n",
    "from PIL import Image\n",
    "\n",
    "torch.manual_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageDataset(Dataset):\n",
    "    def __init__(self,root_masked,root_binary,transform=None):\n",
    "        self.transform = transform\n",
    "        self.files_masked = sorted(glob.glob(root_masked+\"/*.*\"))\n",
    "        self.files_binary = sorted(glob.glob(root_binary+\"/*.*\"))\n",
    "        \n",
    "    def __getitem__(self,index):\n",
    "        item_masked = self.transform(Image.open(self.files_masked[index%len(self.files_masked)]))\n",
    "        item_binary = self.transform(Image.open(self.files_binary[index%len(self.files_binary)]))\n",
    "        return (item_masked-0.5)*2,(item_binary-0.5)*2\n",
    "    \n",
    "    def __len__(self):\n",
    "        return min(len(self.files_masked),len(self.files_binary))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop(image,new_shape):\n",
    "    middle_height = image.shape[2]//2\n",
    "    middle_width = image.shape[3]//2\n",
    "    starting_height = middle_height-round(new_shape[2]/2)\n",
    "    final_height = starting_height+new_shape[2]\n",
    "    starting_width = middle_width-round(new_shape[3]/2)\n",
    "    final_width = starting_width+new_shape[3]\n",
    "    cropped_image = image[:,:,starting_height:final_height,starting_width:final_width]\n",
    "    return cropped_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContractingBlock(nn.Module):\n",
    "    def __init__(self,input_channels,use_dropout=False,use_in=True):\n",
    "        super(ContractingBlock,self).__init__()\n",
    "        self.conv = nn.Conv2d(input_channels,input_channels*2,kernel_size=3,padding=1)\n",
    "        self.activation = nn.LeakyReLU(0.2)\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "        if use_in:\n",
    "            self.insnorm = nn.InstanceNorm2d(input_channels*2)\n",
    "        self.use_in = use_in\n",
    "        if use_dropout:\n",
    "            self.dropout = nn.Dropout()\n",
    "        self.use_dropout = use_dropout\n",
    "    \n",
    "    def forward(self,x):\n",
    "        x = self.conv(x)\n",
    "        if self.use_in:\n",
    "            x = self.insnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.maxpool(x)\n",
    "        return x\n",
    "    \n",
    "class ExpandingBlock(nn.Module):\n",
    "    def __init__(self,input_channels,use_dropout=False,use_in=True):\n",
    "        super(ExpandingBlock,self).__init__()\n",
    "        self.tconv = nn.ConvTranspose2d(input_channels,input_channels//2,kernel_size=3,stride=2,padding=1,output_padding=1)\n",
    "        self.conv2 = nn.Conv2d(input_channels, input_channels // 2, kernel_size=3, padding=1)\n",
    "        if use_in:\n",
    "            self.insnorm = nn.InstanceNorm2d(input_channels//2)\n",
    "        self.use_in = use_in\n",
    "        if use_dropout:\n",
    "            self.dropout = nn.Dropout()\n",
    "        self.use_dropout = use_dropout\n",
    "        self.activation = nn.LeakyReLU(0.2)\n",
    "    \n",
    "    def forward(self,x,skip_x):\n",
    "        x = self.tconv(x)\n",
    "        skip_x = crop(skip_x,x.shape)\n",
    "        x = torch.cat([x,skip_x],axis=1)     #really need ???\n",
    "        x = self.conv2(x)\n",
    "        if self.use_in:\n",
    "            x = self.insnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        return x\n",
    "\n",
    "class FeatureMapBlock(nn.Module):\n",
    "    def __init__(self,input_channels,output_channels):\n",
    "        super(FeatureMapBlock,self).__init__()\n",
    "        self.conv = nn.Conv2d(input_channels,output_channels,kernel_size=1)\n",
    "    \n",
    "    def forward(self,x):\n",
    "        x = self.conv(x)\n",
    "        return x\n",
    "    \n",
    "class UNet(nn.Module):\n",
    "    def __init__(self,input_channels,output_channels,hidden_channels=32):\n",
    "        super(UNet,self).__init__()\n",
    "        self.upfeature = FeatureMapBlock(input_channels,hidden_channels)\n",
    "        self.contract1 = ContractingBlock(hidden_channels,use_in=False)\n",
    "        self.contract2 = ContractingBlock(hidden_channels*2)\n",
    "        self.contract3 = ContractingBlock(hidden_channels*4)\n",
    "        self.contract4 = ContractingBlock(hidden_channels*8)\n",
    "        self.contract5 = ContractingBlock(hidden_channels*16)\n",
    "        self.expand0 = ExpandingBlock(hidden_channels*32)\n",
    "        self.expand1 = ExpandingBlock(hidden_channels*16)\n",
    "        self.expand2 = ExpandingBlock(hidden_channels*8)\n",
    "        self.expand3 = ExpandingBlock(hidden_channels*4)\n",
    "        self.expand4 = ExpandingBlock(hidden_channels*2)\n",
    "        self.downfeature = FeatureMapBlock(hidden_channels,output_channels)\n",
    "        self.tanh = torch.nn.Tanh()\n",
    "    \n",
    "    def forward(self,x):\n",
    "        x0 = self.upfeature(x)\n",
    "        x1 = self.contract1(x0)\n",
    "        x2 = self.contract2(x1)\n",
    "        x3 = self.contract3(x2)\n",
    "        x4 = self.contract4(x3)    #x4:512\n",
    "        x5 = self.contract5(x4)    #x5:1024\n",
    "        x6 = self.expand0(x5,x4)\n",
    "        x7 = self.expand1(x6,x3)\n",
    "        x8 = self.expand2(x7,x2)\n",
    "        x9 = self.expand3(x8,x1)\n",
    "        x10 = self.expand4(x9,x0)\n",
    "        xn = self.downfeature(x10)\n",
    "        return self.tanh(xn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self,input_channels,hidden_channels=8):\n",
    "        super(Discriminator,self).__init__()\n",
    "        self.upfeature = FeatureMapBlock(input_channels,hidden_channels)\n",
    "        self.contract1 = ContractingBlock(hidden_channels,use_in=False)\n",
    "        self.contract2 = ContractingBlock(hidden_channels*2)\n",
    "        self.contract3 = ContractingBlock(hidden_channels*4)\n",
    "        self.contract4 = ContractingBlock(hidden_channels*8)\n",
    "        self.final = nn.Conv2d(hidden_channels*16,1,kernel_size=1)   #should change?\n",
    "        \n",
    "    def forward(self,x):      ##without concat with masked img\n",
    "        x0 = self.upfeature(x)\n",
    "        x1 = self.contract1(x0)\n",
    "        x2 = self.contract2(x1)\n",
    "        x3 = self.contract3(x2)\n",
    "        x4 = self.contract4(x3)\n",
    "        xn = self.final(x4)\n",
    "        return xn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "adv_criterion = nn.BCEWithLogitsLoss()\n",
    "recon_criterion = nn.L1Loss()\n",
    "lambda_recon = 200\n",
    "\n",
    "n_epochs=10\n",
    "input_dim = 3\n",
    "binary_dim = 1         # (-1,1,224,224)\n",
    "display_step = 1000\n",
    "batch_size = 4\n",
    "lr = 0.0002\n",
    "target_shape = 224\n",
    "device = 'cpu'\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor()\n",
    "])\n",
    "masked_root = \"/Users/c.l.beothucus/Downloads/11k-13k_masked\"\n",
    "binary_root = \"/Users/c.l.beothucus/Downloads/11k-13k_binary\"\n",
    "dataset = ImageDataset(masked_root,binary_root,transform=transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = UNet(input_dim,binary_dim).to(device)\n",
    "gen_opt = torch.optim.Adam(gen.parameters(),lr=lr)\n",
    "disc = Discriminator(binary_dim).to(device)\n",
    "disc_opt = torch.optim.Adam(disc.parameters(),lr=lr)\n",
    "\n",
    "def weights_init(m):\n",
    "    if isinstance(m,nn.Conv2d) or isinstance(m,nn.ConvTranspose2d):\n",
    "        torch.nn.init.normal_(m.weight,0.0,0.02)\n",
    "#     if isinstance(m,nn.InstanceNorm2d):\n",
    "#         torch.nn.init.normal_(m.weight,0.0,0.02)\n",
    "#         torch.nn.init.constant_(m.bias,0)\n",
    "\n",
    "pretrained = True\n",
    "if pretrained:\n",
    "    loaded_state = torch.load(\"/Users/c.l.beothucus/Downloads/bi_unet_42540.pth\",map_location=torch.device('cpu'))\n",
    "    gen.load_state_dict(loaded_state[\"gen\"])\n",
    "    gen_opt.load_state_dict(loaded_state[\"gen_opt\"])\n",
    "    disc.load_state_dict(loaded_state[\"disc\"])\n",
    "    disc_opt.load_state_dict(loaded_state[\"disc_opt\"])\n",
    "else:\n",
    "    gen = gen.apply(weights_init)\n",
    "    disc = disc.apply(weights_init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_gen_loss(gen,disc,binary,masked,adv_criterion,recon_criterion,lambda_recon):\n",
    "    fake = gen(masked)\n",
    "    pred = disc(fake)\n",
    "    adv_loss = adv_criterion(pred,torch.ones_like(pred))\n",
    "    recon_loss = recon_criterion(fake,binary)\n",
    "    gen_loss = adv_loss+(lambda_recon*recon_loss)\n",
    "    return gen_loss\n",
    "\n",
    "def get_disc_loss(disc,fake,binary,adv_criterion):\n",
    "    fake_pred = disc(fake.detach())\n",
    "    binary_pred = disc(binary)\n",
    "    fake_loss = adv_criterion(fake_pred,torch.zeros_like(fake_pred))\n",
    "    binary_loss = adv_criterion(binary_pred,torch.ones_like(binary_pred))\n",
    "    disc_loss = (fake_loss+binary_loss)/2\n",
    "    return disc_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_tensor_images(image_tensor, num_images=3, size=(3,224,224)):\n",
    "    image_tensor = (image_tensor + 1) / 2\n",
    "    image_shifted = image_tensor\n",
    "    image_unflat = image_shifted.detach().cpu().view(-1, *size)\n",
    "    image_grid = make_grid(image_unflat[:num_images], nrow=5)\n",
    "    plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(save_model=False):\n",
    "    mean_generator_loss = 0\n",
    "    mean_discriminator_loss = 0\n",
    "    dataloader = DataLoader(dataset,batch_size=1,shuffle = True)\n",
    "    cur_step = 0\n",
    "    \n",
    "    for epoch in range(n_epochs):\n",
    "        for masked,binary in tqdm(dataloader):\n",
    "            cur_batch_size=len(masked)\n",
    "            masked = masked.to(device)\n",
    "            binary = binary.to(device)\n",
    "            \n",
    "            disc_opt.zero_grad()      ##update discriminator\n",
    "            with torch.no_grad():\n",
    "                fake = gen(masked)\n",
    "            disc_loss = get_disc_loss(disc,fake,binary,adv_criterion)\n",
    "            disc_loss.backward(retain_graph=True)\n",
    "            disc_opt.step()\n",
    "            \n",
    "            gen_opt.zero_grad()\n",
    "            gen_loss = get_gen_loss(gen,disc,binary,masked,adv_criterion,recon_criterion,lambda_recon)\n",
    "            gen_loss.backward()\n",
    "            gen_opt.step()\n",
    "            \n",
    "            mean_discriminator_loss += disc_loss.item()/display_step\n",
    "            mean_generator_loss +=gen_loss.item()/display_step\n",
    "            \n",
    "            if cur_step%display_step == 0:\n",
    "                print(f\"Epoch {epoch}: Step {cur_step}: Generator (U-Net) loss: {mean_generator_loss}, Discriminator loss: {mean_discriminator_loss}\")\n",
    "                show_tensor_images(masked,size=(input_dim,target_shape,target_shape))\n",
    "                show_tensor_images(binary,size=(output_dim,target_shape,target_shape))\n",
    "                show_tensor_images(fake,size=(output_dim,target_shape,target_shape))\n",
    "                mean_generator_loss = 0\n",
    "                mean_discriminator_loss = 0\n",
    "                \n",
    "            cur_step += 1\n",
    "            \n",
    "        if save_model:\n",
    "            torch.save({'gen':gen.state_dict(),\n",
    "                       'gen_opt':gen_opt.state_dict(),\n",
    "                       'disc':disc.state_dict(),\n",
    "                       'disc_opt':disc_opt.state_dict()},f\"bi_unet_{cur_step}.pth\")\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f0b86a4f05de4a84bf11c801e192106b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2646 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: Step 0: Generator (U-Net) loss: 0.0167559814453125, Discriminator loss: 0.006258934736251831\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-375-2da0ffaf5447>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-217-e15f08687769>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m()\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m             \u001b[0mgen_opt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m             \u001b[0mgen_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_gen_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdisc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbinary\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmasked\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0madv_criterion\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrecon_criterion\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlambda_recon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m             \u001b[0mgen_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m             \u001b[0mgen_opt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-215-84e7334afb61>\u001b[0m in \u001b[0;36mget_gen_loss\u001b[0;34m(gen, disc, binary, masked, adv_criterion, recon_criterion, lambda_recon)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_gen_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdisc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbinary\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmasked\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0madv_criterion\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrecon_criterion\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlambda_recon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mfake\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmasked\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mpred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdisc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfake\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0madv_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madv_criterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mrecon_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecon_criterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfake\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbinary\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    887\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    888\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    890\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    891\u001b[0m                 \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-195-3d8f03ed9321>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     12\u001b[0m         \u001b[0mx0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupfeature\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m         \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontract1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m         \u001b[0mx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontract2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m         \u001b[0mx3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontract3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0mx4\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontract4\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    887\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    888\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    890\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    891\u001b[0m                 \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-194-5335191d9cc1>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdropout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmaxpool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    887\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    888\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    890\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    891\u001b[0m                 \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/modules/pooling.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    160\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m         return F.max_pool2d(input, self.kernel_size, self.stride,\n\u001b[0m\u001b[1;32m    163\u001b[0m                             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpadding\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdilation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mceil_mode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    164\u001b[0m                             self.return_indices)\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/_jit_internal.py\u001b[0m in \u001b[0;36mfn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    363\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mif_true\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    364\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 365\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mif_false\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    366\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    367\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mif_true\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mif_false\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36m_max_pool2d\u001b[0;34m(input, kernel_size, stride, padding, dilation, ceil_mode, return_indices)\u001b[0m\n\u001b[1;32m    657\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mstride\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    658\u001b[0m         \u001b[0mstride\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mannotate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 659\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkernel_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstride\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpadding\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdilation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mceil_mode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    660\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    661\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.utils import save_image\n",
    "root = \"/Users/c.l.beothucus/Downloads/masked_dataset2/30000\"\n",
    "leaves = \"/Users/c.l.beothucus/Downloads/binary_dataset2/30000/\"\n",
    "imgs_path =sorted(glob.glob(root+\"/*.*\"))\n",
    "for path in imgs_path:   \n",
    "    img = transform(Image.open(path))\n",
    "    img = img.detach().cpu().view(-1,*(3,224,224))\n",
    "    image_tensor = gen(img)\n",
    "    image_tensor = (image_tensor + 1) / 2\n",
    "    image_tensor = image_tensor.detach().cpu().view(-1, *(1,224,224))\n",
    "    save_image(image_tensor,leaves+path[-14:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Morphological Image Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "path = \"/Users/c.l.beothucus/Downloads/binary_dataset2/23000\"\n",
    "pathh = \"/Users/c.l.beothucus/Downloads/binary_dataset2(pros)/23000/\"\n",
    "kernel = np.ones((4,4),np.uint8)\n",
    "imgs_path = sorted(glob.glob(path+\"/*.*\"))\n",
    "\n",
    "for path in imgs_path:\n",
    "    img = cv2.imread(path,cv2.IMREAD_GRAYSCALE)\n",
    "    ret, imgg = cv2.threshold(img,220,255,cv2.THRESH_BINARY)\n",
    "    opening = cv2.morphologyEx(imgg, cv2.MORPH_OPEN, kernel)\n",
    "    cv2.imwrite(pathh+path[-14:],opening)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000, 850, 3)\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "path = \"/Users/c.l.beothucus/Desktop/anime/28250898_p0_master1200.jpg\"\n",
    "img = cv2.imread(path)#,cv2.IMREAD_GRAYSCALE)\n",
    "print(img.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = \"/Users/c.l.beothucus/Desktop/test2.jpg\"\n",
    "img = cv2.imread(path)\n",
    "img = cv2.resize(img,(224,224))\n",
    "cv2.imwrite(\"/Users/c.l.beothucus/Desktop/testing224.jpg\",img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.utils import save_image\n",
    "img_path = '/Users/c.l.beothucus/Downloads/test_imgs/dicky.jpg'\n",
    "img = transform(Image.open(img_path))\n",
    "img = img.detach().cpu().view(-1,*(img.shape))\n",
    "pre = gen(img)\n",
    "pre = (pre + 1) / 2\n",
    "pre = pre.detach().cpu().view(-1, *(1,224,224))\n",
    "save_image(pre,'/Users/c.l.beothucus/Downloads/test_imgs/white_dick.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "binary_path = \"/Users/c.l.beothucus/Desktop/bluwmask_binary.png\"\n",
    "kernel = np.ones((4,4),np.uint8)\n",
    "img = cv2.imread(binary_path,cv2.IMREAD_GRAYSCALE)\n",
    "ret, imgg = cv2.threshold(img,220,255,cv2.THRESH_BINARY)\n",
    "opening = cv2.morphologyEx(imgg, cv2.MORPH_OPEN, kernel)\n",
    "cv2.imwrite(\"/Users/c.l.beothucus/Desktop/blackwhite_test2.jpg\",imgg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}