CycleGAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DeepCPunk\n",
    "\n",
    "Este proyecto surge de la curiosidad por saber como será el futuro distópico que nos espera, lleno de neones, aires contaminados y alta tecnología.\n",
    "\n",
    "\n",
    "<img src='images_notebook/cyberpunkScaled.jpg'>\n",
    "\n",
    "\n",
    "Dado que no sé nada de edición de imágenes tuve que buscar una solución distinta. No sé editar imágenes pero sé algo sobre las GANs... Solo tenía que hacer un set de datos de ciudades actuales, edificios normales, lo que vemos día a día... Por otro lado necesitamos tener una referencia de cómo creemos que será el futuro. Gracias a que es un género de moda hoy en día podemos encontrar cientos de fotos con la estética Cyberpunk en un momento.\n",
    "\n",
    "Tras tener el data set simplemente tenía que decirle a la IA que quiero que me transforme las fotos de ciudades normales a ciudades futurísticas. Así que os voy a enseñar el proceso.\n",
    "\n",
    "Todo el código de este notebook está basado en https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CycleGAN\n",
    "\n",
    "En este notebook vamos a aprender en profundidad qué es una Cycle-Consistent Adversarial Nerwork (traducido en español sería algo así como \"Red Adversarial Consistente en Ciclo\").\n",
    "\n",
    "Este tipo de red nos sirve para hacer **Traducción de Imagen a Imagen**. Transformamos una imagen(X) en otro tipo de imagen(Y), es decir, transformamos imágenes de un dominio a otro. Por ejemplo, una imagen en blanco y negro(X) a una foto de color(Y).\n",
    "\n",
    "Una de las grandes ventajas de este tipo de redes es que no necesitan tener datos emparejados(a cada X le corresponde una Y concreta). Tener datos emparejados supone un problema, son más difíciles de generar y necesitas más cantidad. En nuestro caso con DeepCPunk tendríamos que editar cada foto de ciudad y transformarla en un estilo Cyber Punk lo cual requeriría mucho tiempo o dinero.\n",
    "\n",
    "¿Qué tenemos en vez de datos emparejados? Tenemos dos dominios de imágenes cada dominio con un estilo o características similares.\n",
    "\n",
    "El dataset empleado tiene imágenes en el dominio de Ciudad(fotos de calles de ciudades sin editar con luz normal, ya sean día, noche, con lluvia, etc...). En el dominio tenemos imágenes con estilo Cyber Punk (colores neon, con zonas muy oscuras o luces muy saturadas...).\n",
    "\n",
    "\n",
    "Hoy vamos a conseguir que nuestra a red aprenda qué convierte una imagen en Cyber Punk(sacando las características de este estilo) y viceversa.\n",
    "\n",
    "La red va \"buscando\" qué transformaciones aplicar a una imagen para tranformarla en el tipo de imagen deseado.\n",
    "\n",
    "![teaser.jpg](attachment:teaser.jpg)\n",
    "\n",
    "Podéis visualizar [este video](https://www.youtube.com/watch?v=ysEjAqnHp64) para una explicación en profundidad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una CycleGAN se compone de dos Generadores y dos Discriminadores.\n",
    "\n",
    "- Generador: se encarga de sintetizar fotos.\n",
    "- Discriminador: se encarga de evaluar las imágenes generadas, diferenciando entre las reales y las sintéticas.\n",
    "\n",
    "Ambos evolucionan durante el entrenamiento. El objetivo del generador es \"engañar\" al Discriminador por lo que va aprendiendo a generar mejor las fotos del dominio objetivo. Por otro lado el objetivo del Discriminador es aprender a distinguir entre imágenes sintéticas y reales.\n",
    "\n",
    "![cycle_img.png](attachment:cycle_img.png)\n",
    "\n",
    "Dy hace que G transforme la entrada X en una salida indistinguible del dominio Y y viceversa para Dx y F.\n",
    "La consistencia en ciclo evalua la capacidad de revertir un cambio en una imagen generada, la salida de G pasada por F debe ser similar a la imagen inicial. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generador\n",
    "\n",
    "Cycle-GAN se compone de **dos generadores** (y dos discriminadores que veremos posteriormente en detalle)\n",
    "\n",
    "Nuestro Generador va a estar basado en un tipo de red llamada **autoencoder**. Este tipo de red tiene dos partes:\n",
    "- **Codificador**: toma los datos más importantes de la imagen(aprende una representación).\n",
    "- **Transformador**: extrae las carácterísticas que conformarán la imagen final.\n",
    "- **Decodificador**: crea una nueva imagen con los datos codificados.\n",
    "\n",
    "![encoder-decoder.png](attachment:encoder-decoder.png)\n",
    "\n",
    "![Gen.jpg](attachment:Gen.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear el Discriminador primero debemos crear una clase para ayudarnos a crear los bloques residuales destinados a crear la parte del transformador.\n",
    "\n",
    "![bloque_residual.png](attachment:bloque_residual.png)\n",
    "\n",
    "Los bloques residuales han demostrado ser una [mejora significativa en las redes convolucionales](https://arxiv.org/pdf/1512.03385.pdf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.nn import init\n",
    "import torch.nn as nn\n",
    "import functools\n",
    "import random\n",
    "import itertools\n",
    "\n",
    "class ResnetBlock(nn.Module):\n",
    "    \"\"\"Define a Resnet block\"\"\"\n",
    "\n",
    "    def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):\n",
    "        \"\"\"Inicializa un bloque Resnet\n",
    "        Un bloque ResNet es un bloque convolucional con conexiones saltadas\n",
    "        Construimos el bloque convolucional con build_conv_block() e implementamos\n",
    "        las conexiones saltadas en forward().\n",
    "        \n",
    "        Paper original de Resnet https://arxiv.org/pdf/1512.03385.pdf\n",
    "        \"\"\"\n",
    "        super(ResnetBlock, self).__init__()\n",
    "        self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)\n",
    "\n",
    "    def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias):\n",
    "        \"\"\"COnstruye un bloque convolucional.\n",
    "\n",
    "        Parameters:\n",
    "            dim (int)           -- nº de canales en la capa de conv.\n",
    "            padding_type (str)  -- nombre de la capa de padding: reflect | replicate | zero\n",
    "            norm_layer          -- capa de normalización\n",
    "            use_dropout (bool)  -- si usa capas dropouts.\n",
    "            use_bias (bool)     -- si la capa conv usa bias o no\n",
    "\n",
    "        Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))\n",
    "        \"\"\"\n",
    "        conv_block = []\n",
    "        p = 0\n",
    "        if padding_type == 'reflect':\n",
    "            conv_block += [nn.ReflectionPad2d(1)]\n",
    "        elif padding_type == 'replicate':\n",
    "            conv_block += [nn.ReplicationPad2d(1)]\n",
    "        elif padding_type == 'zero':\n",
    "            p = 1\n",
    "        else:\n",
    "            raise NotImplementedError('padding [%s] is not implemented' % padding_type)\n",
    "\n",
    "        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim), nn.ReLU(True)]\n",
    "        if use_dropout:\n",
    "            conv_block += [nn.Dropout(0.5)]\n",
    "\n",
    "        p = 0\n",
    "        if padding_type == 'reflect':\n",
    "            conv_block += [nn.ReflectionPad2d(1)]\n",
    "        elif padding_type == 'replicate':\n",
    "            conv_block += [nn.ReplicationPad2d(1)]\n",
    "        elif padding_type == 'zero':\n",
    "            p = 1\n",
    "        else:\n",
    "            raise NotImplementedError('padding [%s] is not implemented' % padding_type)\n",
    "        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim)]\n",
    "\n",
    "        return nn.Sequential(*conv_block)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"Forward function (con conexiones salteadas)\"\"\"\n",
    "        out = x + self.conv_block(x)  # add skip connections\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clase para definir el Generador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResnetGenerator(nn.Module):\n",
    "    \"\"\"Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations.\n",
    "\n",
    "    We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_nc, output_nc, ngf=72, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=8, padding_type='reflect'):\n",
    "        \"\"\"Construct a Resnet-based generator\n",
    "\n",
    "        Parameters:\n",
    "            input_nc (int)      -- Nº de canales en las imágenes de entrada\n",
    "            output_nc (int)     -- Nº de canales en las imágenes de salida\n",
    "            ngf (int)           -- Nº de filtros en la última capa convolucional (last conv layer)\n",
    "            norm_layer          -- normalization layer\n",
    "            use_dropout (bool)  -- if use dropout layers\n",
    "            n_blocks (int)      -- the number of ResNet blocks\n",
    "            padding_type (str)  -- the name of padding layer in conv layers: reflect | replicate | zero\n",
    "        \"\"\"\n",
    "        assert(n_blocks >= 0)\n",
    "        super(ResnetGenerator, self).__init__()\n",
    "        if type(norm_layer) == functools.partial:\n",
    "            use_bias = norm_layer.func == nn.InstanceNorm2d\n",
    "        else:\n",
    "            use_bias = norm_layer == nn.InstanceNorm2d\n",
    "\n",
    "        model = [nn.ReflectionPad2d(3),\n",
    "                 nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),\n",
    "                 norm_layer(ngf),\n",
    "                 nn.ReLU(True)]\n",
    "\n",
    "        n_downsampling = 3\n",
    "        for i in range(n_downsampling):  # add downsampling layers\n",
    "            mult = 2 ** i\n",
    "            model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),\n",
    "                      norm_layer(ngf * mult * 2),\n",
    "                      nn.ReLU(True)]\n",
    "\n",
    "        mult = 2 ** n_downsampling\n",
    "        for i in range(n_blocks):       # add ResNet blocks\n",
    "\n",
    "            model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]\n",
    "\n",
    "        for i in range(n_downsampling):  # add upsampling layers\n",
    "            mult = 2 ** (n_downsampling - i)\n",
    "            model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\n",
    "                                         kernel_size=3, stride=2,\n",
    "                                         padding=1, output_padding=1,\n",
    "                                         bias=use_bias),\n",
    "                      norm_layer(int(ngf * mult / 2)),\n",
    "                      nn.ReLU(True)]\n",
    "        model += [nn.ReflectionPad2d(3)]\n",
    "        model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\n",
    "        model += [nn.Tanh()] # A causa de esta activación debemos reescalar las imágenes en [-1, 1]\n",
    "\n",
    "        self.model = nn.Sequential(*model)\n",
    "\n",
    "    def forward(self, input):\n",
    "        \"\"\"Standard forward\"\"\"\n",
    "        return self.model(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inicialización de pesos\n",
    "\n",
    "La siguiente función auxiliar será usada para inicializar los pesos de la Red.\n",
    "Lo cual es una buena práctica a realizar en el Deep Learnig. \n",
    "\n",
    "Los pesos son los vectores que intervienen en las operaciones de las redes neuronales y configuran los distintos resultados.\n",
    "\n",
    "La inicialización se realiza de tal forma que hará mas fácil la retropropagación(backpropagation) de los errores en la red. Por lo que la inicialización de los pesos usando una función en vez de forma aleatoria **acelera el proceso de entrenamiento** de la red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_weights(net, init_type='normal', init_gain=0.02):\n",
    "    \"\"\"Initialize network weights.\n",
    "\n",
    "    Parameters:\n",
    "        net (network)   -- network a inicializar\n",
    "        init_type (str) -- nombre del método de inicialización: normal | xavier | kaiming | orthogonal\n",
    "        init_gain (float)    -- scaling factor for normal, xavier and orthogonal.\n",
    "\n",
    "    Se usa 'normal' en los papeles originales de pix2pix y CycleGAN. Pero xavier y kaiming podrían\n",
    "    funcionar mejor para algunas aplicaciones.\n",
    "    \"\"\"\n",
    "    def init_func(m):  # define the initialization function\n",
    "        classname = m.__class__.__name__\n",
    "        if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\n",
    "            if init_type == 'normal':\n",
    "                init.normal_(m.weight.data, 0.0, init_gain)\n",
    "            elif init_type == 'xavier':\n",
    "                init.xavier_normal_(m.weight.data, gain=init_gain)\n",
    "            elif init_type == 'kaiming':\n",
    "                init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')\n",
    "            elif init_type == 'orthogonal':\n",
    "                init.orthogonal_(m.weight.data, gain=init_gain)\n",
    "            else:\n",
    "                raise NotImplementedError('initialization method [%s] is not implemented' % init_type)\n",
    "            if hasattr(m, 'bias') and m.bias is not None:\n",
    "                init.constant_(m.bias.data, 0.0)\n",
    "        elif classname.find('BatchNorm2d') != -1:  # BatchNorm Layer's weight is not a matrix; only normal distribution applies.\n",
    "            init.normal_(m.weight.data, 1.0, init_gain)\n",
    "            init.constant_(m.bias.data, 0.0)\n",
    "\n",
    "    print('initialize network with %s' % init_type)\n",
    "    net.apply(init_func)  # apply the initialization function <init_func>\n",
    "\n",
    "\n",
    "def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[]):\n",
    "    \"\"\"Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights\n",
    "    Parameters:\n",
    "        net (network)      -- the network to be initialized\n",
    "        init_type (str)    -- the name of an initialization method: normal | xavier | kaiming | orthogonal\n",
    "        gain (float)       -- scaling factor for normal, xavier and orthogonal.\n",
    "        gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2\n",
    "\n",
    "    Return an initialized network.\n",
    "    \"\"\"\n",
    "    if len(gpu_ids) > 0:\n",
    "        assert(torch.cuda.is_available())\n",
    "        net.to(gpu_ids[0])\n",
    "        net = torch.nn.DataParallel(net, gpu_ids)  # multi-GPUs\n",
    "    init_weights(net, init_type, init_gain=init_gain)\n",
    "    return net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Image Pool\n",
    "\n",
    "Calcular el error para cada una de las imágenes generadas es costoso computacionalmente. Por lo que el uso de un buffer de imágenes previamente generadas acelera del entrenamiento.\n",
    "\n",
    "Si cada vez que calculamos el error usamos una imágen distinta no se tendría una referencia constante de \"lo correcto\", entonces nuestro objetivo de optimización variaría mucho.\n",
    "\n",
    "Estrategia sacada de aquí https://arxiv.org/pdf/1612.07828.pdf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImagePool():\n",
    "    \"\"\"\n",
    "    Esta clase implementa un buffer de imágenes que almacena imagenes generadas previamente\n",
    "\n",
    "    Este buffer nos permite actualizar los discriminadores usando un historial de imágenes\n",
    "    generadas en vez de las generadas por los generadores más recientes\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, pool_size):\n",
    "        \"\"\"Inicializa la clase ImagePool\n",
    "\n",
    "        Parameters:\n",
    "            pool_size (int) -- the size of image buffer, if pool_size=0, no buffer will be created\n",
    "        \"\"\"\n",
    "        self.pool_size = pool_size\n",
    "        if self.pool_size > 0:  # create an empty pool\n",
    "            self.num_imgs = 0\n",
    "            self.images = []\n",
    "\n",
    "    def query(self, images):\n",
    "        \"\"\"Devuelve una imagen from the pool.\n",
    "\n",
    "        Parameters:\n",
    "            images: the latest generated images from the generator\n",
    "\n",
    "        Returns images from the buffer.\n",
    "\n",
    "        50/100, el buffer devolverá imágenes de entrada.\n",
    "        50/100, el buffer devolverá imágenes ya almacenadas en el buffer,\n",
    "        e insertará la imagen actual en el buffer.\n",
    "        \"\"\"\n",
    "        if self.pool_size == 0:  # if the buffer size is 0, do nothing\n",
    "            return images\n",
    "        return_images = []\n",
    "        for image in images:\n",
    "            image = torch.unsqueeze(image.data, 0)\n",
    "            if self.num_imgs < self.pool_size:   # if the buffer is not full; keep inserting current images to the buffer\n",
    "                self.num_imgs = self.num_imgs + 1\n",
    "                self.images.append(image)\n",
    "                return_images.append(image)\n",
    "            else:\n",
    "                p = random.uniform(0, 1)\n",
    "                if p > 0.5:  # by 50% chance, the buffer will return a previously stored image, and insert the current image into the buffer\n",
    "                    random_id = random.randint(0, self.pool_size - 1)  # randint is inclusive\n",
    "                    tmp = self.images[random_id].clone()\n",
    "                    self.images[random_id] = image\n",
    "                    return_images.append(tmp)\n",
    "                else:       # by another 50% chance, the buffer will return the current image\n",
    "                    return_images.append(image)\n",
    "        return_images = torch.cat(return_images, 0)   # collect all the images and return\n",
    "        return return_images\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discriminador\n",
    "\n",
    "El discriminador es la parte de la red que determina cómo de bien lo está haciendo el generador.\n",
    "\n",
    "Usamos un discriminador PatchGAN. Se caracteriza por no tener una salida binaria sobre la autenticidad de la foto (falsa o real), determina la autenticidad de la imagen por zonas(parches)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NLayerDiscriminator(nn.Module):\n",
    "    \"\"\"Defines a PatchGAN discriminator\"\"\"\n",
    "\n",
    "    def __init__(self, input_nc, ndf=64, n_layers=4, norm_layer=nn.BatchNorm2d):\n",
    "        \"\"\"Construct a PatchGAN discriminator\n",
    "\n",
    "        Parameters:\n",
    "            input_nc (int)  -- nº canales en las imágenes de entrada\n",
    "            ndf (int)       -- nº filtros en la última capa conv\n",
    "            n_layers (int)  -- nº conv layers en el discriminador\n",
    "            norm_layer      -- normalization layer\n",
    "        \"\"\"\n",
    "        super(NLayerDiscriminator, self).__init__()\n",
    "        if type(norm_layer) == functools.partial:  # no need to use bias as BatchNorm2d has affine parameters\n",
    "            use_bias = norm_layer.func == nn.InstanceNorm2d\n",
    "        else:\n",
    "            use_bias = norm_layer == nn.InstanceNorm2d\n",
    "\n",
    "        kw = 4\n",
    "        padw = 1\n",
    "        sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)]\n",
    "        nf_mult = 1\n",
    "        nf_mult_prev = 1\n",
    "        for n in range(1, n_layers):  # gradually increase the number of filters\n",
    "            nf_mult_prev = nf_mult\n",
    "            nf_mult = min(2 ** n, 8)\n",
    "            sequence += [\n",
    "                nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias),\n",
    "                norm_layer(ndf * nf_mult),\n",
    "                nn.LeakyReLU(0.2, True)\n",
    "            ]\n",
    "\n",
    "        nf_mult_prev = nf_mult\n",
    "        nf_mult = min(2 ** n_layers, 8)\n",
    "        sequence += [\n",
    "            nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias),\n",
    "            norm_layer(ndf * nf_mult),\n",
    "            nn.LeakyReLU(0.2, True)\n",
    "        ]\n",
    "\n",
    "        sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)]  # output 1 channel prediction map\n",
    "        self.model = nn.Sequential(*sequence)\n",
    "\n",
    "    def forward(self, input):\n",
    "        \"\"\"Standard forward.\"\"\"\n",
    "        return self.model(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pérdidas\n",
    "\n",
    "La función de abajo usa la pérdida logarítmica.\n",
    "Si el discriminador lo hace bien tanto diferenciando sintéticas como reales resultara en un valor bajo de pérdida.\n",
    "\n",
    "![LossGAN.png](attachment:LossGAN.png)\n",
    "\n",
    "<img src=\"images_notebook/Log_loss_graph.png\" width=\"400\">\n",
    "\n",
    "Lcyc evalúa con pérdida [L1](https://pytorch.org/docs/stable/nn.html#torch.nn.L1Loss) (mide la variación de la original y la que se transforma al dominio de la original en cada pixel)\n",
    "\n",
    "\n",
    "![LossCycle.png](attachment:LossCycle.png)\n",
    "\n",
    "Así que la pérdida final resulta en la pérdida de ambos generadores + la pérdida del ciclo:\n",
    "![LossFullObj.png](attachment:LossFullObj.png)\n",
    "\n",
    "La optimización que haremos será para minimizar el error en el caso de los generadores(crear mejores imágenes y hacer bien el ciclo) y maximizarlo para los discriminadores(que no distingan las imágenes sinŧeticas de las reales)\n",
    "\n",
    "![solve.png](attachment:solve.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GANLoss(nn.Module):\n",
    "    \"\"\"Define different GAN objectives.\n",
    "\n",
    "    La clase GANLoss abstrae la necesidad de crear un tensor de objetivo\n",
    "    que tenga el mismo tamaño que la entrada.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):\n",
    "        \"\"\" Initialize the GANLoss class.\n",
    "\n",
    "        Parameters:\n",
    "            gan_mode (str) - - tipo de objetivo de la GAN. It currently supports vanilla, lsgan, and wgangp.\n",
    "            target_real_label (bool) - - etiqueta de una imagen verdadera\n",
    "            target_fake_label (bool) - - etiqueta de una imagen falsa\n",
    "\n",
    "        Note: Do not use sigmoid as the last layer of Discriminator.\n",
    "        LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.\n",
    "        \"\"\"\n",
    "        super(GANLoss, self).__init__()\n",
    "        self.register_buffer('real_label', torch.tensor(target_real_label))\n",
    "        self.register_buffer('fake_label', torch.tensor(target_fake_label))\n",
    "        self.gan_mode = gan_mode\n",
    "        if gan_mode == 'lsgan':\n",
    "            self.loss = nn.MSELoss()\n",
    "        elif gan_mode == 'vanilla':\n",
    "            self.loss = nn.BCEWithLogitsLoss()\n",
    "        elif gan_mode in ['wgangp']:\n",
    "            self.loss = None\n",
    "        else:\n",
    "            raise NotImplementedError('gan mode %s not implemented' % gan_mode)\n",
    "\n",
    "    def get_target_tensor(self, prediction, target_is_real):\n",
    "        \"\"\"Crea un tensor etiqueta con la misma dimensión de la entrada\n",
    "\n",
    "        Parameters:\n",
    "            prediction (tensor) - - la predicción de un discriminador\n",
    "            target_is_real (bool) - - si la etiqueta verdadera es verdadera o falsa\n",
    "\n",
    "        Returns:\n",
    "            Un tensor como etiqueta con los valores verdaderos con la dimensión de la entrada\n",
    "        \"\"\"\n",
    "\n",
    "        if target_is_real:\n",
    "            target_tensor = self.real_label\n",
    "        else:\n",
    "            target_tensor = self.fake_label\n",
    "        return target_tensor.expand_as(prediction) # https://pytorch.org/docs/stable/tensors.html#torch.Tensor.expand_as\n",
    "\n",
    "    def __call__(self, prediction, target_is_real):\n",
    "        \"\"\"Calculate loss given Discriminator's output and grount truth labels.\n",
    "\n",
    "        Parameters:\n",
    "            prediction (tensor) - - tpyically the prediction output from a discriminator\n",
    "            target_is_real (bool) - - if the ground truth label is for real images or fake images\n",
    "\n",
    "        Returns:\n",
    "            the calculated loss.\n",
    "        \"\"\"\n",
    "        if self.gan_mode in ['lsgan', 'vanilla']:\n",
    "            target_tensor = self.get_target_tensor(prediction, target_is_real)\n",
    "            loss = self.loss(prediction, target_tensor)\n",
    "        elif self.gan_mode == 'wgangp':\n",
    "            if target_is_real:\n",
    "                loss = -prediction.mean()\n",
    "            else:\n",
    "                loss = prediction.mean()\n",
    "        return loss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CycleGAN completa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class cycle_gan():\n",
    "\n",
    "    def __init__(self, device='cpu', training=True):\n",
    "        self.device = device\n",
    "        use_dropout = False\n",
    "        self.netG_A = init_net(ResnetGenerator(3, 3, 8, use_dropout=use_dropout, n_blocks=9), init_type='xavier').to(self.device)\n",
    "\n",
    "        self.netG_B = init_net(ResnetGenerator(3, 3, 8, use_dropout=use_dropout, n_blocks=9), init_type='xavier').to(self.device)\n",
    "\n",
    "        ndf = 64\n",
    "\n",
    "        beta1 = 0.5\n",
    "        self.training = training\n",
    "        if training:\n",
    "            self.netD_A = init_net(NLayerDiscriminator(3, ndf, n_layers=3).to(self.device))\n",
    "            self.netD_B = init_net(NLayerDiscriminator(3, ndf, n_layers=3).to(self.device))\n",
    "            self.optimizer_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(), self.netD_B.parameters()),\n",
    "                                                lr=0.0002, betas=(beta1, 0.999))\n",
    "\n",
    "        pool_size = 50\n",
    "        self.fake_A_pool = ImagePool(pool_size)  # create image buffer to store previously generated images\n",
    "        self.fake_B_pool = ImagePool(pool_size)  # create image buffer to store previously generated images\n",
    "        # define loss functions\n",
    "        self.criterionGAN = GANLoss('lsgan').to(self.device)  # define GAN loss.\n",
    "        self.criterionCycle = torch.nn.L1Loss()\n",
    "        self.criterionIdt = torch.nn.L1Loss()\n",
    "        # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.\n",
    "\n",
    "        # https://discuss.pytorch.org/t/what-does-chain-in-itertools-do/1817\n",
    "        self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters()),\n",
    "                                            lr=0.0002, betas=(beta1, 0.999))\n",
    "\n",
    "    def set_input(self, A, B):\n",
    "        \"\"\"Tomamos las entradas a la red.\n",
    "\n",
    "        Parameters:\n",
    "            A (Tensor): Tensor con la imagen/es A.\n",
    "            B (Tensor): Tensor con la imagen/es B.\n",
    "        \"\"\"\n",
    "\n",
    "        self.real_A = A.to(self.device)\n",
    "        self.real_B = B.to(self.device)\n",
    "\n",
    "    def set_input_test(self, A):\n",
    "        \"\"\"Tomamos la entrada del dominio A.\n",
    "\n",
    "        Parameters:\n",
    "            A (Tensor): Tensor con la imagen/es A.\n",
    "        \"\"\"\n",
    "\n",
    "        self.real_A = A.to(self.device)\n",
    "\n",
    "    def forward(self):\n",
    "        \"\"\"Run forward pass; called by both functions <optimize_parameters> and <test>.\"\"\"\n",
    "        self.fake_B = self.netG_A(self.real_A)  # G_A(A)\n",
    "        self.rec_A = self.netG_B(self.fake_B)   # G_B(G_A(A))\n",
    "        self.fake_A = self.netG_B(self.real_B)  # G_B(B)\n",
    "        self.rec_B = self.netG_A(self.fake_A)   # G_A(G_B(B))\n",
    "\n",
    "    def forward_test(self):\n",
    "        \"\"\"Solo computa el forward pass en los generadores\"\"\"\n",
    "        self.fake_B = self.netG_A(self.real_A)  # G_A(A)\n",
    "        self.fake_A = self.netG_B(self.fake_B)\n",
    "\n",
    "\n",
    "    def backward_D_basic(self, netD, real, fake):\n",
    "        \"\"\"Calculate GAN loss for the discriminator\n",
    "\n",
    "        Parameters:\n",
    "            netD (network)      -- el discriminador D\n",
    "            real (tensor array) -- imágenes reales\n",
    "            fake (tensor array) -- imágenes generadas por un generador\n",
    "\n",
    "        Return the discriminator loss.\n",
    "        We also call loss_D.backward() to calculate the gradients.\n",
    "        \"\"\"\n",
    "        # Real\n",
    "        pred_real = netD(real)\n",
    "        loss_D_real = self.criterionGAN(pred_real, True)\n",
    "        # Fake\n",
    "        pred_fake = netD(fake.detach())\n",
    "        loss_D_fake = self.criterionGAN(pred_fake, False)\n",
    "        # Combined loss and calculate gradients\n",
    "        loss_D = (loss_D_real + loss_D_fake) * 0.5\n",
    "        loss_D.backward()\n",
    "        return loss_D\n",
    "\n",
    "    def backward_D_A(self):\n",
    "        \"\"\"Calculate GAN loss for discriminator D_A\"\"\"\n",
    "        fake_B = self.fake_B_pool.query(self.fake_B)\n",
    "        self.loss_D_A = self.backward_D_basic(self.netD_A, self.real_B, fake_B)\n",
    "\n",
    "    def backward_D_B(self):\n",
    "        \"\"\"Calculate GAN loss for discriminator D_B\"\"\"\n",
    "        fake_A = self.fake_A_pool.query(self.fake_A)\n",
    "        self.loss_D_B = self.backward_D_basic(self.netD_B, self.real_A, fake_A)\n",
    "\n",
    "    def backward_G(self):\n",
    "        \"\"\"Calculate the loss for generators G_A and G_B\"\"\"\n",
    "        #lambda_idt es la importancia dela pérdida del ciclo.\n",
    "        lambda_idt = 0.5\n",
    "        lambda_A = 10.0 # peso para cycle loss (A -> B -> A)\n",
    "        lambda_B = 10.0 # peso para cycle loss (B -> A-> B)\n",
    "        # Identity loss\n",
    "        if lambda_idt > 0:\n",
    "            # G_A should be identity if real_B is fed: ||G_A(B) - B||\n",
    "            self.idt_A = self.netG_A(self.real_B)\n",
    "            self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt\n",
    "            # G_B should be identity if real_A is fed: ||G_B(A) - A||\n",
    "            self.idt_B = self.netG_B(self.real_A)\n",
    "            self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt\n",
    "        else:\n",
    "            self.loss_idt_A = 0\n",
    "            self.loss_idt_B = 0\n",
    "\n",
    "        # pérdida GAN D_A(G_A(A))\n",
    "        self.loss_G_A = self.criterionGAN(self.netD_A(self.fake_B), True)\n",
    "        # pérdida GAN D_B(G_B(B))\n",
    "        self.loss_G_B = self.criterionGAN(self.netD_B(self.fake_A), True)\n",
    "        # Forward cycle loss || G_B(G_A(A)) - A||\n",
    "        self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A\n",
    "        # Backward cycle loss || G_A(G_B(B)) - B||\n",
    "        self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B\n",
    "        # pérdida combinada y calcula gradientes\n",
    "        self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B\n",
    "        self.loss_G.backward()\n",
    "\n",
    "\n",
    "    def set_requires_grad(self, nets, requires_grad=False):\n",
    "        \"\"\"requies_grad=Fasle para toda las redes para evitar cálculos innecesarios\n",
    "        Parameters:\n",
    "            nets (network list)   -- una lista de las redes\n",
    "            requires_grad (bool)  -- si las redes requieren gradientes o no\n",
    "        \"\"\"\n",
    "        if not isinstance(nets, list):\n",
    "            nets = [nets]\n",
    "        for net in nets:\n",
    "            if net is not None:\n",
    "                for param in net.parameters():\n",
    "                    param.requires_grad = requires_grad\n",
    "\n",
    "    def optimize_parameters(self):\n",
    "        \"\"\"Calcula las pérdidad, gradientes, y actualiza los pesos de las redes; llamada en cada iter de entrenamiento\"\"\"\n",
    "        # forward\n",
    "        self.forward()      # compute fake images and reconstruction images.\n",
    "        # G_A and G_B\n",
    "        self.set_requires_grad([self.netD_A, self.netD_B], False)  # Discriminadores no requieren grad\n",
    "                                                                   # al optimizar los Gen\n",
    "        self.optimizer_G.zero_grad()  # ponemos los gradientes de los gen a cero\n",
    "        self.backward_G()             # calculamos los gradientes para G_A y G_B\n",
    "        self.optimizer_G.step()       # actualizamos los pesos de G_A y G_B's\n",
    "        # D_A and D_B\n",
    "        self.set_requires_grad([self.netD_A, self.netD_B], True)\n",
    "        self.optimizer_D.zero_grad()   # pone a cero los gradientes de los discriminadores\n",
    "        self.backward_D_A()      # calcula los gradientes para D_A\n",
    "        self.backward_D_B()      # calcula los gradientes para D_B\n",
    "        self.optimizer_D.step()  # actualiza los pesos de D_A y D_B\n",
    "\n",
    "    def load_weights(self, dir, epoch):\n",
    "        self.netG_A.load_state_dict(torch.load(dir + 'generatorA-{}.pkl'.format(epoch)))\n",
    "        self.netG_B.load_state_dict(torch.load(dir + 'generatorB-{}.pkl'.format(epoch)))\n",
    "        if self.training:\n",
    "            self.netD_A.load_state_dict(torch.load(dir + 'discriminatorA-{}.pkl'.format(epoch)))\n",
    "            self.netD_B.load_state_dict(torch.load(dir + 'discriminatorB-{}.pkl'.format(epoch)))\n",
    "\n",
    "    def save_weights(self, dir, epoch):\n",
    "        \"\"\"\n",
    "        Guarda los pesos de la red en el directorio indicado e incluyendo en el nombre la epoch\n",
    "        \"\"\"\n",
    "        torch.save(self.netG_A.state_dict(), dir + 'generatorA-{}.pkl'.format(epoch))\n",
    "        torch.save(self.netG_B.state_dict(), dir + 'generatorB-{}.pkl'.format(epoch))\n",
    "        torch.save(self.netD_A.state_dict(), dir + 'discriminatorA-{}.pkl'.format(epoch))\n",
    "        torch.save(self.netD_B.state_dict(), dir + 'discriminatorB-{}.pkl'.format(epoch))\n",
    "    \n",
    "    def print_losses(self):\n",
    "        \"\"\"\n",
    "        Esta función la usamos para imprimir en la terminal las pérdidas\n",
    "        \"\"\"\n",
    "        print('Generator losses: ', self.loss_G)\n",
    "        print('Discriminator losses', self.loss_D_A, self.loss_D_B)\n",
    "\n",
    "    def get_losses(self):\n",
    "        \"\"\"\n",
    "        Returna la pérdida total de la GAN y de cada Discriminador\n",
    "        \"\"\"\n",
    "        return self.loss_G, self.loss_D_A, self.loss_D_B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Carga del dataset\n",
    "\n",
    "El dataset lo he estructurado de tal manera que podremos cargarlo y dividirlo (en training y test) con las funciones de pytorch destinadas a ello.\n",
    "\n",
    "Primero aplicamos unas [transformaciones](https://pytorch.org/docs/stable/torchvision/transforms.html) a las imágenes para ser entrenadas en nuestra red.\n",
    "\n",
    "Para entrenar nuestro modelo tenemos la facilidad de usar los DataLoaders de PyTorch. Nos permiten agrupar en grupos(batches) y barajar los distintos datos para pasarselos a nuestro modelo. Gracias a ellos también evitamos cargar todo el dataset en la RAM lo cual en muchos casos resulta inviable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.datasets import ImageFolder\n",
    "\n",
    "BATCH_SIZE = 5\n",
    "RESUME_TRAINING = False\n",
    "\n",
    "transform = transforms.Compose([transforms.RandomCrop(600, pad_if_needed=True), \n",
    "                                transforms.Resize(512),\n",
    "                                #transforms.Resize((720, 1024)),\n",
    "                                transforms.ToTensor()])\n",
    "\n",
    "transform_test = transforms.Compose([transforms.Resize((720, 1024)),\n",
    "                                    transforms.ToTensor()])\n",
    "\n",
    "def dataloader(direc, type):\n",
    "    '''\n",
    "    Returns dataloaders for training and testing from each domain\n",
    "    :param direc: Directory of the datasets\n",
    "    :param type: \"City\" or \"CP\" (CyberPunk)\n",
    "    :return: Dataloader de entrenamiento y test\n",
    "    '''\n",
    "    image_path_train = direc + '/{}/'.format(type)\n",
    "    image_path_test = direc + '/test_{}/'.format(type)\n",
    "    \n",
    "    train = ImageFolder(image_path_train, transform)\n",
    "    test = ImageFolder(image_path_test, transform_test)\n",
    "    \n",
    "    train_loader = DataLoader(dataset=train, batch_size=BATCH_SIZE, shuffle=True)\n",
    "    test_loader = DataLoader(dataset=test, batch_size=1, shuffle=False)\n",
    "    return train_loader, test_loader\n",
    "\n",
    "train_loader_x, test_loader_x = dataloader('./datasets/', 'City')\n",
    "train_loader_y, test_loader_y = dataloader('./datasets/', 'CP')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Escalado de imágenes\n",
    "\n",
    "El escalado de las imágenes lo realizamos a causa de la función de activación* de la última capa del generador. \n",
    "\n",
    "Las imágenes generadas tendrán una escala \\[-1, 1\\] debido a la función mencionada. Por lo que todo el dataset que le pasemos deberá tener la misma escala. (Si no tendríamos entradas irregulares de \\[0,1\\] y \\[,-1, 1\\]).\n",
    "\n",
    "La función save_image() es usada para transformar la imagen de salida de la red a una escala convencional \\[0, 255\\] y poder guardarla.\n",
    "\n",
    "*La función usada es tanh(x) (función tangente hiperbólica).\n",
    "\n",
    "![tanh.png](attachment:tanh.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale(x, feature_range=(-1, 1)):\n",
    "    '''\n",
    "    Scale toma una imagen x y la devuelve escalada en [-1, 1].\n",
    "    '''\n",
    "    min, max = feature_range\n",
    "    x = x * (max - min) + min\n",
    "    return x\n",
    "\n",
    "\n",
    "def save_image(img_tensor, img_num, epoch, direc, tipo):\n",
    "    '''\n",
    "    Guarda una imagen con el número de la imagen y epoch en la que fue generada \n",
    "    '''\n",
    "    img = img_tensor.squeeze(0) # Quita la dimensión de batch\n",
    "    img = img.detach().cpu().numpy() # Pasa el array a la cpu y lo transforma a un array tipo numpy\n",
    "    img = ((img + 1) * 255 / (2)).astype(np.uint8)\n",
    "    img = img.transpose(1, 2, 0) # Pytorch tiene las imgs con los canales de color primero\n",
    "                                 # lo común es \\[altura, ancho, canales\\]\n",
    "    cv2.imwrite(direc + '/' + tipo + '-num-{}epoch-{}.png'.format(img_num, epoch), cv2.cvtColor(img, cv2.COLOR_RGB2BGR))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bucle de entrenamiento y test\n",
    "\n",
    "El bucle itera un numero de veces(epochs, etapas) sobre el dataset. Cada cierto tiempo prueba el modelo sobre las imágenes de test y las guarda en la carpeta samples donde podremos ver los resultados.\n",
    "\n",
    "Sobre el proceso de entrenamiento y resultado deseado he de decir que desde las primeras epochs se obtienen resultados interesantes.\n",
    "\n",
    "Las primeras epochs dan un efecto muy exagerado, mucha saturación y patrones, dan una apariencia más irreal y psicodélica. Conforme avanza el entrenamiento esos patrones se van perdiendo en la imágen y los efectos son más disimulados, en algunas imágenes procesadas por las últimas epochs(sobre las 280-300) no se aprecian los efectos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_weights = './model_weights/'\n",
    "\n",
    "modelo = cycle_gan()\n",
    "modelo.load_weights(dir_weights, 100)\n",
    "\n",
    "# number of epochs to train the model\n",
    "n_epochs = 10\n",
    "TEST_CADA = 2\n",
    "\n",
    "started = datetime.datetime.now()\n",
    "print('Started at:', started)\n",
    "\n",
    "for epoch in range(102, n_epochs + 1):\n",
    "    # monitor training loss\n",
    "    # TODO implementar el tracking de la pérdida\n",
    "    train_gen_loss = 0.0\n",
    "    train_dis_loss = 0.0\n",
    "\n",
    "    start_time = time.time()\n",
    "    \n",
    "    print('Epoch número:', epoch)\n",
    "\n",
    "    #####################\n",
    "    # entrena el modelo #\n",
    "    #####################\n",
    "    for data_x, data_y in zip(train_loader_x, train_loader_y):\n",
    "        modelo.set_input(scale(data_x[0]), scale(data_y[0])) # mete los datos en nuestra clase\n",
    "        modelo.optimize_parameters() # realiza el proceso de forward, cálcuilo de pérdida\n",
    "                                     # y retropropagación\n",
    "\n",
    "    time_elapsed = time.time() - start_time\n",
    "    print('Epoch {} took {:.2f} seconds ({:.2f} minutes)'.format(epoch, time_elapsed, time_elapsed/60))\n",
    "    \n",
    "    ####################\n",
    "    # prueba el modelo #\n",
    "    ####################\n",
    "    if epoch % TEST_CADA == 0:\n",
    "        modelo.print_losses()\n",
    "        for num, batch in enumerate(test_loader_x):\n",
    "            img, _ = batch\n",
    "            modelo.set_input_test(scale(batch[0]))\n",
    "            modelo.forward_test()\n",
    "\n",
    "            save_image(modelo.fake_B, num, epoch, './samples/', 'B')\n",
    "            save_image(modelo.fake_A, num, epoch, './samples/', 'A')\n",
    "\n",
    "        modelo.save_weights(dir_weights, epoch)\n",
    "\n",
    "print('Started at:', started)\n",
    "print('Finished at ', datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ¡Esto es un engaño, se ven pixeladas!\n",
    "\n",
    "![pixel-fallo.png](attachment:pixel-fallo.png)\n",
    "\n",
    "No te preocupes por esto, es un problema común en este tipo de redes. Este [paper](https://distill.pub/2016/deconv-checkerboard/) explica bien el motivo de este suceso y propone diversas soluciones.\n",
    "\n",
    "He intentado solucionarlo redimensionando la imagen usando Interpolación lineal y después hacer convolución tal y como propone el paper, pero no me ha servido de mucho. He de decir que no he tenido mucho tiempo posteriormente tras descubrirlo así que no he podido experimentar bien y aplicarlo bien a nuestro dataset.\n",
    "\n",
    "Por otra parte en mi opinión le dan un toque entre psicodélico y \"glitchy\" a las imágenes y en ocasiones crea imágenes claramente irrealistas pero visualmente estéticas.\n",
    "\n",
    "Si entrenamos lo suficiente el modelo llegará un punto en el que desaparezcan o sean más disimuladas. Tras unas 200/300 epoch en mi caso he ido obteniendo buenos resultados en ese sentido.\n",
    "\n",
    "![B-num-3epoch-390.png](attachment:B-num-3epoch-390.png)\n",
    "\n",
    "Se puede deber a tener un dataset pequeño, a pesar de que en general la imagen anterior tiene pocos \"píxeles\" o patrones, el suelo no está bien procesado, puede ser a causa de la ausencia de imágenes similares con tanto suelo.\n",
    "\n",
    "Otro detalle a observar es que a las personas también les aplica filtros con las luces de los edificios. Se debe a la ausencia de personas en la parte de imágenes CyberPunk, no \"sabe\" como se ve una persona en ese tipo de imágenes, la solución a este problema sería añadir imágenes CyberPunk con más densidad de personas. El problema es que la mayoría de imágenes no incluyen personas y si buscas \"cyberpunk people\" te saldrán sobre todo imágenes de videojuegos o cosplays."
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}