wgan-gp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim, autograd\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# device agnostic code\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResBlock(nn.Module):\n",
    "\n",
    "    def __init__(self, n_filter=64):\n",
    "        super(ResBlock, self).__init__()\n",
    "\n",
    "        self.res_block = nn.Sequential(\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(n_filter, n_filter, 5, padding=2),#nn.Linear(DIM, DIM),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(n_filter, n_filter, 5, padding=2),#nn.Linear(DIM, DIM),\n",
    "        )\n",
    "\n",
    "    def forward(self, input):\n",
    "        output = self.res_block(input)\n",
    "        return input + (0.3*output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResGenerator(nn.Module):\n",
    "    def __init__(self, input_shape, n_filter=64, n_residual=7):\n",
    "        super(self.__class__, self).__init__()\n",
    "        \n",
    "        self.input_shape = input_shape\n",
    "        self.n_filter = n_filter\n",
    "        \n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(self.input_shape[1], n_filter, 9, padding=4),\n",
    "            nn.LeakyReLU()\n",
    "        )\n",
    "        \n",
    "        self.residual = nn.Sequential(\n",
    "            *[ResBlock() for _ in range(n_residual)]\n",
    "        )\n",
    "        \n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv2d(n_filter, n_filter, 3, padding=1),\n",
    "            nn.BatchNorm2d(n_filter),\n",
    "        )\n",
    "        \n",
    "        self.out = nn.Sequential(\n",
    "            nn.Conv2d(n_filter, self.input_shape[1], 3, padding=1),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "        \n",
    "    def forward(self, input):\n",
    "        conv1 = self.conv1(input)\n",
    "        res = self.residual(conv1)\n",
    "        conv2 = self.conv2(res)\n",
    "        out = self.out(conv2)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, input_shape, wasserstein=True, n_filter=64):\n",
    "        super(self.__class__, self).__init__()\n",
    "        \n",
    "        self.input_shape = input_shape\n",
    "        \n",
    "        self.wasserstein = wasserstein\n",
    "        self.n_filter = n_filter\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Conv2d(input_shape[1], n_filter, 3, padding=1),\n",
    "            \n",
    "            nn.Sequential(\n",
    "                *[\n",
    "                    nn.Sequential(\n",
    "                        nn.Conv2d(n_filter, n_filter, 3, padding=1),\n",
    "                        nn.BatchNorm2d(n_filter),\n",
    "                        nn.LeakyReLU()\n",
    "                    )\n",
    "\n",
    "                    for _ in range(7)\n",
    "                ]\n",
    "            )\n",
    "        )\n",
    "        \n",
    "        _, chan, x, y = input_shape\n",
    "        \n",
    "        self.linear = nn.Sequential(\n",
    "            nn.Linear(x * y * n_filter, 1024),\n",
    "            nn.Sequential(nn.Linear(1024, 1)) if wasserstein else nn.Sequential(nn.Linear(1024, 1), nn.Sigmoid())\n",
    "        )\n",
    "                \n",
    "    def forward(self, input):\n",
    "        _, _, x, y = self.input_shape\n",
    "        \n",
    "        hid = self.layers(input).view(-1, x * y * self.n_filter)\n",
    "        out = self.linear(hid)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define loss functions\n",
    "\n",
    "Can be found in [this paper](https://arxiv.org/abs/1704.00028)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_penalty(disc, real_data, generated_data, device=device):\n",
    "    batch_size = real_data.size(0)\n",
    "    \n",
    "    epsilon = torch.rand(batch_size, 1, device=device, requires_grad=True)\n",
    "    epsilon_exp = epsilon.expand(batch_size, real_data.nelement()/batch_size).contiguous().view(real_data.size())\n",
    "    \n",
    "    interpolates = epsilon_exp * real_data + (1 - epsilon_exp) * generated_data\n",
    "    \n",
    "    disc_interpolates = disc(interpolates)\n",
    "    \n",
    "    gradients = autograd.grad(outputs=disc_interpolates.mean(), \n",
    "                              inputs=interpolates, \n",
    "                              create_graph=True, retain_graph=True\n",
    "    )[0]\n",
    "    \n",
    "    gradients = gradients.view(gradients.size(0), -1)\n",
    "     \n",
    "    return ((gradients.norm(2, dim=1) - 1) ** 2).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wasserstein_loss(disc, real_data, fake_data, gp_lambda=10):\n",
    "    return (disc(fake_data) - disc(real_data)).mean() + gradient_penalty(disc, real_data, fake_data) * gp_lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cycle_loss(inputA, inputB, genA2B, genB2A):\n",
    "    cycleA = genB2A(genA2B(inputA))\n",
    "    cycleB = genA2B(genB2A(inputB))\n",
    "    \n",
    "    return ((cycleA - inputA).pow(2) + (cycleB - inputB).pow(2)).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_combined_loss(inputA, inputB, genA2B, genB2A, discA, discB):\n",
    "    return -discA(genB2A(inputB)).mean() - discB(genA2B(inputA)).mean() + cycle_loss(inputA, inputB, genA2B, genB2A)\n",
    "\n",
    "def discriminator_combined_loss(inputA, inputB, discA, discB, genA2B, genB2A):\n",
    "    genA = genB2A(inputB)\n",
    "    genB = genA2B(inputA)\n",
    "    \n",
    "    return wasserstein_loss(discA, inputA, genA) + wasserstein_loss(discB, inputB, genB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMG_SHAPE = [1, 1, 32, 32]\n",
    "N_RESIDUAL = 4\n",
    "ADAM_PARAMS = {\"lr\": 1e-4, \"betas\": (0.5, 0.9)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "build models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "generatorA2B = ResGenerator(IMG_SHAPE, n_residual=N_RESIDUAL).cuda()\n",
    "generatorB2A = ResGenerator(IMG_SHAPE, n_residual=N_RESIDUAL).cuda()\n",
    "\n",
    "discriminatorA = Discriminator(IMG_SHAPE).cuda()\n",
    "discriminatorB = Discriminator(IMG_SHAPE).cuda()\n",
    "\n",
    "adamGen = optim.Adam(list(generatorA2B.parameters()) + list(generatorB2A.parameters()), **ADAM_PARAMS)\n",
    "adamDisc = optim.Adam(list(discriminatorA.parameters()) + list(discriminatorB.parameters()), **ADAM_PARAMS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lib.pic2tensor import pics2array\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_dir = \"datasets/notMNIST_small/A/\"\n",
    "y_dir = \"datasets/notMNIST_small/B/\"\n",
    "\n",
    "# A's\n",
    "X = np.array(pics2array(x_dir, os.listdir(x_dir), IMG_SHAPE[2:]), dtype=\"float32\")[:, np.newaxis, :, :] / 255.\n",
    "# B's\n",
    "Y = np.array(pics2array(y_dir, os.listdir(y_dir), IMG_SHAPE[2:]), dtype=\"float32\")[:, np.newaxis, :, :] / 255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_batch(size=8, device=device):\n",
    "    xixes = np.random.randint(0, len(X) - 1, size=size)\n",
    "    yixes = np.random.randint(0, len(Y) - 1, size=size)\n",
    "    \n",
    "    return torch.tensor(X[xixes], device=device).to(device), torch.tensor(Y[yixes], device=device).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6b3666bc18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6b366e0588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6b365da7f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 37/5000 [01:33<3:29:24,  2.53s/it]"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "from IPython.display import clear_output\n",
    "\n",
    "BATCH_SIZE = 8\n",
    "N_EPOCHS = 5000\n",
    "N_DISC = 8\n",
    "DISPLAY_EPOCH = 20\n",
    "\n",
    "d_loss_hist = list()\n",
    "g_loss_hist = list()\n",
    "\n",
    "for epoch in tqdm(range(N_EPOCHS)):\n",
    "    \n",
    "    # train discriminator\n",
    "    for _ in range(N_DISC):\n",
    "        x, y = sample_batch(BATCH_SIZE)\n",
    "        d_loss = discriminator_combined_loss(x, y, discriminatorA, discriminatorB, generatorA2B, generatorB2A)\n",
    "                \n",
    "        d_loss.backward()\n",
    "        adamDisc.step()\n",
    "        adamDisc.zero_grad()\n",
    "    \n",
    "    d_loss_hist.append(d_loss)\n",
    "        \n",
    "    x, y = sample_batch(BATCH_SIZE)\n",
    "    g_loss = generator_combined_loss(x, y, generatorA2B, generatorB2A, discriminatorA, discriminatorB)\n",
    "    \n",
    "    g_loss_hist.append(g_loss)\n",
    "    \n",
    "    g_loss.backward()\n",
    "    adamGen.step()\n",
    "    adamGen.zero_grad()\n",
    "    \n",
    "    if epoch % DISPLAY_EPOCH == 0:\n",
    "        clear_output()\n",
    "        \n",
    "        plt.plot(d_loss_hist[:50])\n",
    "        plt.plot(g_loss_hist[:50])\n",
    "        plt.show()\n",
    "\n",
    "        \n",
    "        ix = np.random.randint(0, len(X))\n",
    "        expl = torch.tensor(X[ix:ix + 1]).to(device)\n",
    "\n",
    "        pic = generatorA2B(expl).data.cpu().numpy()[0, 0]\n",
    "\n",
    "        plt.imshow(X[ix, 0])\n",
    "        plt.colorbar()\n",
    "        plt.show()\n",
    "\n",
    "        plt.imshow(pic)\n",
    "        plt.colorbar()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6b440da4e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f6b363b96a0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATwAAAD8CAYAAADqmhgGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAHIhJREFUeJzt3X/0HXV95/HnK9/8Qn4mjbDZABLcnBZ6bIPnu+hZ9igC0bR/EDyrbejWjVvceHpkt7a1x6B7kGXlnNBdpf5BLVFS05YSqYqmbVqM/Fi2R0WijSTAYmJESZMmhkChhCb5fu97/5j56v01c+f++N5f83rkzLl35jNz53PnTt7fz8znM5+PIgIzszKYM+gMmJn1iwOemZWGA56ZlYYDnpmVhgOemZWGA56ZlYYDnpmVhgOemZWGA56ZlcbcbjaWtBr4FDABfDYiNuatP3/itDht7lnNE3Me+Hjdzx1runzfq0syt5k4MpGZNr1Q2Wnzs/OhrDxWsrexPsj+OUvn1IvHmH7lla6OyDvedno8f2y60LrffuLEAxGxupv99VPHAU/SBHAnsAo4ADwuaVtEPJW1zWlzz+Lf/ev/2DxxKvsA37X9vqbL13z3NzK3OevOszPTXlgxLzPt5eXZ0WviZPPzaOJ49vmVGSSByDst/Z+4uDE9VnnnR8xpfmI994d3dL3f549N860HLiy07sTSvdmljiHUzSXt5cC+iNgfESeBrcCa3mTLzAYlgErBf6Omm0vaZcBzVfMHgDd1lx0zG7QgOBXFLmlHTTcBr1mBu6GcLWk9sB5g4cSZXezOzPplFEtvRXQT8A4AF1TNnw8crF8pIjYBmwDOXnCe+6IyG3JBMD2m3cZ1cw/vcWCFpOWS5gNrgW29yZaZDVKFKDSNmo5LeBExJelG4AGSZimbI+LJ3I0qFeKV423v6/y5ZzRd/huv/0bmNn959K2ZaXPPz/7alTOz713E8eZNXTSVuQnKuTKI7JYzndfgZp2DY1qT2Xcd/h/Pq63v5DerZJw7uedNQQFMj2AwK6KrdngRsR3Y3qO8mNmQGMXSWxFdBTwzGz8BnBrTe3gOeGZWIwhf0ppZSQRMj2e8c8Azs1rJkxbjyQHPzOqI6TGt1u9vwJuuEP/8SvO0edkP9GdZufCHmWl//dKrmWlzX23ezAVA83MeqXm1ebNFTWc3Z8xrlpJ7m2Sij9cU43luj44ha0qUVFqM50nhEp6Z1Uja4TngmVlJVFzCM7MycAnPzEojENNjOvqDA56ZNfAlbQ9EBJWTp5qmqYNHWc6ZcyIzTa9mp809kb0v5dSOZlam5VTs5j40nndO5XU60OtzsdM89lqnFdMj3plC1jkyqLa/gTiZ17PFCHMJz8xqJA2PfUlrZiXhSgszK4UIMR3jWcIbz29lZl2poEJTEZJWS3pG0j5JG5qk3yFpVzp9T9KLVWnTVWld96juEp6Z1UgqLXoTGoqMXx0Rv121/n8FLqv6iFcjYmVPMoNLeGZWZ6bSoshUQLvjV18P3Nv9t2iu/yW8yGhvMd3+OJivyWsPcqp58xfIb0Yyd1524qmsmvpOmkXQamT5nM/stWG5Pz0b+RiW79brNiaz/L2me9f2qfD41ZJeBywHHqpavFDSTmAK2BgRX+4mM76kNbMabT5psSQNSDM2pUOzzig0fnVqLfCFiJpRwC+MiIOSLgYekrQ7Ir5fNHP1HPDMrEGl+CXG0YiYzEkvNH51ai3wgeoFEXEwfd0v6RGS+3sdBzzfwzOzGknnAXMKTQUUGr9a0s8Ci4BvVC1bJGlB+n4JcAXwVP227XAJz8xqBOJUjx4tyxq/WtKtwM6ImAl+1wNbI2qeMb0EuEtShaRwtrG6drcTDnhmViOCnjY8bjZ+dUTcXDd/S5Ptvg68oWcZwQHPzBoUb1Q8aroKeJKeBV4GpoGpFjcvExm9okSl/Xr7ibxmHVNTmWlzprL3NWdOB+0H8jbJScvrSWVMR8mzERD0toQ3THpRwntbRBztweeY2ZBwB6BmVgqB3AFohgC+KimAu+oaHJrZCEqGaRzPslC33+qKtBX0ucAOSf8vIh6tXkHSemA9wEJe0+XuzGz2je9A3F1dqFe1gj4C3E/yoHD9OpsiYjIiJuexoJvdmVkfBMmTFkWmUdNxjiWdLunMmffA24E9vcqYmQ3OdFrKazWNmm4uac8D7pc08zl/HhF/25NcFZQbrXMGBVJOE5g5c3JGz+mxju8Ld9g7i1kRERrJ0lsRHQe8iNgP/GIP82JmQyCptPCoZWZWCuM7poUDnpnVSCotRu/+XBEOeGbWwE9amFkp+EkLMyuVggP0jJzxDXh5va/0uOlGXq8nHTdVGpI/sGP6h75jub/1mIiAUxUHPDMrgeSS1gHPzEpiFJ+iKGI8w7iZdWymWUqRqQhJqyU9I2mfpA1N0t8r6ceSdqXT+6rS1knam07ruv1uLuGZWZ3eXdJKmgDuBFaRDNn4uKRtTQbj+XxE3Fi37WLgY8AkSRz+drrtC53mxyU8M2tQSce1aDUVcDmwLyL2R8RJYCuwpmA23gHsiIhjaZDbAazu6AulhqeEF/17aD+PRuDWRd6VRCfZd01scbnHfjZq6wcgqaXt2bO0y4DnquYPAG9qst5/kPQW4HvAb0fEcxnbLusmMy7hmVmNmYbHBe/hLZG0s2paX/dxzUJ9/Z+GvwQuiohfAL4GbGlj27YMTwnPzIZGG8M0Hm0xWuEB4IKq+fOBg9UrRMTzVbOfAW6v2vbKum0fKZqxZlzCM7MaPa6lfRxYIWm5pPnAWmBb9QqSllbNXgs8nb5/AHi7pEWSFpF0MvxAN9/NJTwza9CrWtqImJJ0I0mgmgA2R8STkm4FdkbENuC/SboWmAKOAe9Ntz0m6X+SBE2AWyPiWDf5ccAzsxoRYqqHT1pExHZge92ym6ve3wTclLHtZmBzr/LigGdmDdxbyqjpYzOXjpsqmA0hdwBqZqXigGdmpeAOQM2sVNpohzdSHPDMrEYETLkDUDMrC1/SmlkpjPM9vJblVkmbJR2RtKdq2WJJO9JO+Xakj31YuxTZk9kARajQNGqKXKh/jsY+qDYAD0bECuDBdN7MxkQP+8MbKi0DXkQ8SvJ8W7U1/LQLly3AdT3Ol5kNSERvu3gfJp3ewzsvIg4BRMQhSef2ME9mNlBi2rW0nUk7BFwPsJDXzPbuzKwHRvH+XBGdhvHDM31Ypa9HslaMiE0RMRkRk/NY0OHuzKxfej1q2TDpNOBtA2aGTFsHfKU32TGzgYvkPl6RadS0vKSVdC9JN8tLJB0gGTZtI3CfpBuAHwHvns1MDotwc5Fao/cH/qdm4afsda85gyxAjWINbBEtA15EXJ+RdHWP82JmQyBcaWFmZTKKl6tFOOCZWQPX0ppZKSQVEr17tEzSaknPSNonqeGpLEm/I+kpSU9IelDS66rSpiXtSqdt9du2yyU8M2vQqyYnkiaAO4FVJOPMPi5pW0Q8VbXa3wOTEXFc0m8Cvw/8apr2akSs7ElmcAnPzJroYbOUy4F9EbE/Ik4CW0keTa3aVzwcEcfT2W+SDLg9K1zCq6MhaXoyNLdQhiUfvZb3vYbjFBiYQFSK19IukbSzan5TRGyqml8GPFc1fwB4U87n3QD8TdX8wvTzp4CNEfHlohlrxgHPzBq0EfOPRsRkTnqzPy1NP17SrwOTwFurFl8YEQclXQw8JGl3RHy/ePZqOeCZWa3oaS3tAeCCqvnzgYP1K0m6Bvgo8NaIOPGTrEQcTF/3S3oEuAzoOOD5Hp6ZNYqCU2uPAyskLZc0H1hL8mjqT0i6DLgLuDYijlQtXyRpQfp+CXAFUF3Z0TaX8MysQa9KeBExJelG4AFgAtgcEU9KuhXYGRHbgP8FnAH8hSSAH0XEtcAlwF2SKiSFs411tbttc8AzsxoBVCq9q62KiO3A9rplN1e9vyZju68Db+hZRnDAM7N6wRA1E+gtB7xZNqbnjY05P0trZuXhgGdm5TCaQzAW4YBnZo1cwjOzUgiIHtbSDhMHPDNrwgHPRljuLZnxPLetG76kNbPScMAzs1Jww2MzKxM3PDaz8nAtrZmVxZB0/N1zDnhmVqt4X3cjp2UHoJI2SzoiaU/Vslsk/UPV8Gm/PLvZtKJCzScbXh39ZsqZupaRoTE4sYr0ePw5YHWT5XdExMp02t4k3cxGVe96PB4qLS9pI+JRSRfNflbMbGhUBp2B2dHNmBY3piOFb5a0qGc5MrPBmmmHV9JL2mY+DbweWAkcAj6RtaKk9ZJ2Stp5ihNZq5nZEFEUmwp9lrRa0jOS9kna0CR9gaTPp+mPVV9RSropXf6MpHd0+706CngRcTgipiOiAnyGZHTxrHU3RcRkREzOY0Gn+TSzfurRPTxJE8CdwC8BlwLXS7q0brUbgBci4t8AdwC3p9teSjLK2c+T1CP8Yfp5Heso4ElaWjX7TmBP1rpmVmqXA/siYn9EnAS2Amvq1lkDbEnffwG4WsnwZWuArRFxIiJ+AOwjp3BVRMtKC0n3AlcCSyQdAD4GXClpJUmMfxZ4fzeZsDbl3ToZwZqzodPn45t5aZizr9n+mXvY8HgZ8FzV/AHgTVnrpMM6/hPwM+nyb9Ztu6ybzBSppb2+yeK7u9mpmQ2xoJ1Hy5ZI2lk1vykiNlXNN/ug+nCatU6RbdviJy3MrFHxsHI0IiZz0g8AF1TNnw8czFjngKS5wNnAsYLbtqWbZilmNqZ6WEv7OLBC0nJJ80kqIbbVrbMNWJe+fxfwUEREunxtWou7HFgBfKub7+USnpk16tE9vPSe3I3AA8AEsDkinpR0K7AzIraR3CL7U0n7SEp2a9Ntn5R0H/AUMAV8ICKmu8mPA56ZNephrUj66On2umU3V73/F+DdGdveBtzWq7w44JlZjXYaFY8aB7xRNKYn49AYhePbQVOWtrgDUDMrC5fwzKw8HPDMrBR8D8/MSsUBz8zKQu4A1MxstLmEN4rcW8pYGcqOg8f0PHLAM7NarrQws1JxwDOz0nDAM7MyEONbS+uAZ2a1fA9vBCmnxc0w1oq1Y0xPRqs10NrbMT3HxjfgmVnnHPDMrCx8SWtm5TGmAc+PlplZrUhqaYtM3ZC0WNIOSXvT10VN1lkp6RuSnpT0hKRfrUr7nKQfSNqVTitb7dMBz8waRcGpOxuAByNiBfBgOl/vOPCfIuLngdXAH0g6pyr99yJiZTrtarVDBzwza9DDYRrzrAG2pO+3ANfVrxAR34uIven7g8AR4LWd7rBlwJN0gaSHJT2dFit/K13esjg6bhRqOpl1Y5aCSXf6U8I7LyIOAaSv5+atLOlyYD7w/arFt6WXundIWtBqh0VKeFPA70bEJcCbgQ9IupRixVEzGzVFg10S8JZI2lk1ra/+KElfk7SnybSmnSxJWgr8KfCfI2Lm7uFNwM8B/xZYDHy41ee0rKVNI+9MFH5Z0tPAMpLi6JXpaluAR4rs0MyGm2irhHk0IiazEiPimsz9SIclLY2IQ2lAO5Kx3lnAXwP/PSK+WfXZh9K3JyT9MfChVplt6x6epIuAy4DHaLM4amajo0/38LYB69L364CvNORDmg/cD/xJRPxFXdrS9FUk9//2tNph4YAn6Qzgi8AHI+KlNrZbP1PcPcWJopuZ2SD15x7eRmCVpL3AqnQeSZOSPpuu8yvAW4D3Nml+co+k3cBuYAnw8VY7LNTwWNI8kmB3T0R8KV1cqDgaEZuATQBnafGgb8WaWRF9+J8aEc8DVzdZvhN4X/r+z4A/y9j+qnb3WaSWVsDdwNMR8cmqpJbFUTMbQQUvZwdek9yBIiW8K4D3ALslzTTs+whJ8fM+STcAPwLe3VVO8no3ydBpQ+9QdlOScDMTGwVZp2mvTt8RDGZFFKml/TuyD2NDcdTMRp87ADWz0hjFy9UiHPDMrFZvamCHkgOemTVywDOzMmjzSYuR4oBnZg1UGc+IN9IBbzrvN5mT0/RkosMdZuwv769hv1u5ZOXFrW3qdPj/uZ8ln9zzajZ37Ht4ZlYmvqQ1s/JwwDOzsnAJz8zKwwHPzEoh/GiZmZWE2+ENqdw/Qnk9ouQ1Wcn7oTs4CQbWtKAdeRkZ9eYsPf7NOjZETZcKyf2PMLpGOuCZ2exwCc/MysENj82sTMa10qL9bobNbOypUmzqah/SYkk7JO1NXxdlrDddNYDPtqrlyyU9lm7/+XSEs1wOeGZWK0gqLYpM3dkAPBgRK4AH0/lmXo2Ilel0bdXy24E70u1fAG5otcOhuaRVTs1plpORE68nsnsIyOs8IHdMi0pG2gjUcg5TBweZxvS+Uadyf5esY9WjY9inSos1wJXp+y3AI8CHi2yYDi52FfBrVdvfAnw6bzuX8MysUfFxaZfMjDudTuvb2Mt5EXEIIH09N2O9helnf1PSdemynwFejIipdP4AsKzVDoemhGdmw6HNhsdHI2Iy87OkrwH/qknSR9vI0oURcVDSxcBD6eDbLzVZr2WuHfDMrFZEzzoAjYhrstIkHZa0NCIOSVoKHMn4jIPp635JjwCXAV8EzpE0Ny3lnQ8cbJUfX9KaWaPil7Td2AasS9+vA75Sv4KkRZIWpO+XkIyT/VREBPAw8K687es54JlZA0WxqUsbgVWS9gKr0nkkTUr6bLrOJcBOSd8lCXAbI+KpNO3DwO9I2kdyT+/uVjv0Ja2Z1QqgD2NaRMTzwNVNlu8E3pe+/zrwhozt9wOXt7PPlgFP0gXAn5DceKwAmyLiU5JuAf4L8ON01Y9ExPaWe8x6qD+nGUmW45Gdfc3NTpuel13fX8lqekJ/W58PzbOMw5KPHhua4zusxvT4FCnhTQG/GxHfkXQm8G1JO9K0OyLif89e9sxsEMb1D0LLgJe2j5lpK/OypKcp0N7FzEbXuA7T2FalhaSLSKqEH0sX3SjpCUmbs56DM7MRU7SGdgRjYuGAJ+kMkrYvH4yIl0ge4Xg9sJKkBPiJjO3Wz7TCPsWJHmTZzGZT0vA4Ck2jplDAkzSPJNjdExFfAoiIwxExHREV4DNk1JZExKaImIyIyXks6FW+zWw2VQpOI6ZlwEsf0r0beDoiPlm1fGnVau8E9vQ+e2Y2CONawitSS3sF8B5gt6Rd6bKPANdLWklyJf8s8P5Ce1TzGKsOmqW8WDktO3Fe9ler5DRLmZ7KzkdfO0XstAeWTsZwaH+T0Tcb/1c7PJCZNaKDGg9lRO/PFVGklvbvaP5Ttm5zZ2YjqHfP0g4bP2lhZo1G8HK1CAc8M6vlgbjNrFRcwjOz0hjPeOeAZ2aNVBnPa9r+Bjwps/lJXu8mWf5x6pzMtDgtu5HzdM5gbpXp7LYFc3LSMvMxG20+xvSvb8eG5XgMSz66FYxko+IiXMIzsxpiNBsVF+GAZ2aNHPDMrDTGNOB5TAszqzVzD2+WOw+QtFjSDkl709eGLuYkvU3SrqrpX2bGppX0OUk/qEpb2WqfDnhm1kCVSqGpSxuAByNiBfBgOl8jIh6OiJURsRK4CjgOfLVqld+bSY+IXfXb13PAM7M6kVzSFpm6swbYkr7fAlzXYv13AX8TEcc73WFf7+FJQlm9mJy2sO3P++GJJZlplTOyP296Yc4gPlPZfwOyUiKvo5ecZimR9+emj12YzErTmX7Kyf8ojM0wdMc/6Nc9vPPSISRIB+M+t8X6a4FP1i27TdLNpCXEiMjtZdiVFmbWqPjV6hJJO6vmN0XEppkZSV8jGfGw3kfbyU7a/+YbgAeqFt8E/CMwH9hEMk7trXmf44BnZg3aaId3NCImsxIj4prMfUiHJS1NS3dLgSM5+/kV4P6IOFX12YfStyck/THwoVaZ9T08M2vUn3t424B16ft1wFdy1r0euLd6wUyv62mv7NdRoNd1BzwzqxUB05ViU3c2Aqsk7QVWpfNImpT02ZmV0tESLwD+T93290jaDewGlgAfb7VDX9KaWaM+VFpExPPA1U2W7wTeVzX/LE3Gwo6Iq9rdpwOemTUa0yct+hvw5ghlND/R6a/J3OzET+9T1th7PLsW++TZ2V2i5PWWwsmcq/yMcyC/eUnOiZPXZKXHA8IMXdOHPun19+64mcsoxY8APKaFmZVDQIxn/1AOeGZWK+hFhcRQcsAzs0a+h2dmpeGAZ2bl0JNGxUOpZcCTtBB4FFiQrv+FiPiYpOXAVmAx8B3gPRFxMvfDJibQ2Wc1TZpacmbmZgemmj8PvOtwQ9Ocnzj97JyvllNzN+fV7J4ANJ2xPOfciJydabqzGtxOagrzKiuHpQZ3FB70nxUZP0DkVO1mHaue/JQBjOkgPkWetDgBXBURvwisBFZLejNwO3BH2pfVC8ANs5dNM+ur/jxa1nctA14k/jmdnZdOQdIZ3xfS5UX6sjKzkdC3R8v6rtCztJImJO0i6c1gB/B94MWImEpXOUCTRz/MbAQFRFQKTaOmUKVFREwDKyWdA9wPXNJstWbbSloPrAdYODf7Pp2ZDZExfdKird5SIuJF4BHgzcA5kmYC5vnAwYxtNkXEZERMzp/IfnzMzIZIWe/hSXptWrJD0mnANcDTwMMkfcxD676szGxURCS1tEWmEVPkknYpsEXSBEmAvC8i/krSU8BWSR8H/h64u9UHVRbM5ZWffW3TtBPnZDcH+dSP39Z0+T+9cHrmNtMXZX/eiXOy/zLFnOy06dOaL68s6Owv3bA0B+lYr/M/AgWGWek8ICstZ2dZHVb07JwawdJbES0DXkQ8AVzWZPl+4PLZyJSZDVIQ0xmNTkecn7Qws1ruHsrMSmUEm5wU4YBnZjUCCJfwzKwUwh2AmlmJjGulhaKP1c+Sfgz8MJ1dAhzt286zOR+1nI9ao5aP10VE87ZfBUn623R/RRyNiNXd7K+f+hrwanYs7cwbsdz5cD6cj+HLx6jzQNxmVhoOeGZWGoMMeJsGuO9qzkct56OW8zFGBnYPz8ys33xJa2alMZCAJ2m1pGck7ZO0YRB5SPPxrKTdknZJ2tnH/W6WdETSnqpliyXtkLQ3fV00oHzcIukf0mOyS9Iv9yEfF0h6WNLTkp6U9Fvp8r4ek5x89PWYSFoo6VuSvpvm43+ky5dLeiw9Hp+XNH828zGWIqKvEzBB0kX8xcB84LvApf3OR5qXZ4ElA9jvW4A3Anuqlv0+sCF9vwG4fUD5uAX4UJ+Px1Lgjen7M4HvAZf2+5jk5KOvx4Sk460z0vfzgMdIOt29D1ibLv8j4Df7+TuNwzSIEt7lwL6I2B/JsI5bgTUDyMfARMSjwLG6xWtIBkOCPg2KlJGPvouIQxHxnfT9yyQdzC6jz8ckJx99FQkPnDULBhHwlgHPVc0PcgCgAL4q6dvp2BuDdF5EHILkPx5w7gDzcqOkJ9JL3lm/tK4m6SKS/hcfY4DHpC4f0Odj4oGzZscgAl6zPlkHVVV8RUS8Efgl4AOS3jKgfAyTTwOvJxmD+BDwiX7tWNIZwBeBD0bES/3ab4F89P2YRMR0RKwkGS/mctoYOMuyDSLgHQAuqJrPHABotkXEwfT1CMlobIPswfmwpKUA6euRQWQiIg6n/9kqwGfo0zGRNI8kyNwTEV9KF/f9mDTLx6COSbrvtgfOsmyDCHiPAyvSGqf5wFpgW78zIel0SWfOvAfeDuzJ32pWbSMZDAkGOCjSTIBJvZM+HBNJIhkT5emI+GRVUl+PSVY++n1MPHDW7BlIw+O0Wv8PSGpsN0fEbQPIw8UkpTpIusn6837lQ9K9wJUkPVIcBj4GfJmkFu5C4EfAuyNiVisUMvJxJcmlW5DUYr9/5j7aLObj3wP/F9gNzHTE9hGS+2d9OyY5+biePh4TSb9AUilRPXDWrek5uxVYTDJw1q9HxInZysc48pMWZlYaftLCzErDAc/MSsMBz8xKwwHPzErDAc/MSsMBz8xKwwHPzErDAc/MSuP/A4t72A0bYM1mAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6b3640d080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ix = np.random.randint(0, len(X))\n",
    "expl = torch.tensor(Y[ix:ix + 1]).to(device)\n",
    "\n",
    "pic = generatorA2B(expl).data.cpu().numpy()[0, 0]\n",
    "\n",
    "plt.imshow(Y[ix, 0])\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "\n",
    "plt.imshow(pic)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot()"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}