Step_02_Simulator_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version:  3.8.10 (default, Mar 15 2022, 12:22:08) \n",
      "[GCC 9.4.0]\n",
      "numpy version 1.23.1\n",
      "matplotlib version 3.5.2\n",
      "TF: 2.9.1\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"Python version: \", sys.version)\n",
    "import os\n",
    "from pathlib import Path\n",
    "import time\n",
    "import datetime\n",
    "import itertools\n",
    "import random\n",
    "\n",
    "import numpy as np\n",
    "print(\"numpy version\", np.__version__)\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "print(\"matplotlib version\", matplotlib.__version__)\n",
    "\n",
    "import imutils\n",
    "\n",
    "from tqdm import tqdm\n",
    "tqdm.pandas()\n",
    "\n",
    "#from perlin_numpy import (\n",
    "#    generate_perlin_noise_3d\n",
    "#)\n",
    "\n",
    "import tensorflow as tf\n",
    "print(\"TF:\", tf.__version__)\n",
    "\n",
    "from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout, Concatenate, MaxPool2D, multiply\n",
    "from tensorflow.keras.layers import BatchNormalization, Activation, Embedding, ZeroPadding2D\n",
    "from tensorflow.keras.layers import LeakyReLU\n",
    "from tensorflow.keras.layers import UpSampling2D, Conv2D\n",
    "from tensorflow.keras.models import Sequential, Model\n",
    "from tensorflow.python.framework import ops\n",
    "\n",
    "physical_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "if len(physical_devices) > 0:\n",
    "    tf.config.set_visible_devices(physical_devices[0], 'GPU')\n",
    "    tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "\n",
    "from IPython import display\n",
    "\n",
    "import simulate\n",
    "import process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = \"./data/\"\n",
    "MARKER_PATH = \"./markers_official/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PIGN6ouoQxt3"
   },
   "source": [
    "## Build an input pipeline with `tf.data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Load files: 100%|██████████| 2/2 [00:03<00:00,  1.60s/it]\n",
      "100%|██████████| 645972/645972 [02:40<00:00, 4029.16it/s]\n"
     ]
    }
   ],
   "source": [
    "lstDfs = []\n",
    "for f in tqdm([\"16h5_validation.pkl\", \"36h11_training.pkl\"], desc=\"Load files\"):\n",
    "    lstDfs.append(pd.read_pickle(f\"{DATA_PATH}{f}\"))\n",
    "\n",
    "df = pd.concat(lstDfs)\n",
    "\n",
    "df[\"Marker\"] = df.progress_apply(lambda e: simulate.load_tag(e.Size, e.MarkerType, e.Id, e.Angle, MARKER_PATH=MARKER_PATH), axis=1)\n",
    "df.reset_index(drop = True, inplace = True)\n",
    "\n",
    "# create train/test/val split\n",
    "df['Datatype'] = \"\"\n",
    "\n",
    "np.random.seed(420)\n",
    "indices = np.arange(len(df))\n",
    "np.random.shuffle(indices)\n",
    "\n",
    "train, test = .7, .3\n",
    "# We do not keep a validaton set back, because we have a validation dataset with different makers.\n",
    "\n",
    "train_len = int(np.ceil(len(indices)*train))\n",
    "test_len = int(train_len + np.ceil(len(indices)*test))\n",
    "\n",
    "train_ids = indices[:train_len] \n",
    "test_ids = indices[train_len:]\n",
    "\n",
    "df.loc[train_ids, 'Datatype'] = 'train'\n",
    "df.loc[test_ids, 'Datatype'] = 'test'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataGenerator:\n",
    "    \n",
    "    def __init__(self, df, batch_size = 64, shuffle = True, cap_res=(32, 32, 1), temp_res=(128,128, 1)):\n",
    "        self.batch_size = batch_size\n",
    "        self.shuffle = shuffle\n",
    "        self.df = df\n",
    "        self.n_batches = int(np.round(len(self.df)/batch_size))\n",
    "        self.cap_res = cap_res\n",
    "        self.temp_res = temp_res\n",
    "\n",
    "    def __call__(self, shuffle=True):\n",
    "        \n",
    "        indexes = self.df.index.values\n",
    "        if self.shuffle:\n",
    "            np.random.shuffle(indexes)\n",
    "\n",
    "        for i in range(self.n_batches-1):\n",
    "            batch = indexes[i*batch_size:(i+1)*batch_size]\n",
    "            imgs_A, imgs_B = [], []\n",
    "            for i, e in self.df.loc[batch].iterrows():\n",
    "\n",
    "                img_A = e.Blob\n",
    "                img_B = e.Marker\n",
    "\n",
    "                # Shift Blob (img_A) and Template (img_B) using normal distribution\n",
    "                # stdev = 1 -> 99.73% samples within range +- 3 around mean = 0\n",
    "                for shift_axis in [0, 1]:\n",
    "                    shift_amount = np.random.randint(-1,2)\n",
    "\n",
    "                    img_A = np.roll(img_A, shift_amount, axis = shift_axis)\n",
    "                    img_B = np.roll(img_B, shift_amount*4, axis = shift_axis)\n",
    "\n",
    "\n",
    "                img_A = img_A.reshape([self.cap_res[0],self.cap_res[1],self.cap_res[2]])\n",
    "                img_B = img_B.reshape([self.temp_res[0],self.temp_res[1],self.temp_res[2]])\n",
    "\n",
    "                imgs_A.append(img_A)\n",
    "                imgs_B.append(img_B)\n",
    "\n",
    "            imgs_A = np.array(imgs_A)/127.5 - 1.\n",
    "            imgs_B = np.array(imgs_B)/127.5 - 1.\n",
    "\n",
    "            imgs_A = tf.convert_to_tensor(imgs_A)\n",
    "            imgs_B = tf.convert_to_tensor(imgs_B)\n",
    "\n",
    "            yield imgs_B, imgs_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "cap_res=(32, 32, 1)\n",
    "temp_res=(128, 128, 1)\n",
    "\n",
    "gen_train = DataGenerator(df[df.Datatype == 'train'], batch_size=batch_size, cap_res = cap_res, temp_res = temp_res)\n",
    "gen_val = DataGenerator(df[df.Datatype == 'test'], batch_size=batch_size, cap_res = cap_res, temp_res = temp_res)\n",
    "\n",
    "train_dataset = tf.data.Dataset.from_generator(gen_train, \n",
    "                                         output_signature=(\n",
    "                                             tf.TensorSpec(shape=(batch_size, 128,128,1), dtype=tf.float32),\n",
    "         tf.TensorSpec(shape=(batch_size, 32, 32, 1), dtype=tf.float32)\n",
    "         )).prefetch(tf.data.AUTOTUNE).cache().repeat()\n",
    "\n",
    "test_dataset = tf.data.Dataset.from_generator(gen_val, \n",
    "                                         output_signature=(\n",
    "                                             tf.TensorSpec(shape=(batch_size, 128,128,1), dtype=tf.float32),\n",
    "         tf.TensorSpec(shape=(batch_size, 32, 32, 1), dtype=tf.float32))).prefetch(tf.data.AUTOTUNE).cache().repeat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "THY-sZMiQ4UV"
   },
   "source": [
    "## Build the Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "lFPI4Nu-8b4q"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"generator\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input (InputLayer)             [(None, 128, 128, 1  0           []                               \n",
      "                                )]                                                                \n",
      "                                                                                                  \n",
      " conv2d_15 (Conv2D)             (None, 128, 128, 32  544         ['input[0][0]']                  \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " leaky_re_lu_11 (LeakyReLU)     (None, 128, 128, 32  0           ['conv2d_15[0][0]']              \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " max_pooling2d_5 (MaxPooling2D)  (None, 64, 64, 32)  0           ['leaky_re_lu_11[0][0]']         \n",
      "                                                                                                  \n",
      " conv2d_16 (Conv2D)             (None, 64, 64, 64)   32832       ['max_pooling2d_5[0][0]']        \n",
      "                                                                                                  \n",
      " leaky_re_lu_12 (LeakyReLU)     (None, 64, 64, 64)   0           ['conv2d_16[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_11 (BatchN  (None, 64, 64, 64)  256         ['leaky_re_lu_12[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " max_pooling2d_6 (MaxPooling2D)  (None, 32, 32, 64)  0           ['batch_normalization_11[0][0]'] \n",
      "                                                                                                  \n",
      " conv2d_17 (Conv2D)             (None, 32, 32, 128)  131200      ['max_pooling2d_6[0][0]']        \n",
      "                                                                                                  \n",
      " leaky_re_lu_13 (LeakyReLU)     (None, 32, 32, 128)  0           ['conv2d_17[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_12 (BatchN  (None, 32, 32, 128)  512        ['leaky_re_lu_13[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " max_pooling2d_7 (MaxPooling2D)  (None, 16, 16, 128)  0          ['batch_normalization_12[0][0]'] \n",
      "                                                                                                  \n",
      " conv2d_18 (Conv2D)             (None, 16, 16, 256)  524544      ['max_pooling2d_7[0][0]']        \n",
      "                                                                                                  \n",
      " leaky_re_lu_14 (LeakyReLU)     (None, 16, 16, 256)  0           ['conv2d_18[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_13 (BatchN  (None, 16, 16, 256)  1024       ['leaky_re_lu_14[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " max_pooling2d_8 (MaxPooling2D)  (None, 8, 8, 256)   0           ['batch_normalization_13[0][0]'] \n",
      "                                                                                                  \n",
      " conv2d_19 (Conv2D)             (None, 8, 8, 512)    2097664     ['max_pooling2d_8[0][0]']        \n",
      "                                                                                                  \n",
      " leaky_re_lu_15 (LeakyReLU)     (None, 8, 8, 512)    0           ['conv2d_19[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_14 (BatchN  (None, 8, 8, 512)   2048        ['leaky_re_lu_15[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " max_pooling2d_9 (MaxPooling2D)  (None, 4, 4, 512)   0           ['batch_normalization_14[0][0]'] \n",
      "                                                                                                  \n",
      " up_sampling2d_3 (UpSampling2D)  (None, 8, 8, 512)   0           ['max_pooling2d_9[0][0]']        \n",
      "                                                                                                  \n",
      " conv2d_20 (Conv2D)             (None, 8, 8, 256)    2097408     ['up_sampling2d_3[0][0]']        \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)            (None, 8, 8, 256)    0           ['conv2d_20[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_15 (BatchN  (None, 8, 8, 256)   1024        ['dropout_1[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " concatenate_3 (Concatenate)    (None, 8, 8, 512)    0           ['batch_normalization_15[0][0]', \n",
      "                                                                  'max_pooling2d_8[0][0]']        \n",
      "                                                                                                  \n",
      " up_sampling2d_4 (UpSampling2D)  (None, 16, 16, 512)  0          ['concatenate_3[0][0]']          \n",
      "                                                                                                  \n",
      " conv2d_21 (Conv2D)             (None, 16, 16, 128)  1048704     ['up_sampling2d_4[0][0]']        \n",
      "                                                                                                  \n",
      " batch_normalization_16 (BatchN  (None, 16, 16, 128)  512        ['conv2d_21[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " concatenate_4 (Concatenate)    (None, 16, 16, 256)  0           ['batch_normalization_16[0][0]', \n",
      "                                                                  'max_pooling2d_7[0][0]']        \n",
      "                                                                                                  \n",
      " up_sampling2d_5 (UpSampling2D)  (None, 32, 32, 256)  0          ['concatenate_4[0][0]']          \n",
      "                                                                                                  \n",
      " conv2d_22 (Conv2D)             (None, 32, 32, 1)    4097        ['up_sampling2d_5[0][0]']        \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 5,942,369\n",
      "Trainable params: 5,939,681\n",
      "Non-trainable params: 2,688\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def Generator(template_shape = (128, 128, 1), channels = 1, debug = True):\n",
    "    \n",
    "    initializer = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.02, seed=None)\n",
    "    \n",
    "    def conv2d(layer_input, filters, f_size=4, bn=True):\n",
    "        d = Conv2D(filters, kernel_size=f_size, strides=1, padding='same', kernel_initializer = initializer)(layer_input)\n",
    "        d = LeakyReLU(alpha=0.2)(d)\n",
    "        if bn:\n",
    "            d = BatchNormalization(momentum=0.8)(d)\n",
    "        d = MaxPool2D(padding = 'same')(d)\n",
    "        return d\n",
    "\n",
    "    def deconv2d(layer_input, skip_input, filters, f_size=4, apply_dropout=False):\n",
    "        u = UpSampling2D(size=2)(layer_input)\n",
    "        u = Conv2D(filters, kernel_size=f_size, strides=1, padding='same', activation='relu', kernel_initializer = initializer)(u)\n",
    "        if apply_dropout:\n",
    "            u = Dropout(0.5)(u)\n",
    "        u = BatchNormalization(momentum=0.8)(u)\n",
    "        u = Concatenate()([u, skip_input])\n",
    "        return u\n",
    "\n",
    "    # Image input\n",
    "    d0 = tf.keras.layers.Input(shape=template_shape, name=\"input\")\n",
    "\n",
    "    # Downsampling\n",
    "    d1 = conv2d(d0, 32, bn=False)\n",
    "    d2 = conv2d(d1, 64)\n",
    "    d3 = conv2d(d2, 128)\n",
    "    d4 = conv2d(d3, 256)\n",
    "    d5 = conv2d(d4, 512)\n",
    "    u5 = deconv2d(d5, d4, 256, apply_dropout = True)\n",
    "    u6 = deconv2d(u5, d3, 128)\n",
    "\n",
    "    u7 = UpSampling2D(size=2)(u6)\n",
    "    output_img = Conv2D(channels, kernel_size=4, strides=1, padding='same', activation='tanh')(u7)\n",
    "    model = Model(d0, output_img, name = 'generator')\n",
    "    \n",
    "    if (debug):\n",
    "        print(model.summary())\n",
    "    return model\n",
    "\n",
    "generator = Generator(template_shape = temp_res)\n",
    "#tf.keras.utils.plot_model(generator, show_shapes=True, dpi=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "90BIcCKcDMxz"
   },
   "outputs": [],
   "source": [
    "LAMBDA = 100\n",
    "\n",
    "loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
    "\n",
    "def generator_loss(disc_generated_output, gen_output, target):\n",
    "    gan_loss = loss_object(tf.ones_like(disc_generated_output), disc_generated_output)\n",
    "\n",
    "    # Mean absolute error\n",
    "    l1_loss = tf.reduce_mean(tf.abs(target - gen_output))\n",
    "\n",
    "    total_gen_loss = gan_loss + (LAMBDA * l1_loss)\n",
    "\n",
    "    return total_gen_loss, gan_loss, l1_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZTKZfoaoEF22"
   },
   "source": [
    "## Build the Discriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "ll6aNeQx8b4v"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"discriminator\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_template (InputLayer)    [(None, 128, 128, 1  0           []                               \n",
      "                                )]                                                                \n",
      "                                                                                                  \n",
      " conv2d_23 (Conv2D)             (None, 64, 64, 16)   272         ['input_template[0][0]']         \n",
      "                                                                                                  \n",
      " leaky_re_lu_16 (LeakyReLU)     (None, 64, 64, 16)   0           ['conv2d_23[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_17 (BatchN  (None, 64, 64, 16)  64          ['leaky_re_lu_16[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " input_cap (InputLayer)         [(None, 32, 32, 1)]  0           []                               \n",
      "                                                                                                  \n",
      " conv2d_24 (Conv2D)             (None, 32, 32, 32)   8224        ['batch_normalization_17[0][0]'] \n",
      "                                                                                                  \n",
      " conv2d_25 (Conv2D)             (None, 32, 32, 32)   544         ['input_cap[0][0]']              \n",
      "                                                                                                  \n",
      " leaky_re_lu_17 (LeakyReLU)     (None, 32, 32, 32)   0           ['conv2d_24[0][0]']              \n",
      "                                                                                                  \n",
      " leaky_re_lu_18 (LeakyReLU)     (None, 32, 32, 32)   0           ['conv2d_25[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_18 (BatchN  (None, 32, 32, 32)  128         ['leaky_re_lu_17[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " batch_normalization_19 (BatchN  (None, 32, 32, 32)  128         ['leaky_re_lu_18[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " concatenate_5 (Concatenate)    (None, 32, 32, 64)   0           ['batch_normalization_18[0][0]', \n",
      "                                                                  'batch_normalization_19[0][0]'] \n",
      "                                                                                                  \n",
      " conv2d_26 (Conv2D)             (None, 16, 16, 64)   65600       ['concatenate_5[0][0]']          \n",
      "                                                                                                  \n",
      " leaky_re_lu_19 (LeakyReLU)     (None, 16, 16, 64)   0           ['conv2d_26[0][0]']              \n",
      "                                                                                                  \n",
      " conv2d_27 (Conv2D)             (None, 8, 8, 128)    131200      ['leaky_re_lu_19[0][0]']         \n",
      "                                                                                                  \n",
      " leaky_re_lu_20 (LeakyReLU)     (None, 8, 8, 128)    0           ['conv2d_27[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_20 (BatchN  (None, 8, 8, 128)   512         ['leaky_re_lu_20[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " conv2d_28 (Conv2D)             (None, 4, 4, 256)    524544      ['batch_normalization_20[0][0]'] \n",
      "                                                                                                  \n",
      " leaky_re_lu_21 (LeakyReLU)     (None, 4, 4, 256)    0           ['conv2d_28[0][0]']              \n",
      "                                                                                                  \n",
      " batch_normalization_21 (BatchN  (None, 4, 4, 256)   1024        ['leaky_re_lu_21[0][0]']         \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " conv2d_29 (Conv2D)             (None, 4, 4, 1)      4097        ['batch_normalization_21[0][0]'] \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 736,337\n",
      "Trainable params: 735,409\n",
      "Non-trainable params: 928\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def Discriminator(cap_shape = (32, 32, 1), template_shape = (128, 128, 1), debug = True):\n",
    "    \n",
    "    initializer = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.02, seed=None)\n",
    "    \n",
    "    def d_layer(layer_input, filters, f_size=4, bn=True):\n",
    "        \"\"\"Discriminator layer\"\"\"\n",
    "        d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same', kernel_initializer = initializer)(layer_input)\n",
    "     \n",
    "        \n",
    "        d = LeakyReLU(alpha=0.2)(d)\n",
    "        if bn:\n",
    "            d = BatchNormalization(momentum=0.8)(d)\n",
    "            \n",
    "        #d = MaxPool2D(padding = 'same')(d)\n",
    "        \n",
    "        return d\n",
    "\n",
    "    def conv2d(layer_input, filters, f_size=4, strides = 1, bn=True):\n",
    "        \"\"\"Layers used during downsampling\"\"\"\n",
    "        d = Conv2D(filters, kernel_size=f_size, strides=strides, padding='same', kernel_initializer = initializer)(layer_input)\n",
    "        d = LeakyReLU(alpha=0.2)(d)\n",
    "\n",
    "        if bn:\n",
    "            d = BatchNormalization(momentum=0.8)(d)\n",
    "        return d \n",
    "\n",
    "    img_A = tf.keras.layers.Input(shape=cap_shape, name=\"input_cap\")\n",
    "    img_B = tf.keras.layers.Input(shape=template_shape, name=\"input_template\")\n",
    "    \n",
    "    # Downsampling of template\n",
    "    db1 = conv2d(img_B, 16, strides = 2)\n",
    "    db2 = conv2d(db1, 32, strides = 2)\n",
    "    da1 = conv2d(img_A, 32, strides = 1)\n",
    "\n",
    "    # Concatenate image and conditioning image by channels to produce input\n",
    "    combined_imgs = Concatenate(axis=-1)([db2, da1])\n",
    "\n",
    "    d1 = d_layer(combined_imgs, 64, bn=False)\n",
    "    d2 = d_layer(d1, 128)\n",
    "    d3 = d_layer(d2, 256)\n",
    "\n",
    "    validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d3)\n",
    "\n",
    "    model = Model([img_B, img_A], validity, name = 'discriminator')\n",
    "    \n",
    "    if (debug):\n",
    "        print(model.summary())\n",
    "        \n",
    "    return model\n",
    "\n",
    "discriminator = Discriminator(cap_shape = cap_res, template_shape = temp_res)\n",
    "tf.keras.utils.plot_model(discriminator, show_shapes=True, dpi=64)\n",
    "\n",
    "def discriminator_loss(disc_real_output, disc_generated_output):\n",
    "    real_loss = loss_object(tf.ones_like(disc_real_output), disc_real_output)\n",
    "\n",
    "    generated_loss = loss_object(tf.zeros_like(disc_generated_output), disc_generated_output)\n",
    "\n",
    "    total_disc_loss = real_loss + generated_loss\n",
    "\n",
    "    return total_disc_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0FMYgY_mPfTi"
   },
   "source": [
    "## Set Hyperparameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_dir=\"./logs/\"\n",
    "Path(log_dir).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "start_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "summary_writer = tf.summary.create_file_writer(log_dir + \"fit/\" + start_time + '_4x4_2e-4_shift_dropout')\n",
    "\n",
    "\n",
    "step_count = len(df[df.Datatype == 'train'])//batch_size\n",
    "decay_steps = step_count * 30\n",
    "\n",
    "generator_optimizer = tf.keras.optimizers.Adam(learning_rate = 2e-4, beta_1=0.5)\n",
    "discriminator_optimizer = tf.keras.optimizers.Adam(learning_rate = 2e-4, beta_1=0.5)\n",
    "\n",
    "\n",
    "checkpoint_dir = './training_checkpoints'\n",
    "Path(checkpoint_dir).mkdir(parents=True, exist_ok=True)\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt_\"+ start_time)\n",
    "checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,\n",
    "                                 discriminator_optimizer=discriminator_optimizer,\n",
    "                                 generator=generator,\n",
    "                                 discriminator=discriminator)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "RmdVsmvhPxyy"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-11 19:11:48.120038: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n"
     ]
    }
   ],
   "source": [
    "def generate_images(model, test_input, tar):\n",
    "    prediction = model(test_input, training=True)\n",
    "    plt.figure(figsize=(15, 15))\n",
    "\n",
    "    display_list = [test_input[0], tar[0], prediction[0]]\n",
    "    title = ['Input Image', 'Ground Truth', 'Predicted Image']\n",
    "\n",
    "    for i in range(3):\n",
    "        plt.subplot(1, 3, i+1)\n",
    "        plt.title(title[i])\n",
    "        # Getting the pixel values in the [0, 1] range to plot.\n",
    "        plt.imshow(display_list[i] * 0.5 + 0.5)\n",
    "        plt.axis('off')\n",
    "    plt.show()\n",
    "        \n",
    "for example_input, example_target in test_dataset.take(1).cache():\n",
    "    generate_images(generator, example_input, example_target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "KBKUV2sKXDbY"
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(input_image, target, epoch):\n",
    "    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
    "        gen_output = generator(input_image, training=True)\n",
    "        #gen_output = generator(input_image)\n",
    "\n",
    "        disc_real_output = discriminator([input_image, target], training=True)\n",
    "        disc_generated_output = discriminator([input_image, gen_output], training=True)\n",
    "\n",
    "        gen_total_loss, gen_gan_loss, gen_l1_loss = generator_loss(disc_generated_output, gen_output, target)\n",
    "        disc_loss = discriminator_loss(disc_real_output, disc_generated_output)\n",
    "\n",
    "    generator_gradients = gen_tape.gradient(gen_total_loss,\n",
    "                                          generator.trainable_variables)\n",
    "    discriminator_gradients = disc_tape.gradient(disc_loss,\n",
    "                                               discriminator.trainable_variables)\n",
    "\n",
    "    generator_optimizer.apply_gradients(zip(generator_gradients,\n",
    "                                          generator.trainable_variables))\n",
    "    discriminator_optimizer.apply_gradients(zip(discriminator_gradients,\n",
    "                                              discriminator.trainable_variables))\n",
    "\n",
    "    with summary_writer.as_default():\n",
    "        tf.summary.scalar('gen_total_loss', gen_total_loss, step=epoch)\n",
    "        tf.summary.scalar('gen_gan_loss', gen_gan_loss, step=epoch)\n",
    "        tf.summary.scalar('gen_l1_loss', gen_l1_loss, step=epoch)\n",
    "        tf.summary.scalar('disc_loss', disc_loss, step=epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2022-07-11 19:12:23'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a1zZmKmvOH85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start epoch at 2022-07-11 19:12:33\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-11 19:12:34.026388: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0\n",
      "."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-11 19:12:34.516386: I tensorflow/core/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      ".......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The Jupyter server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--ServerApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "ServerApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "...............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n",
      "............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................"
     ]
    }
   ],
   "source": [
    "EPOCHS = 10\n",
    "saveCheckpointAfterNEpochs = 2\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    start = time.time()\n",
    "    display.clear_output(wait=True)\n",
    "\n",
    "    timeSTR = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "    print(f\"Start epoch at {timeSTR}\")\n",
    "    # Display Only\n",
    "    for example_input, example_target in test_dataset.take(1).cache():\n",
    "        generate_images(generator, example_input, example_target)\n",
    "\n",
    "    print(\"Epoch: \", epoch)\n",
    "\n",
    "    # Training step\n",
    "    for n, (input_image, target) in train_dataset.enumerate():\n",
    "        print('.', end='')\n",
    "        if (n+1) % 10000 == 0:\n",
    "            print()\n",
    "        train_step(input_image, target, epoch)\n",
    "    print()\n",
    "\n",
    "    # Test Setp\n",
    "    #\n",
    "    # TODO\n",
    "    #\n",
    "\n",
    "    # Saving (checkpointing) the model every 20 epochs\n",
    "    if (epoch + 1) % saveCheckpointAfterNEpochs == 0:\n",
    "        checkpoint.save(file_prefix=checkpoint_prefix)\n",
    "\n",
    "    print ('Time taken for epoch {} is {} sec\\n'.format(epoch + 1, time.time()-start))\n",
    "checkpoint.save(file_prefix=checkpoint_prefix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Quality test after training\")\n",
    "for example_input, example_target in test_dataset.take(5):\n",
    "    generate_images(generator, example_input, example_target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quality test after training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Quality test after training\")\n",
    "for example_input, example_target in test_dataset.take(5):\n",
    "    generate_images(generator, example_input, example_target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save The Last Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n",
      "INFO:tensorflow:Assets written to: ./models/model_generator_2022-07-03 15:49:16/assets\n"
     ]
    }
   ],
   "source": [
    "modelSave_dir = f\"./models/model_generator_{start_time}\"\n",
    "Path(modelSave_dir).mkdir(parents=True, exist_ok=True)\n",
    "generator.save(modelSave_dir)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "pix2pix.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}