{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"## Import the libraries","metadata":{}},{"cell_type":"code","source":"from IPython.display import Image as ImageDisplay\nfrom kaggle_datasets import KaggleDatasets\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport PIL\nimport shutil\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.utils import plot_model\nimport tensorflow_addons as tfa","metadata":{"execution":{"iopub.status.busy":"2021-12-01T22:10:30.128684Z","iopub.execute_input":"2021-12-01T22:10:30.129245Z","iopub.status.idle":"2021-12-01T22:10:30.133784Z","shell.execute_reply.started":"2021-12-01T22:10:30.129208Z","shell.execute_reply":"2021-12-01T22:10:30.132926Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Enable the TPU cluster","metadata":{}},{"cell_type":"code","source":"# Enable the TPU cluster resolver.\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n    print('Device:', tpu.master())\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nexcept:\n    strategy = tf.distribute.get_strategy()\nprint('Number of replicas:', strategy.num_replicas_in_sync)\n\nAUTOTUNE = tf.data.experimental.AUTOTUNE\n    \nprint(tf.__version__)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:22.080034Z","iopub.execute_input":"2021-12-01T19:50:22.080363Z","iopub.status.idle":"2021-12-01T19:50:28.217028Z","shell.execute_reply.started":"2021-12-01T19:50:22.080331Z","shell.execute_reply":"2021-12-01T19:50:28.216415Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Import the Dataset\n#### Requires turning on the Internet on the Settings tab to work.","metadata":{}},{"cell_type":"code","source":"KAGGLE_GCS_PATH = KaggleDatasets().get_gcs_path()","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:33.665664Z","iopub.execute_input":"2021-12-01T19:50:33.665953Z","iopub.status.idle":"2021-12-01T19:50:34.275296Z","shell.execute_reply.started":"2021-12-01T19:50:33.665925Z","shell.execute_reply":"2021-12-01T19:50:34.274399Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"MONET_TFREC_IMAGE_FILES = tf.io.gfile.glob(str(KAGGLE_GCS_PATH + '/monet_tfrec/*.tfrec'))\nPHOTOGRAPH_TFREC_IMAGE_FILES = tf.io.gfile.glob(str(KAGGLE_GCS_PATH + '/photo_tfrec/*.tfrec'))\n\nprint(\"TFREC Records for Monet Images: %s\" % len(MONET_TFREC_IMAGE_FILES))\nprint(\"TFREC Records for Photograph Images: %s\" % len(PHOTOGRAPH_TFREC_IMAGE_FILES))","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:36.003811Z","iopub.execute_input":"2021-12-01T19:50:36.004841Z","iopub.status.idle":"2021-12-01T19:50:36.168820Z","shell.execute_reply.started":"2021-12-01T19:50:36.004775Z","shell.execute_reply":"2021-12-01T19:50:36.167786Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Image Helper functions","metadata":{}},{"cell_type":"code","source":"DATASET_IMAGE_SIZE = [256, 256]\n\ndef decode_image(image):\n    image = tf.image.decode_jpeg(image, channels=3)\n    image = (tf.cast(image, tf.float32) / 127.5) - 1\n    image = tf.reshape(image, [*DATASET_IMAGE_SIZE, 3])\n    return image\n\ndef tfrecord_read(sample):\n    tfrecord_format = {\"image_name\": tf.io.FixedLenFeature([], tf.string),\n                       \"image\": tf.io.FixedLenFeature([], tf.string),\n                       \"target\": tf.io.FixedLenFeature([], tf.string)}\n    sample = tf.io.parse_single_example(sample, tfrecord_format)\n    image = decode_image(sample[\"image\"])\n    return image\n\ndef load_dataset(filenames, labeled=True, ordered=False):\n    dataset = tf.data.TFRecordDataset(filenames)\n    dataset = dataset.map(tfrecord_read, num_parallel_calls=AUTOTUNE)\n    return dataset","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:40.427233Z","iopub.execute_input":"2021-12-01T19:50:40.427538Z","iopub.status.idle":"2021-12-01T19:50:40.438162Z","shell.execute_reply.started":"2021-12-01T19:50:40.427506Z","shell.execute_reply":"2021-12-01T19:50:40.437027Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Load the Dataset for the Model\n#### The format are tfrecords which can be cycled through an iterator. Unlike other methods, you cannot determine the length of the records without iterating through all the records.","metadata":{}},{"cell_type":"code","source":"monet_images_dataset = load_dataset(MONET_TFREC_IMAGE_FILES, labeled = True).batch(1)\nphotographs_images_dataset = load_dataset(PHOTOGRAPH_TFREC_IMAGE_FILES, labeled = True).batch(1)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:43.993209Z","iopub.execute_input":"2021-12-01T19:50:43.993525Z","iopub.status.idle":"2021-12-01T19:50:44.176444Z","shell.execute_reply.started":"2021-12-01T19:50:43.993497Z","shell.execute_reply":"2021-12-01T19:50:44.175749Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"num_records_monet = sum(1 for record in monet_images_dataset)\nnum_records_photographs = sum(1 for record in photographs_images_dataset)\nprint(\"# of monet images to train with: %s\" % num_records_monet)\nprint(\"# of photographs to predict: %s\" % num_records_photographs)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:50:52.019438Z","iopub.execute_input":"2021-12-01T19:50:52.020039Z","iopub.status.idle":"2021-12-01T19:51:06.622196Z","shell.execute_reply.started":"2021-12-01T19:50:52.020004Z","shell.execute_reply":"2021-12-01T19:51:06.621208Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"There are more photographs for the prediction than there are monet images. This is good, as the photographs transformations will be very useful in training and validating. The monet images are mostly for the model to learn patterns from and apply the transformation to the photos","metadata":{}},{"cell_type":"markdown","source":"## View a sample of the Dataset\n#### Iterate through some of the records and show a pyplot","metadata":{}},{"cell_type":"code","source":"sample_monet_image = next(iter(monet_images_dataset))\nsample_photograph_image = next(iter(photographs_images_dataset))\n\nplt.subplot(1,2,1)\nplt.title(\"Photograph\")\nplt.imshow((sample_photograph_image[0] * 0.5) + 0.5)\nplt.subplot(1,2,2)\nplt.title(\"Monet Artwork\")\nplt.imshow((sample_monet_image[0] * 0.5) + 0.5)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:10.048184Z","iopub.execute_input":"2021-12-01T19:51:10.048487Z","iopub.status.idle":"2021-12-01T19:51:10.499752Z","shell.execute_reply.started":"2021-12-01T19:51:10.048455Z","shell.execute_reply":"2021-12-01T19:51:10.498748Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Custom layers for the GAN Model (downsampling, upsampling, Reflection Padding)","metadata":{}},{"cell_type":"markdown","source":"#### Define the initializers used to feed the functions below ","metadata":{}},{"cell_type":"code","source":"# Weights initializer for the layers.\nkernel_weights_initializer = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n# Gamma initializer for instance normalization.\ngamma_normalization_initializer = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:14.485611Z","iopub.execute_input":"2021-12-01T19:51:14.485926Z","iopub.status.idle":"2021-12-01T19:51:14.491721Z","shell.execute_reply.started":"2021-12-01T19:51:14.485896Z","shell.execute_reply":"2021-12-01T19:51:14.490850Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Define the Downsampling, Upsampling and ConstantPadding2D layers","metadata":{}},{"cell_type":"code","source":"class PaddingConstant2D(layers.Layer):\n    '''Implements a Reflection Padding as a layer.\n\n    Args:\n        padding(tuple): Amount of padding for the\n        spatial dimensions.\n\n    Returns:\n        A padded tensor with the same type as the input tensor.\n    '''\n    \n    def __init__(self, padding = (1,1), **kwargs):\n        self.padding = padding\n        super(PaddingConstant2D, self).__init__(**kwargs)\n        \n    def call(self, input_tensor, mask = None):\n        padding_width, padding_height = self.padding\n        padding_tensor = [[0,0], [padding_height, padding_height], [padding_width, padding_width], [0,0]]\n        return tf.pad(input_tensor, padding_tensor, mode=\"CONSTANT\")\n\ndef downsampling_layers(model_layers, filters, activation, kernel_initializer=kernel_weights_initializer, kernel_size=(3,3),\n                        strides=(2,2), padding=\"same\", gamma_initializer=gamma_normalization_initializer, use_bias=False):\n    # Conv2D -> Activation (optional)\n    model_layers = layers.Conv2D(filters, kernel_size, strides=strides, kernel_initializer=kernel_initializer,\n                                 padding=padding, use_bias=use_bias)(model_layers)\n    \n    if activation:\n        model_layers = activation(model_layers)\n    return model_layers\n\ndef upsampling_layers(model_layers, filters, activation, kernel_initializer=kernel_weights_initializer, kernel_size=(3,3),\n                      strides=(2,2), padding=\"same\", gamma_initializer=gamma_normalization_initializer, use_bias=False):\n    # Conv2DTranspose -> Normalization -> Activation (optional)\n    model_layers = layers.Conv2DTranspose(filters, kernel_size, strides=strides, padding=padding, \n                                          kernel_initializer=kernel_initializer, use_bias=use_bias)(model_layers)\n    model_layers = tfa.layers.InstanceNormalization(gamma_initializer = gamma_initializer)(model_layers)\n    \n    if activation:\n        model_layers = activation(model_layers)\n    return model_layers\n\ndef residual_block_layers(model_layers, activation, kernel_initializer=kernel_weights_initializer,\n                          kernel_size=(3,3), strides=(1,1), padding=\"valid\",\n                          gamma_initializer=gamma_normalization_initializer, use_bias=False):\n    input_tensor = model_layers\n    num_output_filters = model_layers.shape[-1]\n\n    # Append all the layers here.\n    model_layers = PaddingConstant2D()(input_tensor)\n    model_layers = layers.Conv2D(num_output_filters, kernel_size, strides=strides, kernel_initializer=kernel_initializer,\n                                 padding=padding, use_bias=use_bias)(model_layers)\n    model_layers = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(model_layers)\n    model_layers = activation(model_layers)\n    model_layers = PaddingConstant2D()(model_layers)\n    model_layers = layers.Conv2D(num_output_filters, kernel_size, strides=strides, kernel_initializer=kernel_initializer,\n                                 padding=padding, use_bias=use_bias)(model_layers)\n    model_layers = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(model_layers)\n    model_layers = layers.add([input_tensor, model_layers])\n    return model_layers","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:17.151112Z","iopub.execute_input":"2021-12-01T19:51:17.151387Z","iopub.status.idle":"2021-12-01T19:51:17.169791Z","shell.execute_reply.started":"2021-12-01T19:51:17.151359Z","shell.execute_reply":"2021-12-01T19:51:17.168907Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Build the Generator and Discriminator Models","metadata":{}},{"cell_type":"code","source":"#-------------- Generator Model\ndef generator_model(filters=64, num_downsampling_blocks=2, num_residual_blocks=9, num_upsampling_blocks=2,\n                    kernel_initializer=kernel_weights_initializer, gamma_initializer=gamma_normalization_initializer,\n                    name=None):\n    image_layer_name = name + \"_image_input\"\n    image_input = layers.Input(shape=(256,256,3), name=image_layer_name)\n\n    # Define the Relu activation layer.\n    relu_activation_layer = layers.Activation(\"relu\")\n    \n    model_layers = PaddingConstant2D(padding=(3,3))(image_input)\n    model_layers = layers.Conv2D(filters, (7,7), kernel_initializer=kernel_initializer, use_bias=False)(model_layers)\n    model_layers = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(model_layers)\n    model_layers = relu_activation_layer(model_layers)\n    \n    # Add Downsampling layers\n    for _ in range(num_downsampling_blocks):\n        filters *= 2\n        model_layers = downsampling_layers(model_layers, filters=filters, activation=relu_activation_layer)\n        \n    # Add Residual block layers\n    for _ in range(num_residual_blocks):\n        model_layers = residual_block_layers(model_layers, activation=relu_activation_layer)\n        \n    # Add Upsampling layers\n    for _ in range(num_upsampling_blocks):\n        filters //= 2\n        model_layers = upsampling_layers(model_layers, filters=filters, activation=relu_activation_layer)\n        \n    # Final layers with Tanh activation.\n    model_layers = PaddingConstant2D(padding=(3,3))(model_layers)\n    model_layers = layers.Conv2D(3, (7,7), padding=\"valid\")(model_layers)\n    model_layers = layers.Activation(\"tanh\")(model_layers)\n    \n    model = keras.models.Model(image_input, model_layers, name=name)\n    return model\n\n\n#-------------- Discriminator Model\ndef discriminator_model(filters=64, kernel_initializer=kernel_weights_initializer, num_downsampling=3, name=None):\n    image_layer_name = name + \"_image_input\"\n    image_input = layers.Input(shape=(256,256,3), name=image_layer_name)\n    \n    # Define the leaky relu activation layer.\n    leaky_relu_activation_layer = layers.LeakyReLU(0.2)\n    \n    # Add a convolution layer with 2x2 strides followed by a leaky relu activation layer.\n    model_layers = layers.Conv2D(filters, (4,4), strides=(2,2), padding=\"same\", \n                                 kernel_initializer=kernel_initializer)(image_input)\n    model_layers = leaky_relu_activation_layer(model_layers)\n    \n    # Add Downsampling layers.\n    num_filters = filters\n    for num_downsample_block in range(3):\n        num_filters *= 2\n        if num_downsample_block < 2:\n            model_layers = downsampling_layers(model_layers, filters=num_filters, activation=leaky_relu_activation_layer,\n                                               kernel_size=(4,4), strides=(2,2))\n        else:\n            model_layers = downsampling_layers(model_layers, filters=num_filters, activation=leaky_relu_activation_layer,\n                                               kernel_size=(4,4),strides=(1,1))\n\n    # Finally add the convolution layer with 1x2 stride at the end of the model.\n    model_layers = layers.Conv2D(1, (4,4), strides=(1,1), padding=\"same\",\n                                 kernel_initializer=kernel_initializer)(model_layers)\n    model = keras.models.Model(image_input, model_layers, name = name)\n    return model","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:22.017711Z","iopub.execute_input":"2021-12-01T19:51:22.018290Z","iopub.status.idle":"2021-12-01T19:51:22.036671Z","shell.execute_reply.started":"2021-12-01T19:51:22.018253Z","shell.execute_reply":"2021-12-01T19:51:22.035727Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Enable the TPU on the Generator and Discriminator Models and Model Optimizers","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    # Define the generator and discriminator models\n    monet_generator = generator_model(name=\"generator_monet\")  # Transforms photos to monet\n    photo_generator = generator_model(name=\"generator_photo\")  # Transforms monet to photos\n    monet_discriminator = discriminator_model(name=\"discriminator_monet\") # Differentiates real monets and generated monets\n    photo_discriminator = discriminator_model(name=\"discriminator_photo\") # Differentiates real photos and generated photos\n    \n    # Define the optimizers for the models.\n    monet_generator_optimizer = keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    photo_generator_optimizer = keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    monet_discriminator_optimizer = keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    photo_discriminator_optimizer = keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:26.435611Z","iopub.execute_input":"2021-12-01T19:51:26.435887Z","iopub.status.idle":"2021-12-01T19:51:33.511371Z","shell.execute_reply.started":"2021-12-01T19:51:26.435859Z","shell.execute_reply":"2021-12-01T19:51:33.510532Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"converted_monet_image = monet_generator(sample_photograph_image)\n\nplt.subplot(1,2,1)\nplt.title(\"Original Photograph\")\nplt.imshow((sample_photograph_image[0] * 0.5) + 0.5)\nplt.subplot(1,2,2)\nplt.title(\"Generate Monet Artwork\")\nplt.imshow((converted_monet_image[0] * 0.5) + 0.5)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:35.505808Z","iopub.execute_input":"2021-12-01T19:51:35.506141Z","iopub.status.idle":"2021-12-01T19:51:36.218106Z","shell.execute_reply.started":"2021-12-01T19:51:35.506085Z","shell.execute_reply":"2021-12-01T19:51:36.217199Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can see that the model is initialized and ready to be trained.","metadata":{}},{"cell_type":"markdown","source":"## Build the Loss Functions to be ran on the TPU","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    def discriminator_loss(real, generated):\n        loss_real = keras.losses.BinaryCrossentropy(from_logits=True,\n                                                    reduction=tf.keras.losses.Reduction.NONE)(tf.ones_like(real), real)\n        loss_fake = keras.losses.BinaryCrossentropy(from_logits=True,\n                                                    reduction=tf.keras.losses.Reduction.NONE)(tf.zeros_like(generated), generated)\n        total_discriminator_loss = (loss_real + loss_fake) * 0.5\n        return total_discriminator_loss    \n\n    def generator_loss(generated):\n        gen_loss = keras.losses.BinaryCrossentropy(from_logits=True,\n                                                   reduction=tf.keras.losses.Reduction.NONE)(tf.ones_like(generated), generated)\n        return gen_loss\n\n    def cycle_loss(real_image, cycled_image, lamda):\n        loss = tf.reduce_mean(tf.abs(real_image - cycled_image))\n        cyc_loss = loss * lamda\n        return cyc_loss\n\n    def identity_loss(real_image, same_image, lamda1, lamda2):\n        loss = tf.reduce_mean(tf.abs(real_image - same_image))\n        id_loss = loss * lamda1 * lamda2\n        return id_loss","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:40.663690Z","iopub.execute_input":"2021-12-01T19:51:40.663985Z","iopub.status.idle":"2021-12-01T19:51:40.674736Z","shell.execute_reply.started":"2021-12-01T19:51:40.663955Z","shell.execute_reply":"2021-12-01T19:51:40.673611Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Build the CycleGAN Model","metadata":{}},{"cell_type":"code","source":"class CycleGAN(keras.Model):\n    def __init__(self, monet_generator, photo_generator,\n                 monet_discriminator, photo_discriminator,\n                 lambda_cycle=10.0, lambda_identity=0.5):\n        super(CycleGAN, self).__init__()\n        self.monet_generator = monet_generator\n        self.photo_generator = photo_generator\n        self.monet_discriminator = monet_discriminator\n        self.photo_discriminator = photo_discriminator\n        self.lambda_cycle = lambda_cycle\n        self.lambda_identity = lambda_identity\n        \n    def compile(self, monet_generator_optimizer, photo_generator_optimizer,\n                monet_discriminator_optimizer, photo_discriminator_optimizer,\n                generator_loss_function, discriminator_loss_function,\n                cycle_loss_function, identity_loss_function):\n        super(CycleGAN, self).compile()\n        self.monet_generator_optimizer = monet_generator_optimizer\n        self.photo_generator_optimizer = photo_generator_optimizer\n        self.monet_discriminator_optimizer = monet_discriminator_optimizer\n        self.photo_discriminator_optimizer = photo_discriminator_optimizer\n        self.generator_loss = generator_loss_function\n        self.discriminator_loss = discriminator_loss_function\n        self.cycle_loss = cycle_loss_function\n        self.identity_loss = identity_loss_function\n    \n    # The naming convention below is shared by keras.Model per epoch.\n    def train_step(self, batch):\n        monet_real, photo_real = batch\n        \n        with tf.GradientTape(persistent=True) as tape:\n            # photo --> monet --> photo\n            monet_fake = self.monet_generator(photo_real, training=True)\n            photo_cycled = self.photo_generator(monet_fake, training=True)\n            \n            # monet --> photo --> monet\n            photo_fake = self.photo_generator(monet_real, training=True)\n            monet_cycled = self.monet_generator(photo_fake, training=True)\n            \n            # Identity mapping. Attempt to reproduce the same source image for model accuracy comparison.\n            monet_approximate = self.monet_generator(monet_real, training=True)\n            photo_approximate = self.photo_generator(photo_real, training=True)\n            \n            # Discriminator outputs used for training.\n            discriminator_monet_real = self.monet_discriminator(monet_real, training=True)\n            discriminator_monet_fake = self.monet_discriminator(monet_fake, training=True)\n            discriminator_photo_real = self.photo_discriminator(photo_real, training=True)\n            discriminator_photo_fake = self.photo_discriminator(photo_fake, training=True)\n            \n            # Generator cycle losses\n            monet_cycled_loss = self.cycle_loss(monet_real, monet_cycled, self.lambda_cycle)\n            photo_cycled_loss = self.cycle_loss(photo_real, photo_cycled, self.lambda_cycle)\n            total_cycle_loss = monet_cycled_loss + photo_cycled_loss\n            \n            # Generator losses for the discriminator fake outputs.\n            monet_generator_loss = self.generator_loss(discriminator_monet_fake)\n            photo_generator_loss = self.generator_loss(discriminator_photo_fake)\n            \n            # Identity losses\n            monet_identity_loss = self.identity_loss(monet_real, monet_approximate,\n                                                     self.lambda_cycle, self.lambda_identity)\n            photo_identity_loss = self.identity_loss(photo_real, photo_approximate,\n                                                     self.lambda_cycle, self.lambda_identity)\n            total_identity_loss = monet_identity_loss + photo_identity_loss\n            \n            # Total generator losses\n            total_monet_generator_loss = monet_generator_loss + total_cycle_loss + total_identity_loss\n            total_photo_generator_loss = photo_generator_loss + total_cycle_loss + total_identity_loss\n            \n            # Discriminator losses\n            monet_discriminator_loss = self.discriminator_loss(discriminator_monet_real, discriminator_monet_fake)\n            photo_discriminator_loss = self.discriminator_loss(discriminator_photo_real, discriminator_photo_fake)\n        \n        # Calculate Gradients for Generator and Discriminators.\n        monet_generator_gradients = tape.gradient(total_monet_generator_loss,\n                                                  self.monet_generator.trainable_variables)\n        photo_generator_gradients = tape.gradient(total_photo_generator_loss,\n                                                  self.photo_generator.trainable_variables)\n        monet_discriminator_gradients = tape.gradient(monet_discriminator_loss,\n                                                      self.monet_discriminator.trainable_variables)\n        photo_discriminator_gradients = tape.gradient(photo_discriminator_loss,\n                                                      self.photo_discriminator.trainable_variables)\n        \n        self.monet_generator_optimizer.apply_gradients(zip(monet_generator_gradients,\n                                                           self.monet_generator.trainable_variables))\n        self.photo_generator_optimizer.apply_gradients(zip(photo_generator_gradients,\n                                                           self.photo_generator.trainable_variables))\n        self.monet_discriminator_optimizer.apply_gradients(zip(monet_discriminator_gradients,\n                                                               self.monet_discriminator.trainable_variables))\n        self.photo_discriminator_optimizer.apply_gradients(zip(photo_discriminator_gradients,\n                                                               self.photo_discriminator.trainable_variables))\n        \n        return {'monet_gen_loss': total_monet_generator_loss,\n                'photo_gen_loss': total_photo_generator_loss,\n                'monet_disc_loss': monet_discriminator_loss,\n                'photo_disc_loss': photo_discriminator_loss}","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:46.555551Z","iopub.execute_input":"2021-12-01T19:51:46.555864Z","iopub.status.idle":"2021-12-01T19:51:46.580608Z","shell.execute_reply.started":"2021-12-01T19:51:46.555835Z","shell.execute_reply":"2021-12-01T19:51:46.579524Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Compile the CycleGAN Model to run on the TPU","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    cycle_gan_model = CycleGAN(monet_generator, photo_generator, monet_discriminator, photo_discriminator)\n    cycle_gan_model.compile(monet_generator_optimizer=monet_generator_optimizer,\n                            photo_generator_optimizer=photo_generator_optimizer,\n                            monet_discriminator_optimizer=monet_discriminator_optimizer,\n                            photo_discriminator_optimizer=photo_discriminator_optimizer,\n                            generator_loss_function=generator_loss,\n                            discriminator_loss_function=discriminator_loss,\n                            cycle_loss_function=cycle_loss,\n                            identity_loss_function=identity_loss)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:51:52.284185Z","iopub.execute_input":"2021-12-01T19:51:52.284466Z","iopub.status.idle":"2021-12-01T19:51:52.342260Z","shell.execute_reply.started":"2021-12-01T19:51:52.284438Z","shell.execute_reply":"2021-12-01T19:51:52.341424Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Train the CycleGAN Model with 50 epochs\nThe model fitting will be stuck at Epoch 1/50 for sometime while loading to the TPU, after sometime, the TPU will kickstart and the training will begin.\n\nWith the TPU, each epoch takes approximately 2 minutes. This means 50 epochs takes about 120 minutes or about 2 hours.","metadata":{}},{"cell_type":"code","source":"history = cycle_gan_model.fit(tf.data.Dataset.zip((monet_images_dataset, photographs_images_dataset)),\n                              epochs=2)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T19:52:06.616071Z","iopub.execute_input":"2021-12-01T19:52:06.616768Z","iopub.status.idle":"2021-12-01T19:58:14.615128Z","shell.execute_reply.started":"2021-12-01T19:52:06.616720Z","shell.execute_reply":"2021-12-01T19:58:14.613993Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Visualize the Predictions from the monet_generator","metadata":{}},{"cell_type":"code","source":"# Show 10 photographs transformed to Monet artworks.\n_, axes = plt.subplots(10, 2, figsize=(20,20))\nfor idx, photo_image in enumerate(photographs_images_dataset.take(10)):\n    # Make sure training=False so that we don't affect the trained generator.\n    monet_of_photo = monet_generator(photo_image, training=False)[0].numpy()\n    \n    # Scale the Monet generated output and input photograph.\n    monet_of_photo = (monet_of_photo * 0.5) + 0.5\n    photo_image = ((photo_image[0] * 0.5) + 0.5).numpy()\n    \n    # Show the comparison images.\n    axes[idx, 0].imshow(photo_image)\n    axes[idx, 1].imshow(monet_of_photo)\n    axes[idx, 0].set_title(\"Photograph Input\")\n    axes[idx, 1].set_title(\"Generated Monet Output\")\n    axes[idx, 0].axis(\"off\")\n    axes[idx, 1].axis(\"off\")\n\nplt.tight_layout()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2021-12-01T15:36:13.552753Z","iopub.execute_input":"2021-12-01T15:36:13.553107Z","iopub.status.idle":"2021-12-01T15:36:18.885543Z","shell.execute_reply.started":"2021-12-01T15:36:13.553071Z","shell.execute_reply":"2021-12-01T15:36:18.88437Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Visualize the Architecture of the Full Model","metadata":{}},{"cell_type":"code","source":"plot_model(cycle_gan_model, to_file='monet_cycleGAN_model.png', show_shapes=True, show_layer_names=True)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T20:00:58.450217Z","iopub.execute_input":"2021-12-01T20:00:58.450547Z","iopub.status.idle":"2021-12-01T20:00:59.445167Z","shell.execute_reply.started":"2021-12-01T20:00:58.450515Z","shell.execute_reply":"2021-12-01T20:00:59.444134Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The model is special in that the layers are added in a custom way that isn't just adding layers to the model. For instance, the model trains the discriminator and generator models in each step, updating the gradients of the optimizer based on the losses calculated from the generator and discriminator models.","metadata":{}},{"cell_type":"markdown","source":"![cyclegan_model_view.png](attachment:f4cdf641-433f-4e75-afeb-70e076b1272f.png)","metadata":{},"attachments":{"f4cdf641-433f-4e75-afeb-70e076b1272f.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"## Visualize the Architectures of the Generator and Discriminator Models","metadata":{}},{"cell_type":"code","source":"plot_model(monet_generator, to_file='cycleGAN_generator_monet.png', show_shapes=True, show_layer_names=True)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T20:01:10.502216Z","iopub.execute_input":"2021-12-01T20:01:10.502559Z","iopub.status.idle":"2021-12-01T20:01:12.552063Z","shell.execute_reply.started":"2021-12-01T20:01:10.502514Z","shell.execute_reply":"2021-12-01T20:01:12.549252Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plot_model(monet_discriminator, to_file='cycleGAN_discriminator_monet.png', show_shapes=True, show_layer_names=True)","metadata":{"execution":{"iopub.status.busy":"2021-12-01T20:01:56.561896Z","iopub.execute_input":"2021-12-01T20:01:56.562270Z","iopub.status.idle":"2021-12-01T20:01:56.768331Z","shell.execute_reply.started":"2021-12-01T20:01:56.562230Z","shell.execute_reply":"2021-12-01T20:01:56.767243Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"","metadata":{}}]}