GAN_skin_cancer.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "GAN_skin_cancer.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0lO3lqRzPpoo"
      },
      "source": [
        "#Set-up enviroment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTcYYlWwLHp0"
      },
      "source": [
        "!rm -r sample_data/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 126
        },
        "id": "JBu9i7FnVAZx",
        "outputId": "0b5f2cc3-bf94-427a-b3cf-56ebc15e5e5e"
      },
      "source": [
        "#Download Kaggle dataset guide: https://www.kaggle.com/general/74235\n",
        "from google.colab import files\n",
        "files.upload()\n",
        "!pip install -q kaggle\n",
        "!mkdir ~/.kaggle   \n",
        "!mv ./kaggle.json ~/.kaggle\n",
        "!chmod 600 ~/.kaggle/kaggle.json\n",
        "!kaggle datasets download -d kmader/skin-cancer-mnist-ham10000"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8ad0bcc1-b23c-461c-9a9b-189298af5000\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8ad0bcc1-b23c-461c-9a9b-189298af5000\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving kaggle.json to kaggle.json\n",
            "Downloading skin-cancer-mnist-ham10000.zip to /content\n",
            "100% 5.20G/5.20G [02:05<00:00, 51.0MB/s]\n",
            "100% 5.20G/5.20G [02:05<00:00, 44.6MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0KRV3Cd2VFCw"
      },
      "source": [
        "!mkdir data \n",
        "!unzip skin-cancer-mnist-ham10000.zip -d data\n",
        "!mv data/HAM10000_metadata.csv ./HAM10000_metadata.csv\n",
        "!rm -r data/ham10000_images_part_1 data/ham10000_images_part_2 data/*.csv\n",
        "!mkdir weights grid logs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wGIcgRdJ4Ulr"
      },
      "source": [
        "Librerie"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7aD8Hlcc4Yjf"
      },
      "source": [
        "import os\n",
        "import cv2\n",
        "import sys\n",
        "import math\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.losses import BinaryCrossentropy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cZQAbkG09L2W"
      },
      "source": [
        "Path"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ExUzfynv4SP2"
      },
      "source": [
        "root = './'\n",
        "data_path = os.path.join(root, \"data\")\n",
        "weights_path = os.path.join(root, 'weights')\n",
        "grid_path = os.path.join(root, 'grid')\n",
        "logs_path = os.path.join(root, 'logs')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iS9cz7bKNWTf"
      },
      "source": [
        "#Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZStDOqElhrPJ"
      },
      "source": [
        "Histogram"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        },
        "id": "g83RGQnue0EY",
        "outputId": "4f59316a-5efd-4837-c75c-43a7445daf72"
      },
      "source": [
        "df = pd.read_csv ('HAM10000_metadata.csv', sep=',')\n",
        "df['dx'].value_counts().plot(kind='bar')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f1f8b5a2fd0>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VK5QVfkjhs_e"
      },
      "source": [
        "TFrecord"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KCU4BeCcRptH"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vwga07l8NkMh"
      },
      "source": [
        "#Based on: https://www.tensorflow.org/tutorials/load_data/tfrecord\n",
        "def bytes_feature(value):\n",
        "  \"\"\"Returns a bytes_list from a string / byte.\"\"\"\n",
        "  if isinstance(value, type(tf.constant(0))):\n",
        "    value = value.numpy()\n",
        "  return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\n",
        "\n",
        "def int64_feature(value):\n",
        "  \"\"\"Returns an int64_list from a bool / enum / int / uint.\"\"\"\n",
        "  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7-bz_KmBOQas"
      },
      "source": [
        "def format_example(name_img, img):\n",
        "  example = tf.train.Example(features=tf.train.Features(feature={\n",
        "\n",
        "    'image_name': bytes_feature(name_img.encode('utf-8')),  \n",
        "    'image_raw': bytes_feature(img.tobytes()), \n",
        "\n",
        "    'image_format': bytes_feature('jpg'.encode('utf-8')),\n",
        "    'image_height': int64_feature(img.shape[0]),\n",
        "    'image_width': int64_feature(img.shape[1]),\n",
        "\n",
        "  }))\n",
        "\n",
        "  return example"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ooBJG1YoNSsq",
        "outputId": "5fb93b85-a67d-45f7-efb2-f3695167a436"
      },
      "source": [
        "name_dataset = os.path.join(root, \"Skin_cancer.tfrecord\")\n",
        "tfrecord_writer = tf.compat.v1.python_io.TFRecordWriter(name_dataset)\n",
        "len_dataset = 0\n",
        "\n",
        "for dir in os.listdir(data_path):\n",
        "  for name_img in os.listdir(os.path.join(data_path, dir)):\n",
        "    len_dataset += 1\n",
        "    img = cv2.imread(os.path.join(data_path, dir, name_img), 1)\n",
        "    img = cv2.resize(img, dsize=(64, 64), interpolation=cv2.INTER_NEAREST).reshape(64, 64, 3)\n",
        "\n",
        "    example = format_example(name_img,img)\n",
        "    tfrecord_writer.write(example.SerializeToString())\n",
        "    sys.stdout.write(\"\\r<Creazione TFrecord> Analisi: \" + str(len_dataset))\n",
        "    sys.stdout.flush()\n",
        "\n",
        "tfrecord_writer.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<Creazione TFrecord> Analisi: 10015"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "skKvKQCZ-3s2"
      },
      "source": [
        "descriptor_dataset = {\n",
        "  'image_name': tf.io.FixedLenFeature([], tf.string), \n",
        "  'image_raw': tf.io.FixedLenFeature([], tf.string), \n",
        "  'image_format': tf.io.FixedLenFeature((), tf.string),  # .png/.jpg\n",
        "  'image_height': tf.io.FixedLenFeature([], tf.int64, default_value=64),\n",
        "  'image_width': tf.io.FixedLenFeature([], tf.int64, default_value=64),\n",
        "  }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43qX7u1ZLHwJ"
      },
      "source": [
        "#GAN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KL3rWvU8wW6X"
      },
      "source": [
        "def build_generator(latent_size):\n",
        "  model = Sequential()\n",
        "\n",
        "  # Input\n",
        "  model.add(Dense(4 * 4 * 256, activation=\"relu\", input_shape=(latent_size,)))\n",
        "  model.add(Reshape((4, 4, 256))) #[batch,4,4,256]\n",
        "  \n",
        "  # block_1\n",
        "  model.add(UpSampling2D())\n",
        "  model.add(Conv2D(128, kernel_size=3, padding=\"same\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(Activation(\"relu\")) #[batch,8,8,256]\n",
        "\n",
        "  # block_2\n",
        "  model.add(UpSampling2D())\n",
        "  model.add(Conv2D(128, kernel_size=3, padding=\"same\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(Activation(\"relu\")) #[batch,16,16,256]\n",
        "\n",
        "  # block_3\n",
        "  model.add(UpSampling2D())\n",
        "  model.add(Conv2D(128, kernel_size=3, padding=\"same\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(Activation(\"relu\")) #[batch,32,32,128]\n",
        "\n",
        "  # block_4\n",
        "  model.add(UpSampling2D())\n",
        "  model.add(Conv2D(128, kernel_size=3, padding=\"same\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(Activation(\"relu\")) #[batch,64,64,128]\n",
        "\n",
        "  # Output\n",
        "  model.add(Conv2D(3, kernel_size=3, padding=\"same\"))\n",
        "  model.add(Activation('tanh')) #[batch,64,64,3]\n",
        "\n",
        "  return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MbfcYLGhw3Ch"
      },
      "source": [
        "def build_discriminator(input_size):\n",
        "  model = Sequential()\n",
        "\n",
        "  # block_1\n",
        "  model.add(Conv2D(64, kernel_size=(3, 3), strides=2, padding='same', data_format=\"channels_last\", input_shape=input_size))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(LeakyReLU(alpha=0.2)) #[batch,32,32,64]\n",
        "\n",
        "  # block_2\n",
        "  model.add(Conv2D(128, kernel_size=(3, 3), strides=2, padding='same', data_format=\"channels_last\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(LeakyReLU(alpha=0.2)) #[batch,16,16,128]\n",
        "\n",
        "  # block_3\n",
        "  model.add(Conv2D(256, kernel_size=(3, 3), strides=2, padding='same', data_format=\"channels_last\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(LeakyReLU(alpha=0.2)) #[batch,8,8,256]\n",
        "\n",
        "  # block_4\n",
        "  model.add(Conv2D(512, kernel_size=(3, 3), strides=1, padding='same', data_format=\"channels_last\"))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(LeakyReLU(alpha=0.2)) #[batch,8,8,512]\n",
        "\n",
        "  # output\n",
        "  model.add(Flatten())\n",
        "  model.add(Dense(1, activation='sigmoid')) #[batch,1]\n",
        "\n",
        "  return model\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPc2RVxaECh9"
      },
      "source": [
        "def generator_loss(fake_output):\n",
        "  return tf.reduce_mean(BinaryCrossentropy(from_logits=True)(tf.ones_like(fake_output), fake_output))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FpGAc1VeDdHJ"
      },
      "source": [
        "def discriminator_loss(real_output, fake_output):\n",
        "  real_loss = tf.reduce_mean(BinaryCrossentropy(from_logits=True)(tf.ones_like(real_output), real_output))\n",
        "  fake_loss = tf.reduce_mean(BinaryCrossentropy(from_logits=True)(tf.zeros_like(fake_output), fake_output))\n",
        "  total_loss = (real_loss + fake_loss)\n",
        "  return total_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uRbM1Ki-B_iW"
      },
      "source": [
        "#Utils"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XUHaI8hmm2P7"
      },
      "source": [
        "def make_grid(tensor, nrow=8, padding=2,\n",
        "              normalize=False, scale_each=False):\n",
        "  \"\"\"Code based on https://github.com/pytorch/vision/blob/master/torchvision/utils.py\"\"\"\n",
        "  nmaps = tensor.shape[0]\n",
        "  xmaps = min(nrow, nmaps)  \n",
        "  ymaps = int(math.ceil(float(nmaps) / xmaps)) \n",
        "  height, width = int(tensor.shape[1] + padding), int(tensor.shape[2] + padding)\n",
        "  grid = np.zeros([height * ymaps + 1 + padding // 2, width * xmaps + 1 + padding // 2, 3], dtype=np.uint8)\n",
        "  k = 0\n",
        "  for y in range(ymaps):\n",
        "      for x in range(xmaps):\n",
        "          if k >= nmaps:\n",
        "              break\n",
        "          h, h_width = y * height + 1 + padding // 2, height - padding\n",
        "          w, w_width = x * width + 1 + padding // 2, width - padding\n",
        "\n",
        "          grid[h:h + h_width, w:w + w_width] = tensor[k]\n",
        "          k = k + 1\n",
        "  return grid\n",
        "  \n",
        "def save_image(tensor, filename, nrow=8, padding=2,\n",
        "               normalize=False, scale_each=False):\n",
        "  ndarr = make_grid(tensor, nrow=nrow, padding=padding,\n",
        "                    normalize=normalize, scale_each=scale_each)\n",
        "  cv2.imwrite(filename, ndarr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EIoyV2W35JXw"
      },
      "source": [
        "def preprocessamento(example_proto):\n",
        "  example = tf.io.parse_single_example(example_proto, descriptor_dataset)\n",
        "\n",
        "  w = example['image_width']\n",
        "  h = example['image_height']\n",
        "  image_raw = tf.reshape(tf.io.decode_raw(example['image_raw'], tf.uint8), [w, h, 3])\n",
        "  image_raw = tf.cast(image_raw, dtype=tf.float32)\n",
        "  image_raw_prepr = tf.math.divide(tf.math.subtract(image_raw, 127.5), 127.5)  #[-1,1]\n",
        "\n",
        "  return image_raw_prepr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nycg0GIqZ97h"
      },
      "source": [
        "#Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sUbdQ25Z-39c"
      },
      "source": [
        "def train_on_batch(generator, generator_optimizer,\n",
        "                   discriminator, discriminator_optimizer,\n",
        "                   noise_batch, real_imgs_batch):\n",
        "  \n",
        "  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
        "    fake_imgs_batch = generator(noise_batch) # Generator create the image\n",
        "\n",
        "    real_output = discriminator(real_imgs_batch) # Prediction on real\n",
        "    fake_output = discriminator(fake_imgs_batch) # Prediction on generated\n",
        "\n",
        "    # Loss\n",
        "    gen_loss = generator_loss(fake_output)\n",
        "    disc_loss = discriminator_loss(real_output, fake_output)\n",
        "\n",
        "  # Thanks to the subdivision of the optimizers we can train simultaneously \n",
        "  # the generator and the discriminator\n",
        "  discriminator_optimizer.minimize(disc_loss, var_list=discriminator.trainable_weights, tape=disc_tape)\n",
        "  generator_optimizer.minimize(gen_loss, var_list=generator.trainable_weights, tape=gen_tape)\n",
        "  \n",
        "  return gen_loss, disc_loss, real_output, fake_output, fake_imgs_batch"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BYbdI0RN1xLJ",
        "outputId": "d378e54b-e57f-493a-e247-0a596f330726"
      },
      "source": [
        "# -1.Training params\n",
        "input_size = [64, 64, 3]\n",
        "g_lr = 0.0001\n",
        "d_lr = 0.0002\n",
        "latent_size = 100\n",
        "batch_size = 32\n",
        "epochs = 50\n",
        "num_batches = len_dataset // batch_size\n",
        "\n",
        "# -2.Callbacks\n",
        "# --end epoch\n",
        "save_weights_epoch = 1\n",
        "# --end iteration\n",
        "save_grid_iteration = 50\n",
        "\n",
        "#######################################################################\n",
        "\n",
        "# Pipeline: Load dataset\n",
        "dataset = tf.data.TFRecordDataset(name_dataset)\n",
        "dataset = dataset.map(preprocessamento, num_parallel_calls=tf.data.AUTOTUNE)\n",
        "dataset = dataset.shuffle(len_dataset, reshuffle_each_iteration=True)\n",
        "dataset = dataset.batch(batch_size)\n",
        "dataset = dataset.prefetch(tf.data.AUTOTUNE)\n",
        "\n",
        "# Build GAN\n",
        "generator = build_generator(latent_size)\n",
        "generator_optimizer = tf.keras.optimizers.RMSprop(lr=g_lr, decay=3e-8)\n",
        "#generator_optimizer = tf.keras.optimizers.Adam(lr=0.000002)\n",
        "\n",
        "discriminator = build_discriminator(input_size)\n",
        "discriminator_optimizer = tf.keras.optimizers.RMSprop(lr=d_lr, decay=6e-8)\n",
        "#discriminator_optimizer = tf.keras.optimizers.Adam(lr=0.000004)\n",
        "\n",
        "# Metrics\n",
        "metric_accuracy_real = tf.keras.metrics.BinaryAccuracy(name='binary_accuracy', threshold=0.5)\n",
        "metric_accuracy_fake = tf.keras.metrics.BinaryAccuracy(name='binary_accuracy', threshold=0.5)\n",
        "\n",
        "history = {\"epoch\": 0,\n",
        "            \"loss_G\": [],\n",
        "            \"loss_D\": [],\n",
        "            \"acc_real\": [],\n",
        "            \"acc_fake\": []\n",
        "            }\n",
        "\n",
        "# Training\n",
        "for epoch in range(epochs):\n",
        "\n",
        "  dataset_iterator = iter(dataset)\n",
        "  array_gen_loss = np.empty(num_batches)\n",
        "  array_disc_loss = np.empty(num_batches)\n",
        "  metric_accuracy_real.reset_state()\n",
        "  metric_accuracy_fake.reset_state()\n",
        "\n",
        "  name_dir_grid = os.path.join(grid_path, str(epoch + 1))\n",
        "  if not os.path.exists(name_dir_grid):\n",
        "    os.mkdir(name_dir_grid)\n",
        "\n",
        "  for step in range(num_batches):\n",
        "    noise_batch = tf.random.normal(mean=0.0, stddev=1.0, shape=[batch_size, latent_size], dtype=tf.float32)\n",
        "    real_imgs_batch = next(dataset_iterator)\n",
        "\n",
        "    array_gen_loss[step], array_disc_loss[step], \\\n",
        "    real, fake, fake_imgs_batch = train_on_batch(generator, generator_optimizer,\n",
        "                                                  discriminator, discriminator_optimizer,\n",
        "                                                  noise_batch, real_imgs_batch)\n",
        "\n",
        "    # -Callbacks iteration\n",
        "    # --Metrics\n",
        "    # [TP/(TP+FP)]\n",
        "    metric_accuracy_real.update_state(tf.ones_like(real), real)\n",
        "    accuracy_real = metric_accuracy_real.result().numpy()\n",
        "    # [TN/(TN+FN)]\n",
        "    metric_accuracy_fake.update_state(tf.zeros_like(fake), fake)\n",
        "    accuracy_fake = metric_accuracy_fake.result().numpy()\n",
        "\n",
        "    # --Logs\n",
        "    logs = \"Epoch {epoch} step {step} / {iterations} --> gen_loss: {gen_loss:.4f}, disc_loss: {disc_loss:.4f}, acc_real:{acc_real:.4f}, acc_fake:{acc_fake:.4f}\".format(\n",
        "        epoch=epoch + 1,\n",
        "        step=step + 1,\n",
        "        iterations=len_dataset // batch_size,\n",
        "        gen_loss=np.mean(array_gen_loss[:step + 1]),\n",
        "        disc_loss=np.mean(array_disc_loss[:step + 1]),\n",
        "        acc_real=accuracy_real,\n",
        "        acc_fake=accuracy_fake\n",
        "    )\n",
        "    sys.stdout.write('\\r')\n",
        "    sys.stdout.write(logs)\n",
        "    sys.stdout.flush()\n",
        "\n",
        "    # --Save images\n",
        "    if step % save_grid_iteration == 0:\n",
        "      save_image((fake_imgs_batch * 127.5) + 127.5, os.path.join(name_dir_grid, \"imgs\" + str(step) + \".png\"),\n",
        "                    nrow=8)\n",
        "      \n",
        "  sys.stdout.write('\\n')\n",
        "\n",
        "  # -Callbacks epoch\n",
        "  # --Save weights\n",
        "  if epoch % save_weights_epoch == 0:\n",
        "    name_generator = \"Generator_{epoch}-acc_real_{acc_real}-acc_fake_{acc_fake}.hdf5\".format(\n",
        "        epoch=epoch + 1,\n",
        "        acc_real=accuracy_real,\n",
        "        acc_fake=accuracy_fake\n",
        "    )\n",
        "    name_discriminator = \"Discriminator_{epoch}.hdf5\".format(epoch=epoch + 1)\n",
        "    generator.save_weights(os.path.join(weights_path, name_generator))\n",
        "    discriminator.save_weights(os.path.join(weights_path, name_discriminator))\n",
        "  # --History\n",
        "  history['epoch'] = epoch + 1\n",
        "  history['loss_G'].append(np.mean(array_gen_loss))\n",
        "  history['loss_D'].append(np.mean(array_disc_loss))\n",
        "  history['acc_real'].append(accuracy_real)\n",
        "  history['acc_fake'].append(accuracy_fake)\n",
        "  np.save(os.path.join(logs_path,'history.npy'), history)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/rmsprop.py:130: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(RMSprop, self).__init__(name, **kwargs)\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py:1096: UserWarning: \"`binary_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
            "  return dispatch_target(*args, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1 step 312 / 312 --> gen_loss: 0.8882, disc_loss: 1.2660, acc_real:0.6354, acc_fake:0.6433\n",
            "Epoch 2 step 312 / 312 --> gen_loss: 1.0059, disc_loss: 1.2510, acc_real:0.6333, acc_fake:0.6574\n",
            "Epoch 3 step 312 / 312 --> gen_loss: 0.9920, disc_loss: 1.2344, acc_real:0.6505, acc_fake:0.6825\n",
            "Epoch 4 step 312 / 312 --> gen_loss: 1.2468, disc_loss: 1.1242, acc_real:0.6998, acc_fake:0.7598\n",
            "Epoch 5 step 312 / 312 --> gen_loss: 1.3284, disc_loss: 1.0456, acc_real:0.7052, acc_fake:0.8002\n",
            "Epoch 6 step 312 / 312 --> gen_loss: 1.4382, disc_loss: 1.0317, acc_real:0.7260, acc_fake:0.8021\n",
            "Epoch 7 step 312 / 312 --> gen_loss: 1.4545, disc_loss: 0.9881, acc_real:0.7304, acc_fake:0.8182\n",
            "Epoch 8 step 312 / 312 --> gen_loss: 1.5944, disc_loss: 0.9491, acc_real:0.7472, acc_fake:0.8195\n",
            "Epoch 9 step 312 / 312 --> gen_loss: 1.7582, disc_loss: 0.8568, acc_real:0.7696, acc_fake:0.8495\n",
            "Epoch 10 step 312 / 312 --> gen_loss: 1.7740, disc_loss: 0.8853, acc_real:0.7736, acc_fake:0.8602\n",
            "Epoch 11 step 312 / 312 --> gen_loss: 1.7818, disc_loss: 0.8521, acc_real:0.7756, acc_fake:0.8518\n",
            "Epoch 12 step 312 / 312 --> gen_loss: 1.7732, disc_loss: 0.8535, acc_real:0.7705, acc_fake:0.8484\n",
            "Epoch 13 step 312 / 312 --> gen_loss: 1.7794, disc_loss: 0.8341, acc_real:0.7708, acc_fake:0.8579\n",
            "Epoch 14 step 312 / 312 --> gen_loss: 1.7868, disc_loss: 0.8551, acc_real:0.7683, acc_fake:0.8441\n",
            "Epoch 15 step 312 / 312 --> gen_loss: 1.7712, disc_loss: 0.8497, acc_real:0.7734, acc_fake:0.8514\n",
            "Epoch 16 step 312 / 312 --> gen_loss: 1.7195, disc_loss: 0.8603, acc_real:0.7654, acc_fake:0.8458\n",
            "Epoch 17 step 312 / 312 --> gen_loss: 1.7266, disc_loss: 0.8436, acc_real:0.7645, acc_fake:0.8601\n",
            "Epoch 18 step 312 / 312 --> gen_loss: 1.7268, disc_loss: 0.9038, acc_real:0.7615, acc_fake:0.8590\n",
            "Epoch 19 step 312 / 312 --> gen_loss: 1.6239, disc_loss: 0.8909, acc_real:0.7426, acc_fake:0.8480\n",
            "Epoch 20 step 312 / 312 --> gen_loss: 1.5937, disc_loss: 0.8935, acc_real:0.7534, acc_fake:0.8252\n",
            "Epoch 21 step 312 / 312 --> gen_loss: 1.4940, disc_loss: 0.9408, acc_real:0.7466, acc_fake:0.8134\n",
            "Epoch 22 step 312 / 312 --> gen_loss: 1.3952, disc_loss: 0.9664, acc_real:0.7370, acc_fake:0.7981\n",
            "Epoch 23 step 312 / 312 --> gen_loss: 1.3814, disc_loss: 0.9893, acc_real:0.7268, acc_fake:0.7855\n",
            "Epoch 24 step 312 / 312 --> gen_loss: 1.3232, disc_loss: 1.0127, acc_real:0.7165, acc_fake:0.7866\n",
            "Epoch 25 step 312 / 312 --> gen_loss: 1.2899, disc_loss: 1.0190, acc_real:0.7207, acc_fake:0.7785\n",
            "Epoch 26 step 312 / 312 --> gen_loss: 1.3265, disc_loss: 1.0066, acc_real:0.7205, acc_fake:0.7860\n",
            "Epoch 27 step 312 / 312 --> gen_loss: 1.2714, disc_loss: 1.0370, acc_real:0.7085, acc_fake:0.7753\n",
            "Epoch 28 step 312 / 312 --> gen_loss: 1.2853, disc_loss: 1.0173, acc_real:0.7242, acc_fake:0.7758\n",
            "Epoch 29 step 312 / 312 --> gen_loss: 1.3089, disc_loss: 1.0219, acc_real:0.7250, acc_fake:0.7690\n",
            "Epoch 30 step 312 / 312 --> gen_loss: 1.2853, disc_loss: 1.0367, acc_real:0.7253, acc_fake:0.7685\n",
            "Epoch 31 step 312 / 312 --> gen_loss: 1.2836, disc_loss: 1.0305, acc_real:0.7216, acc_fake:0.7726\n",
            "Epoch 32 step 312 / 312 --> gen_loss: 1.2877, disc_loss: 1.0343, acc_real:0.7192, acc_fake:0.7674\n",
            "Epoch 33 step 312 / 312 --> gen_loss: 1.2720, disc_loss: 1.0314, acc_real:0.7101, acc_fake:0.7685\n",
            "Epoch 34 step 312 / 312 --> gen_loss: 1.2979, disc_loss: 1.0331, acc_real:0.7181, acc_fake:0.7661\n",
            "Epoch 35 step 312 / 312 --> gen_loss: 1.3139, disc_loss: 1.0283, acc_real:0.7126, acc_fake:0.7665\n",
            "Epoch 36 step 312 / 312 --> gen_loss: 1.3190, disc_loss: 1.0183, acc_real:0.7229, acc_fake:0.7773\n",
            "Epoch 37 step 312 / 312 --> gen_loss: 1.3604, disc_loss: 1.0150, acc_real:0.7267, acc_fake:0.7818\n",
            "Epoch 38 step 312 / 312 --> gen_loss: 1.3118, disc_loss: 1.0298, acc_real:0.7117, acc_fake:0.7718\n",
            "Epoch 39 step 312 / 312 --> gen_loss: 1.3005, disc_loss: 1.0197, acc_real:0.7149, acc_fake:0.7821\n",
            "Epoch 40 step 312 / 312 --> gen_loss: 1.3377, disc_loss: 1.0026, acc_real:0.7194, acc_fake:0.7831\n",
            "Epoch 41 step 312 / 312 --> gen_loss: 1.3610, disc_loss: 0.9935, acc_real:0.7253, acc_fake:0.7862\n",
            "Epoch 42 step 312 / 312 --> gen_loss: 1.3493, disc_loss: 0.9967, acc_real:0.7279, acc_fake:0.7972\n",
            "Epoch 43 step 312 / 312 --> gen_loss: 1.3706, disc_loss: 0.9901, acc_real:0.7228, acc_fake:0.7951\n",
            "Epoch 44 step 312 / 312 --> gen_loss: 1.3743, disc_loss: 0.9910, acc_real:0.7250, acc_fake:0.7910\n",
            "Epoch 45 step 312 / 312 --> gen_loss: 1.3867, disc_loss: 0.9738, acc_real:0.7310, acc_fake:0.8014\n",
            "Epoch 46 step 312 / 312 --> gen_loss: 1.4216, disc_loss: 0.9495, acc_real:0.7395, acc_fake:0.8049\n",
            "Epoch 47 step 312 / 312 --> gen_loss: 1.4087, disc_loss: 0.9588, acc_real:0.7398, acc_fake:0.8021\n",
            "Epoch 48 step 312 / 312 --> gen_loss: 1.4405, disc_loss: 0.9386, acc_real:0.7441, acc_fake:0.8072\n",
            "Epoch 49 step 312 / 312 --> gen_loss: 1.4432, disc_loss: 0.9429, acc_real:0.7431, acc_fake:0.8023\n",
            "Epoch 50 step 312 / 312 --> gen_loss: 1.4772, disc_loss: 0.9245, acc_real:0.7490, acc_fake:0.8147\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "vjr7Xv66RKm4",
        "outputId": "b768a913-ca62-43a0-f467-e792231a6fa8"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "history = np.load(os.path.join(logs_path,\"history.npy\"), allow_pickle=True)\n",
        "\n",
        "fig, axs = plt.subplots(2)\n",
        "fig.suptitle('Loss and Accuracy curves')\n",
        "\n",
        "axs[0].plot(history[()]['loss_G'], label='loss_G')\n",
        "axs[0].plot(history[()]['loss_D'], label='loss_D')\n",
        "axs[0].legend()\n",
        "\n",
        "axs[1].plot(history[()]['acc_real'], label='acc_real')\n",
        "axs[1].plot(history[()]['acc_fake'], label='acc_fake')\n",
        "axs[1].legend()\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rEgmbbuUiBt1"
      },
      "source": [
        "!zip weights.zip weights/* grid/*/* logs/*"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "76wQejZj75Np"
      },
      "source": [
        "#Inference"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e-1qM1iv7ZBc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 81
        },
        "outputId": "8e1d848c-93c9-46be-a63a-29c8d25ea611"
      },
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "\n",
        "input_size = [64, 64, 3]\n",
        "latent_size = 100\n",
        "batch_size = 1\n",
        "name_weights = \"Generator_40-acc_real_0.7193509340286255-acc_fake_0.7830528616905212.hdf5\"\n",
        "\n",
        "generator = build_generator(latent_size)\n",
        "generator.load_weights(os.path.join(weights_path, name_weights))\n",
        "\n",
        "noise_batch = tf.random.normal(mean=0.0, stddev=1.0, shape=[batch_size, latent_size], dtype=tf.float32)\n",
        "prediction = generator.predict(noise_batch)\n",
        "prediction = (prediction[0] * 127.5) + 127.5\n",
        "prediction = prediction.astype(dtype=np.uint8)\n",
        "\n",
        "cv2_imshow(prediction)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=64x64 at 0x7F1F11671050>"
            ]
          },
          "metadata": {}
        }
      ]
    }
  ]
}