conditional_gan.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# conditional gan\n",
    "\n",
    "https://keras.io/examples/generative/conditional_gan/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "from tensorflow_docs.vis import embed\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import imageio\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.8.0'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensorflow.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install -q git+https://github.com/tensorflow/docs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# consts\n",
    "batch_size = 64\n",
    "num_channels = 1\n",
    "num_classes = 10\n",
    "image_size = 28\n",
    "latent_dim = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape training data:  (70000, 28, 28, 1)\n",
      "shape training labels:  (70000, 10)\n"
     ]
    }
   ],
   "source": [
    "# get data\n",
    "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
    "all_digits = np.concatenate([x_train, x_test], axis=0)\n",
    "all_labels = np.concatenate([y_train, y_test], axis=0)\n",
    "\n",
    "# scale\n",
    "all_digits = all_digits.astype(\"float32\") / 255.0\n",
    "all_digits = np.reshape(all_digits, (-1, image_size, image_size, 1))\n",
    "all_labels = keras.utils.to_categorical(all_labels, num_classes)\n",
    "\n",
    "# data set\n",
    "dataset = tf.data.Dataset.from_tensor_slices((all_digits, all_labels))\n",
    "dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)\n",
    "\n",
    "print('shape training data: ', all_digits.shape)\n",
    "print('shape training labels: ', all_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "138 11\n"
     ]
    }
   ],
   "source": [
    "# add category to noise input\n",
    "generator_in_channels = latent_dim + num_classes\n",
    "discrimintaor_in_channels = num_channels + num_classes\n",
    "print(generator_in_channels, discrimintaor_in_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# discriminator\n",
    "discriminator = keras.Sequential(\n",
    "    [keras.layers.InputLayer((image_size, image_size, discrimintaor_in_channels)),\n",
    "        keras.layers.Conv2D(64, (3,3), strides=(2,2), padding=\"same\"),\n",
    "        keras.layers.LeakyReLU(alpha=0.2),\n",
    "        keras.layers.Conv2D(128, (3,3), strides=(2,2), padding=\"same\"),\n",
    "        keras.layers.LeakyReLU(alpha=0.2),\n",
    "        keras.layers.GlobalMaxPooling2D(),\n",
    "        keras.layers.Dense(1),\n",
    "    ],name=\"discriminator\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generator\n",
    "generator = keras.Sequential(\n",
    "    [keras.layers.InputLayer((generator_in_channels,)),\n",
    "        keras.layers.Dense(7 * 7 * generator_in_channels),\n",
    "        keras.layers.LeakyReLU(alpha=0.2),\n",
    "        layers.Reshape((7, 7, generator_in_channels)),\n",
    "        keras.layers.Conv2DTranspose(128, (4,4), strides=(2,2), padding=\"same\"),\n",
    "        keras.layers.LeakyReLU(alpha=0.2),\n",
    "        keras.layers.Conv2DTranspose(128, (4,4), strides=(2,2), padding=\"same\"),\n",
    "        keras.layers.LeakyReLU(alpha=0.2),\n",
    "        keras.layers.Conv2D(1, (7,7), padding=\"same\", activation=\"sigmoid\"),\n",
    "        ],name=\"generator\",)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cond gan model\n",
    "class ConditionalGAN(keras.Model):\n",
    "    def __init__(self, discriminator, generator, latent_dim) -> None:\n",
    "        super(ConditionalGAN, self).__init__()\n",
    "        self.discriminator = discriminator\n",
    "        self.generator = generator\n",
    "        self.latent_dim = latent_dim\n",
    "        self.gen_loss_tracker = keras.metrics.Mean(name=\"gener_loss\")\n",
    "        self.disc_loss_tracker = keras.metrics.Mean(name=\"discrim_loss\")\n",
    "    \n",
    "    @property\n",
    "    def metrics(self):\n",
    "        return [self.gen_loss_tracker, self.disc_loss_tracker]\n",
    "    \n",
    "    def compile(self, d_optimizer, g_optimizer, loss_fn):\n",
    "        super(ConditionalGAN, self).compile()\n",
    "        self.d_optimizer = d_optimizer\n",
    "        self.g_optimizer = g_optimizer\n",
    "        self.loss_fn = loss_fn\n",
    "    \n",
    "    def train_step(self, data):\n",
    "        # unpack data\n",
    "        real_images, one_hot_labels = data\n",
    "\n",
    "        # dummy dim\n",
    "        image_one_hot_labels = one_hot_labels[:, :, None, None]\n",
    "        image_one_hot_labels = tf.repeat(\n",
    "            image_one_hot_labels, repeats=[image_size*image_size]\n",
    "        )\n",
    "        image_one_hot_labels = tf.reshape(\n",
    "            image_one_hot_labels, (-1, image_size, image_size, num_classes)\n",
    "        )\n",
    "\n",
    "        # random points\n",
    "        batch_size = tf.shape(real_images)[0]\n",
    "        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))\n",
    "        random_latent_vectors = tf.concat([random_latent_vectors, one_hot_labels], axis=1)\n",
    "\n",
    "        # decode noise\n",
    "        generated_images = self.generator(random_latent_vectors)\n",
    "\n",
    "        # combine\n",
    "        fake_image_and_labels = tf.concat([generated_images, image_one_hot_labels], axis=-1)\n",
    "        real_image_and_labels = tf.concat([real_images, image_one_hot_labels], axis=-1)\n",
    "        combined_images = tf.concat([fake_image_and_labels, real_image_and_labels], axis=0)\n",
    "\n",
    "        # assmeble labels\n",
    "        labels = tf.concat(\n",
    "            [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0\n",
    "        )\n",
    "\n",
    "        # train discriminator\n",
    "        with tf.GradientTape() as tape:\n",
    "            predictions = self.discriminator(combined_images)\n",
    "            d_loss = self.loss_fn(labels, predictions)\n",
    "        grads = tape.gradient(d_loss, self.discriminator.trainable_weights)\n",
    "        self.d_optimizer.apply_gradients(\n",
    "            zip(grads, self.discriminator.trainable_weights)\n",
    "        )\n",
    "\n",
    "        # sample\n",
    "        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))\n",
    "        random_vector_labels = tf.concat(\n",
    "            [random_latent_vectors, one_hot_labels], axis=1\n",
    "        )\n",
    "\n",
    "        # assemble labels\n",
    "        misleading_labels = tf.zeros((batch_size, 1))\n",
    "\n",
    "        # train generator\n",
    "        with tf.GradientTape() as tape:\n",
    "            fake_images = self.generator(random_vector_labels)\n",
    "            fake_image_and_labels = tf.concat([fake_images, image_one_hot_labels], axis=-1)\n",
    "            predictions = self.discriminator(fake_image_and_labels)\n",
    "            g_loss = self.loss_fn(misleading_labels, predictions)\n",
    "        grads = tape.gradient(g_loss, self.generator.trainable_weights)\n",
    "        self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights))\n",
    "\n",
    "        # monitor loss\n",
    "        self.gen_loss_tracker.update_state(g_loss)\n",
    "        self.disc_loss_tracker.update_state(d_loss)\n",
    "        return {\"gener_loss\": self.gen_loss_tracker.result(), \n",
    "            \"discrim_loss\": self.disc_loss_tracker.result()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1094/1094 [==============================] - 1984s 2s/step - gener_loss: 1.4442 - discrim_loss: 0.4190\n",
      "Epoch 2/10\n",
      "1094/1094 [==============================] - 1838s 2s/step - gener_loss: 1.3046 - discrim_loss: 0.4924\n",
      "Epoch 3/10\n",
      "1094/1094 [==============================] - 1685s 2s/step - gener_loss: 1.3184 - discrim_loss: 0.4690\n",
      "Epoch 4/10\n",
      "1094/1094 [==============================] - 1370s 1s/step - gener_loss: 1.6242 - discrim_loss: 0.3623\n",
      "Epoch 5/10\n",
      "1094/1094 [==============================] - 1370s 1s/step - gener_loss: 1.5247 - discrim_loss: 0.4728\n",
      "Epoch 6/10\n",
      "1094/1094 [==============================] - 1539s 1s/step - gener_loss: 0.9526 - discrim_loss: 0.6141\n",
      "Epoch 7/10\n",
      "1094/1094 [==============================] - 1464s 1s/step - gener_loss: 0.8776 - discrim_loss: 0.6420\n",
      "Epoch 8/10\n",
      "1094/1094 [==============================] - 1817s 2s/step - gener_loss: 0.8361 - discrim_loss: 0.6550\n",
      "Epoch 9/10\n",
      "1094/1094 [==============================] - 2156s 2s/step - gener_loss: 0.8318 - discrim_loss: 0.6583\n",
      "Epoch 10/10\n",
      "1094/1094 [==============================] - 1661s 2s/step - gener_loss: 0.8078 - discrim_loss: 0.6661\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f8caf4efd30>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train cond gan\n",
    "cond_gan = ConditionalGAN(discriminator, generator, latent_dim=latent_dim)\n",
    "cond_gan.compile(\n",
    "    d_optimizer=keras.optimizers.Adam(learning_rate=0.0002),\n",
    "    g_optimizer=keras.optimizers.Adam(learning_rate=0.0002),\n",
    "    loss_fn=keras.losses.BinaryCrossentropy(from_logits=True),\n",
    ")\n",
    "\n",
    "cond_gan.fit(dataset, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BatchDataset element_spec=(TensorSpec(shape=(None, 28, 28, 1), dtype=tf.float32, name=None), TensorSpec(shape=(None, 10), dtype=tf.float32, name=None))>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interpolate\n",
    "from configparser import Interpolation\n",
    "\n",
    "\n",
    "trained_gen = cond_gan.generator\n",
    "\n",
    "# num intermediatee images\n",
    "num_interpolations = 9\n",
    "\n",
    "# sample noise\n",
    "interpolation_noise = tf.random.normal(shape=(1, latent_dim))\n",
    "interpolation_noise = tf.repeat(interpolation_noise, repeats=num_interpolations,)\n",
    "interpolation_noise = tf.reshape(interpolation_noise, (num_interpolations, latent_dim))\n",
    "\n",
    "def interpolate_class(first_number, second_number):\n",
    "    first_label = keras.utils.to_categorical([first_number], num_classes)\n",
    "    second_label = keras.utils.to_categorical([second_number], num_classes)\n",
    "    first_label = tf.cast(first_label, tf.float32)\n",
    "    second_label = tf.cast(second_label, tf.float32)\n",
    "\n",
    "    # interpolate\n",
    "    percent_second = tf.linspace(0.0, 1.0, num_interpolations)[:, None]\n",
    "    percent_second = tf.cast(percent_second, tf.float32)\n",
    "    interpolation_labels = (first_label * (1 - percent_second)) + (second_label * percent_second)\n",
    "\n",
    "    # combine\n",
    "    noise_and_labels = tf.concat([interpolation_noise, interpolation_labels], axis=1)\n",
    "    fake = trained_gen.predict(noise_and_labels)\n",
    "    return fake\n",
    " \n",
    "start_class = 1\n",
    "end_class = 5\n",
    "\n",
    "fake_images = interpolate_class(start_class, end_class)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/gif;base64,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\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fake_images *= 255.\n",
    "conv_images = fake_images.astype(np.uint8)\n",
    "conv_images = tf.image.resize(conv_images, (96, 96)).numpy().astype(np.uint8)\n",
    "imageio.mimsave('animation.gif', conv_images, fps=1)\n",
    "embed.embed_file('animation.gif')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drwxr-xr-x@ 11 sandy  staff   352B Oct 20 12:51 js_movies\n",
      "drwxr-xr-x@ 50 sandy  staff   1.6K Oct 20 12:51 RustPython\n",
      "-rw-r--r--@  1 sandy  staff    36K Oct 24 13:52 animation.gif\n",
      "-rw-r--r--   1 sandy  staff   6.0M Oct 24 16:13 cond_gan_weights.h5\n",
      "-rw-r--r--@  1 sandy  staff    65K Oct 24 16:14 condi_gan.ipynb\n"
     ]
    }
   ],
   "source": [
    "!ls -ltrh | tail -n5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cond_gan.save('cond_gan.tf')\n",
    "cond_gan.save_weights('cond_gan_weights.h5')\n",
    "cond_gan.save_spec('cond_gan_spec.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}