{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"tpu1vmV38","dataSources":[{"sourceId":21755,"databundleVersionId":1475600,"sourceType":"competition"}],"dockerImageVersionId":30748,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# !pip install git+https://github.com/tensorflow/examples.git","metadata":{"execution":{"iopub.status.busy":"2024-08-16T09:11:52.930614Z","iopub.execute_input":"2024-08-16T09:11:52.930885Z","iopub.status.idle":"2024-08-16T09:12:02.031483Z","shell.execute_reply.started":"2024-08-16T09:11:52.930848Z","shell.execute_reply":"2024-08-16T09:12:02.030425Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# !pip install tensorflow-addons","metadata":{"execution":{"iopub.status.busy":"2024-08-16T12:55:00.897716Z","iopub.execute_input":"2024-08-16T12:55:00.898564Z","iopub.status.idle":"2024-08-16T12:55:04.509479Z","shell.execute_reply.started":"2024-08-16T12:55:00.898527Z","shell.execute_reply":"2024-08-16T12:55:04.508308Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport tensorflow as tf\nimport IPython.display as display\nfrom google.protobuf.json_format import MessageToJson\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nimport glob\n# import tensorflow_addons as tfa\nfrom PIL import Image\nimport zipfile\n# from tensorflow_examples.models.pix2pix import pix2pix\nimport time\n\nfrom kaggle_datasets import KaggleDatasets\nimport matplotlib.pyplot as plt\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-08-17T12:26:55.071180Z","iopub.execute_input":"2024-08-17T12:26:55.071887Z","iopub.status.idle":"2024-08-17T12:27:04.594265Z","shell.execute_reply.started":"2024-08-17T12:26:55.071840Z","shell.execute_reply":"2024-08-17T12:27:04.593175Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"try:\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.TPUStrategy(tpu)\nexcept:\n    strategy = tf.distribute.get_strategy()\nprint('Number of replicas:', strategy.num_replicas_in_sync)\n\nAUTOTUNE = tf.data.AUTOTUNE\n    \nprint(tf.__version__)","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:04.595938Z","iopub.execute_input":"2024-08-17T12:27:04.598204Z","iopub.status.idle":"2024-08-17T12:27:13.220236Z","shell.execute_reply.started":"2024-08-17T12:27:04.598165Z","shell.execute_reply":"2024-08-17T12:27:13.219158Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"GCS_PATH = KaggleDatasets().get_gcs_path()\nGCS_PATH","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:14.533040Z","iopub.execute_input":"2024-08-17T12:27:14.533436Z","iopub.status.idle":"2024-08-17T12:27:14.542809Z","shell.execute_reply.started":"2024-08-17T12:27:14.533404Z","shell.execute_reply":"2024-08-17T12:27:14.541827Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"MONET_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/monet_tfrec/*.tfrec'))\nprint('Monet TFRecord Files:', len(MONET_FILENAMES))\n\nPHOTO_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/photo_tfrec/*.tfrec'))\nprint('Photo TFRecord Files:', len(PHOTO_FILENAMES))","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:15.061556Z","iopub.execute_input":"2024-08-17T12:27:15.061918Z","iopub.status.idle":"2024-08-17T12:27:15.078342Z","shell.execute_reply.started":"2024-08-17T12:27:15.061888Z","shell.execute_reply":"2024-08-17T12:27:15.077121Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# raw_image_dataset = tf.data.TFRecordDataset('/kaggle/input/gan-getting-started/monet_tfrec/monet16-60.tfrec')\n\n# Create a dictionary describing the features.\n\nIMAGE_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, [*IMAGE_SIZE, 3])\n    return image\n\ndef read_tfrecord(example):\n    tfrecord_format = {\n        \"image_name\": tf.io.FixedLenFeature([], tf.string),\n        \"image\": tf.io.FixedLenFeature([], tf.string),\n        \"target\": tf.io.FixedLenFeature([], tf.string)\n    }\n    example = tf.io.parse_single_example(example, tfrecord_format)\n    image = decode_image(example['image'])\n    return image\ndef load_dataset(filenames, labeled=True, ordered=False):\n    dataset = tf.data.TFRecordDataset(filenames)\n    dataset = dataset.map(read_tfrecord, num_parallel_calls=AUTOTUNE)\n    return dataset","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:15.836076Z","iopub.execute_input":"2024-08-17T12:27:15.836472Z","iopub.status.idle":"2024-08-17T12:27:15.843597Z","shell.execute_reply.started":"2024-08-17T12:27:15.836426Z","shell.execute_reply":"2024-08-17T12:27:15.842698Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"buffer_size=10000\nwith strategy.scope():\n    monet_ds = load_dataset(MONET_FILENAMES, labeled=True).shuffle(buffer_size).repeat().batch(strategy.num_replicas_in_sync).prefetch(AUTOTUNE)\n    photo_ds = load_dataset(PHOTO_FILENAMES, labeled=True).shuffle(buffer_size).repeat().batch(strategy.num_replicas_in_sync).prefetch(AUTOTUNE)\n# dataset=tf.data.Dataset.zip()","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:16.347416Z","iopub.execute_input":"2024-08-17T12:27:16.347813Z","iopub.status.idle":"2024-08-17T12:27:16.498675Z","shell.execute_reply.started":"2024-08-17T12:27:16.347780Z","shell.execute_reply":"2024-08-17T12:27:16.497494Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# dataset_length = [i for i,_ in enumerate(photo_ds)][-1] + 1\n# dataset_length","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:16.618366Z","iopub.execute_input":"2024-08-17T12:27:16.618721Z","iopub.status.idle":"2024-08-17T12:27:16.622327Z","shell.execute_reply.started":"2024-08-17T12:27:16.618683Z","shell.execute_reply":"2024-08-17T12:27:16.621485Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# example_monet = next(iter(monet_ds))\n# example_photo = next(iter(photo_ds))","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:17.146369Z","iopub.execute_input":"2024-08-17T12:27:17.146747Z","iopub.status.idle":"2024-08-17T12:27:17.150245Z","shell.execute_reply.started":"2024-08-17T12:27:17.146714Z","shell.execute_reply":"2024-08-17T12:27:17.149252Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# OUTPUT_CHANNELS = 3\n# with strategy.scope():\n#     generator_g = pix2pix.unet_generator(OUTPUT_CHANNELS, norm_type='instancenorm')\n#     generator_f = pix2pix.unet_generator(OUTPUT_CHANNELS, norm_type='instancenorm')\n\n#     discriminator_x = pix2pix.discriminator(norm_type='instancenorm', target=False)\n#     discriminator_y = pix2pix.discriminator(norm_type='instancenorm', target=False)","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:17.595569Z","iopub.execute_input":"2024-08-17T12:27:17.595918Z","iopub.status.idle":"2024-08-17T12:27:17.599661Z","shell.execute_reply.started":"2024-08-17T12:27:17.595884Z","shell.execute_reply":"2024-08-17T12:27:17.598696Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Weights initializer for the layers.\nkernel_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n# Gamma initializer for instance normalization.\ngamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n# Size of the random crops to be used during training.\ninput_img_size = (256, 256, 3)\nclass ReflectionPadding2D(layers.Layer):\n    \"\"\"Implements 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 = tuple(padding)\n        super().__init__(**kwargs)\n\n    def call(self, input_tensor, mask=None):\n        padding_width, padding_height = self.padding\n        padding_tensor = [\n            [0, 0],\n            [padding_height, padding_height],\n            [padding_width, padding_width],\n            [0, 0],\n        ]\n        return tf.pad(input_tensor, padding_tensor, mode=\"REFLECT\")\n\n\ndef residual_block(\n    x,\n    activation,\n    kernel_initializer=kernel_init,\n    kernel_size=(3, 3),\n    strides=(1, 1),\n    padding=\"valid\",\n    gamma_initializer=gamma_init,\n    use_bias=False,\n):\n    dim = x.shape[-1]\n    input_tensor = x\n\n    x = ReflectionPadding2D()(input_tensor)\n    x = layers.Conv2D(\n        dim,\n        kernel_size,\n        strides=strides,\n        kernel_initializer=kernel_initializer,\n        padding=padding,\n        use_bias=use_bias,\n    )(x)\n    x = tf.keras.layers.GroupNormalization(gamma_initializer=gamma_initializer,groups=-1)(x)\n    x = activation(x)\n\n    x = ReflectionPadding2D()(x)\n    x = layers.Conv2D(\n        dim,\n        kernel_size,\n        strides=strides,\n        kernel_initializer=kernel_initializer,\n        padding=padding,\n        use_bias=use_bias,\n    )(x)\n    x = tf.keras.layers.GroupNormalization(gamma_initializer=gamma_initializer,groups=-1)(x)\n    x = layers.add([input_tensor, x])\n    return x\n\n\ndef downsample(\n    x,\n    filters,\n    activation,\n    kernel_initializer=kernel_init,\n    kernel_size=(3, 3),\n    strides=(2, 2),\n    padding=\"same\",\n    gamma_initializer=gamma_init,\n    use_bias=False,\n):\n    x = layers.Conv2D(\n        filters,\n        kernel_size,\n        strides=strides,\n        kernel_initializer=kernel_initializer,\n        padding=padding,\n        use_bias=use_bias,\n    )(x)\n    x = tf.keras.layers.GroupNormalization(gamma_initializer=gamma_initializer,groups=-1)(x)\n    if activation:\n        x = activation(x)\n    return x\n\n\ndef upsample(\n    x,\n    filters,\n    activation,\n    kernel_size=(3, 3),\n    strides=(2, 2),\n    padding=\"same\",\n    kernel_initializer=kernel_init,\n    gamma_initializer=gamma_init,\n    use_bias=False,\n):\n    x = layers.Conv2DTranspose(\n        filters,\n        kernel_size,\n        strides=strides,\n        padding=padding,\n        kernel_initializer=kernel_initializer,\n        use_bias=use_bias,\n    )(x)\n    x = tf.keras.layers.GroupNormalization(gamma_initializer=gamma_initializer,groups=-1)(x)\n    if activation:\n        x = activation(x)\n    return x","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:17.851416Z","iopub.execute_input":"2024-08-17T12:27:17.851771Z","iopub.status.idle":"2024-08-17T12:27:17.865005Z","shell.execute_reply.started":"2024-08-17T12:27:17.851738Z","shell.execute_reply":"2024-08-17T12:27:17.864149Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\ndef get_resnet_generator(\n    filters=64,\n    num_downsampling_blocks=2,\n    num_residual_blocks=9,\n    num_upsample_blocks=2,\n    gamma_initializer=gamma_init,\n    name=None,\n):\n    img_input = layers.Input(shape=input_img_size, name=name + \"_img_input\")\n    x = ReflectionPadding2D(padding=(3, 3))(img_input)\n    x = layers.Conv2D(filters, (7, 7), kernel_initializer=kernel_init, use_bias=False)(\n        x\n    )\n    x = tf.keras.layers.GroupNormalization(gamma_initializer=gamma_initializer,groups=-1)(x)\n    x = layers.Activation(\"relu\")(x)\n\n    # Downsampling\n    for _ in range(num_downsampling_blocks):\n        filters *= 2\n        x = downsample(x, filters=filters, activation=layers.Activation(\"relu\"))\n\n    # Residual blocks\n    for _ in range(num_residual_blocks):\n        x = residual_block(x, activation=layers.Activation(\"relu\"))\n\n    # Upsampling\n    for _ in range(num_upsample_blocks):\n        filters //= 2\n        x = upsample(x, filters, activation=layers.Activation(\"relu\"))\n\n    # Final block\n    x = ReflectionPadding2D(padding=(3, 3))(x)\n    x = layers.Conv2D(3, (7, 7), padding=\"valid\")(x)\n    x = layers.Activation(\"tanh\")(x)\n\n    model = keras.models.Model(img_input, x, name=name)\n    return model","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:18.125620Z","iopub.execute_input":"2024-08-17T12:27:18.125978Z","iopub.status.idle":"2024-08-17T12:27:18.133657Z","shell.execute_reply.started":"2024-08-17T12:27:18.125948Z","shell.execute_reply":"2024-08-17T12:27:18.132772Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_discriminator(\n    filters=64, kernel_initializer=kernel_init, num_downsampling=3, name=None\n):\n    img_input = layers.Input(shape=input_img_size, name=name + \"_img_input\")\n    x = layers.Conv2D(\n        filters,\n        (4, 4),\n        strides=(2, 2),\n        padding=\"same\",\n        kernel_initializer=kernel_initializer,\n    )(img_input)\n    x = layers.LeakyReLU(0.2)(x)\n\n    num_filters = filters\n    for num_downsample_block in range(3):\n        num_filters *= 2\n        if num_downsample_block < 2:\n            x = downsample(\n                x,\n                filters=num_filters,\n                activation=layers.LeakyReLU(0.2),\n                kernel_size=(4, 4),\n                strides=(2, 2),\n            )\n        else:\n            x = downsample(\n                x,\n                filters=num_filters,\n                activation=layers.LeakyReLU(0.2),\n                kernel_size=(4, 4),\n                strides=(1, 1),\n            )\n\n    x = layers.Conv2D(\n        1, (4, 4), strides=(1, 1), padding=\"same\", kernel_initializer=kernel_initializer\n    )(x)\n\n    model = keras.models.Model(inputs=img_input, outputs=x, name=name)\n    return model\n\nwith strategy.scope():\n    # Get the generators\n    gen_G = get_resnet_generator(name=\"generator_G\")\n    gen_F = get_resnet_generator(name=\"generator_F\")\n\n    # Get the discriminators\n    disc_X = get_discriminator(name=\"discriminator_X\")\n    disc_Y = get_discriminator(name=\"discriminator_Y\")","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:18.493583Z","iopub.execute_input":"2024-08-17T12:27:18.493944Z","iopub.status.idle":"2024-08-17T12:27:21.220327Z","shell.execute_reply.started":"2024-08-17T12:27:18.493914Z","shell.execute_reply":"2024-08-17T12:27:21.219071Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class GANMonitor(keras.callbacks.Callback):\n    \"\"\"A callback to generate and save images after each epoch\"\"\"\n\n    def __init__(self, num_img=4):\n        self.num_img = num_img\n\n    def on_epoch_end(self, epoch, logs=None):\n        _, ax = plt.subplots(4, 2, figsize=(12, 12))\n        for i, img in enumerate(test_horses.take(self.num_img)):\n            prediction = self.model.gen_G(img)[0].numpy()\n            prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n            img = (img[0] * 127.5 + 127.5).numpy().astype(np.uint8)\n\n#             ax[i, 0].imshow(img)\n#             ax[i, 1].imshow(prediction)\n#             ax[i, 0].set_title(\"Input image\")\n#             ax[i, 1].set_title(\"Translated image\")\n#             ax[i, 0].axis(\"off\")\n#             ax[i, 1].axis(\"off\")\n\n            prediction = keras.utils.array_to_img(prediction)\n            prediction.save(\n                \"generated_img_{i}_{epoch}.png\".format(i=i, epoch=epoch + 1)\n            )\n#         plt.show()\n#         plt.close()","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:21.222360Z","iopub.execute_input":"2024-08-17T12:27:21.222664Z","iopub.status.idle":"2024-08-17T12:27:21.229398Z","shell.execute_reply.started":"2024-08-17T12:27:21.222634Z","shell.execute_reply":"2024-08-17T12:27:21.228585Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class CycleGan(keras.Model):\n    def __init__(\n        self,\n        generator_G,\n        generator_F,\n        discriminator_X,\n        discriminator_Y,\n        lambda_cycle=10.0,\n        lambda_identity=0.5,\n        epochs=1\n    ):\n        super().__init__()\n        self.gen_G = generator_G\n        self.gen_F = generator_F\n        self.disc_X = discriminator_X\n        self.disc_Y = discriminator_Y\n        self.lambda_cycle = lambda_cycle\n        self.lambda_identity = lambda_identity\n        self.epochs=epochs\n\n    \n    def compile(\n        self,\n        gen_G_optimizer,\n        gen_F_optimizer,\n        disc_X_optimizer,\n        disc_Y_optimizer,\n        gen_loss_fn,\n        disc_loss_fn,\n        steps_per_execution\n    ):\n        super().compile(steps_per_execution=steps_per_execution)\n        self.gen_G_optimizer = gen_G_optimizer\n        self.gen_F_optimizer = gen_F_optimizer\n        self.disc_X_optimizer = disc_X_optimizer\n        self.disc_Y_optimizer = disc_Y_optimizer\n        self.generator_loss_fn = gen_loss_fn\n        self.discriminator_loss_fn = disc_loss_fn\n        self.cycle_loss_fn = keras.losses.MeanAbsoluteError()\n        self.identity_loss_fn = keras.losses.MeanAbsoluteError()\n        \n#         self.generator_loss_met = keras.metrics.Mean('generator_loss',dtype=tf.float32)\n#         self.discriminator_loss_met= keras.metrics.Mean('discriminator_loss',dtype=tf.float32)\n#         self.cycle_loss_met=keras.metrics.Mean('cycle_loss',dtype=tf.float32)\n#         self.identity_loss_met=keras.metrics.Mean('identity_loss',dtype=tf.float32)\n\n    @tf.function\n    def train_step(self, iterator):\n        # x is Horse and y is zebra\n        def step_fn(batch_data):\n            real_x, real_y = batch_data\n\n            # For CycleGAN, we need to calculate different\n            # kinds of losses for the generators and discriminators.\n            # We will perform the following steps here:\n            #\n            # 1. Pass real images through the generators and get the generated images\n            # 2. Pass the generated images back to the generators to check if we\n            #    can predict the original image from the generated image.\n            # 3. Do an identity mapping of the real images using the generators.\n            # 4. Pass the generated images in 1) to the corresponding discriminators.\n            # 5. Calculate the generators total loss (adversarial + cycle + identity)\n            # 6. Calculate the discriminators loss\n            # 7. Update the weights of the generators\n            # 8. Update the weights of the discriminators\n            # 9. Return the losses in a dictionary\n\n            with tf.GradientTape(persistent=True) as tape:\n                # Horse to fake zebra\n                fake_y = self.gen_G(real_x, training=True)\n                # Zebra to fake horse -> y2x\n                fake_x = self.gen_F(real_y, training=True)\n\n                # Cycle (Horse to fake zebra to fake horse): x -> y -> x\n                cycled_x = self.gen_F(fake_y, training=True)\n                # Cycle (Zebra to fake horse to fake zebra) y -> x -> y\n                cycled_y = self.gen_G(fake_x, training=True)\n\n                # Identity mapping\n                same_x = self.gen_F(real_x, training=True)\n                same_y = self.gen_G(real_y, training=True)\n\n                # Discriminator output\n                disc_real_x = self.disc_X(real_x, training=True)\n                disc_fake_x = self.disc_X(fake_x, training=True)\n\n                disc_real_y = self.disc_Y(real_y, training=True)\n                disc_fake_y = self.disc_Y(fake_y, training=True)\n\n                # Generator adversarial loss\n                gen_G_loss = self.generator_loss_fn(disc_fake_y)\n                gen_F_loss = self.generator_loss_fn(disc_fake_x)\n\n                # Generator cycle loss\n                cycle_loss_G = self.cycle_loss_fn(real_y, cycled_y) * self.lambda_cycle\n                cycle_loss_F = self.cycle_loss_fn(real_x, cycled_x) * self.lambda_cycle\n\n                # Generator identity loss\n                id_loss_G = (\n                    self.identity_loss_fn(real_y, same_y)\n                    * self.lambda_cycle\n                    * self.lambda_identity\n                )\n                id_loss_F = (\n                    self.identity_loss_fn(real_x, same_x)\n                    * self.lambda_cycle\n                    * self.lambda_identity\n                )\n\n                # Total generator loss\n                total_loss_G = gen_G_loss + cycle_loss_G + id_loss_G\n                total_loss_F = gen_F_loss + cycle_loss_F + id_loss_F\n\n                # Discriminator loss\n                disc_X_loss = self.discriminator_loss_fn(disc_real_x, disc_fake_x)\n                disc_Y_loss = self.discriminator_loss_fn(disc_real_y, disc_fake_y)\n\n            # Get the gradients for the generators\n            grads_G = tape.gradient(total_loss_G, self.gen_G.trainable_variables)\n            grads_F = tape.gradient(total_loss_F, self.gen_F.trainable_variables)\n\n            # Get the gradients for the discriminators\n            disc_X_grads = tape.gradient(disc_X_loss, self.disc_X.trainable_variables)\n            disc_Y_grads = tape.gradient(disc_Y_loss, self.disc_Y.trainable_variables)\n\n            # Update the weights of the generators\n            self.gen_G_optimizer.apply_gradients(\n                list(zip(grads_G, self.gen_G.trainable_variables))\n            )\n            self.gen_F_optimizer.apply_gradients(\n                zip(grads_F, self.gen_F.trainable_variables)\n            )\n\n            # Update the weights of the discriminators\n            self.disc_X_optimizer.apply_gradients(\n                zip(disc_X_grads, self.disc_X.trainable_variables)\n            )\n            self.disc_Y_optimizer.apply_gradients(\n                zip(disc_Y_grads, self.disc_Y.trainable_variables)\n            )\n#             self.generator_loss_met.update_state(tf.math.multiply(\n#                 tf.math.add(gen_G_loss,gen_F_loss) ,strategy.num_replicas_in_sync))\n    #         self.discriminator_loss_met.update_state((disc_X_loss+disc_Y_loss) * strategy.num_replicas_in_sync)\n    #         self.cycle_loss_met.update_state((cycle_loss_G+cycle_loss_F) * strategy.num_replicas_in_sync)\n    #         self.identity_loss_met.update_state((id_loss_G+id_loss_F) * strategy.num_replicas_in_sync)\n#             step_fn_log= 'generator loss: {}'\n#             tf.print(total_loss_G)\n            return total_loss_G,total_loss_F,disc_X_loss,disc_Y_loss\n            \n        total_loss_G,total_loss_F,disc_X_loss,disc_Y_loss=strategy.run(step_fn, args=(next(iterator),))\n#         self.generator_loss_met.reset_states()\n        return  {\n            \"G_loss\": total_loss_G,\n            \"F_loss\": total_loss_F,\n            \"D_X_loss\": disc_X_loss,\n            \"D_Y_loss\": disc_Y_loss,\n        }\n        ","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:29:26.434544Z","iopub.execute_input":"2024-08-17T12:29:26.435439Z","iopub.status.idle":"2024-08-17T12:29:26.452430Z","shell.execute_reply.started":"2024-08-17T12:29:26.435395Z","shell.execute_reply":"2024-08-17T12:29:26.451439Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nwith strategy.scope():\n    adv_loss_fn = keras.losses.MeanSquaredError()\n    # Define the loss function for the generators\n    def generator_loss_fn(fake):\n        fake_loss = adv_loss_fn(tf.ones_like(fake), fake)\n        return fake_loss\n\n# Callbacks\n# plotter = GANMonitor()\n# checkpoint_filepath = \"./model_checkpoints/cyclegan_checkpoints.{epoch:03d}\"\n# model_checkpoint_callback = keras.callbacks.ModelCheckpoint(\n#     filepath=checkpoint_filepath, save_weights_only=True\n# )\ntrain_dataset = strategy.distribute_datasets_from_function(\n    lambda _: tf.data.Dataset.zip((photo_ds, monet_ds)))\n\nphoto_dataset = strategy.distribute_datasets_from_function(\n    lambda _: photo_ds)","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:21.581743Z","iopub.execute_input":"2024-08-17T12:27:21.582536Z","iopub.status.idle":"2024-08-17T12:27:21.594498Z","shell.execute_reply.started":"2024-08-17T12:27:21.582497Z","shell.execute_reply":"2024-08-17T12:27:21.593610Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    # Define the loss function for the discriminators\n    def discriminator_loss_fn(real, fake):\n        real_loss = adv_loss_fn(tf.ones_like(real), real)\n        fake_loss = adv_loss_fn(tf.zeros_like(fake), fake)\n        return (real_loss + fake_loss) * 0.5","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:22.153980Z","iopub.execute_input":"2024-08-17T12:27:22.154861Z","iopub.status.idle":"2024-08-17T12:27:22.159937Z","shell.execute_reply.started":"2024-08-17T12:27:22.154820Z","shell.execute_reply":"2024-08-17T12:27:22.158914Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    # Create cycle gan model\n    cycle_gan_model = CycleGan(\n        generator_G=gen_G, generator_F=gen_F, discriminator_X=disc_X, discriminator_Y=disc_Y\n    )\n    gen_G_optimizer=tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    gen_F_optimizer=tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    disc_X_optimizer=tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    disc_Y_optimizer=tf.keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5)\n    # Compile the model\n    cycle_gan_model.compile(\n        gen_G_optimizer=gen_G_optimizer,\n        gen_F_optimizer=gen_F_optimizer,\n        disc_X_optimizer=disc_X_optimizer,\n        disc_Y_optimizer=disc_Y_optimizer,\n        gen_loss_fn=generator_loss_fn,\n        disc_loss_fn=discriminator_loss_fn,\n        steps_per_execution = 150,\n    )","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:27:24.140291Z","iopub.execute_input":"2024-08-17T12:27:24.141348Z","iopub.status.idle":"2024-08-17T12:27:24.696110Z","shell.execute_reply.started":"2024-08-17T12:27:24.141304Z","shell.execute_reply":"2024-08-17T12:27:24.694894Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_iterator=iter(train_dataset)\n# cycle_gan_model.fit(\n#     tf.data.Dataset.zip((photo_ds, monet_ds)),\n# #     train_iterator,\n#     epochs=1,\n#     steps_per_epoch=300,\n# #     callbacks=[plotter],\n# )\n# steps_per_epoch=int(dataset_length)\nfor epoch in range(1,6):\n    print('Epoch: {}/5'.format(epoch))\n    start_time = time.time()\n    for step in range(1,301):\n#         print('step: {}/300, loss: {}'.format(step,round(float(cycle_gan_model.generator_loss_met\n#                                                                .result()), 4)))\n        cycle_gan_model.train_step(train_iterator)\n#     cycle_gan_model.generator_loss_met.reset_states()    \n    end_time = time.time()\n    total_time=end_time-start_time\n    print(f\"elapsed time: {total_time} seconds\")\n        \n#     print('Current step: {}'.format(\n#       cycle_gan_model.gen_G_optimizer.iterations.numpy()))","metadata":{"execution":{"iopub.status.busy":"2024-08-17T12:29:30.296762Z","iopub.execute_input":"2024-08-17T12:29:30.297176Z","iopub.status.idle":"2024-08-17T12:29:51.004116Z","shell.execute_reply.started":"2024-08-17T12:29:30.297142Z","shell.execute_reply":"2024-08-17T12:29:51.002661Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# with strategy.scope():\n#     LAMBDA = 10\n\n#     loss_obj = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n#     def discriminator_loss(real, generated):\n#         real_loss = loss_obj(tf.ones_like(real), real)\n\n#         generated_loss = loss_obj(tf.zeros_like(generated), generated)\n\n#         total_disc_loss = real_loss + generated_loss\n\n#         return total_disc_loss * 0.5\n\n#     def generator_loss(generated):\n#         return loss_obj(tf.ones_like(generated), generated)\n\n#     def calc_cycle_loss(real_image, cycled_image):\n#         loss1 = tf.reduce_mean(tf.abs(real_image - cycled_image))\n\n#         return LAMBDA * loss1\n\n#     def identity_loss(real_image, same_image):\n#         loss = tf.reduce_mean(tf.abs(real_image - same_image))\n#         return LAMBDA * 0.5 * loss","metadata":{"execution":{"iopub.status.busy":"2024-08-17T08:38:29.314104Z","iopub.execute_input":"2024-08-17T08:38:29.314447Z","iopub.status.idle":"2024-08-17T08:38:29.321247Z","shell.execute_reply.started":"2024-08-17T08:38:29.314403Z","shell.execute_reply":"2024-08-17T08:38:29.320334Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# with strategy.scope():\n#     generator_g_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n#     generator_f_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n\n#     discriminator_x_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n#     discriminator_y_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)","metadata":{"execution":{"iopub.status.busy":"2024-08-17T08:38:29.791614Z","iopub.execute_input":"2024-08-17T08:38:29.791931Z","iopub.status.idle":"2024-08-17T08:38:29.826508Z","shell.execute_reply.started":"2024-08-17T08:38:29.791904Z","shell.execute_reply":"2024-08-17T08:38:29.825623Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# checkpoint_path = \"/kaggle/output/gan-getting-started/checkpoints/train\"\n\n# ckpt = tf.train.Checkpoint(generator_g=generator_g,\n#                            generator_f=generator_f,\n#                            discriminator_x=discriminator_x,\n#                            discriminator_y=discriminator_y,\n#                            generator_g_optimizer=generator_g_optimizer,\n#                            generator_f_optimizer=generator_f_optimizer,\n#                            discriminator_x_optimizer=discriminator_x_optimizer,\n#                            discriminator_y_optimizer=discriminator_y_optimizer)\n\n# ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)\n\n# # if a checkpoint exists, restore the latest checkpoint.\n# if ckpt_manager.latest_checkpoint:\n#   ckpt.restore(ckpt_manager.latest_checkpoint)\n#   print ('Latest checkpoint restored!!')","metadata":{"execution":{"iopub.status.busy":"2024-08-17T08:28:32.684297Z","iopub.execute_input":"2024-08-17T08:28:32.684738Z","iopub.status.idle":"2024-08-17T08:28:32.689336Z","shell.execute_reply.started":"2024-08-17T08:28:32.684701Z","shell.execute_reply":"2024-08-17T08:28:32.688544Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def generate_images(model, test_input):\n    prediction = model(test_input)\n\n    plt.figure(figsize=(12, 12))\n\n    display_list = [test_input[0], prediction[0]]\n    title = ['Input Image', 'Predicted Image']\n\n    for i in range(2):\n        plt.subplot(1, 2, i+1)\n        plt.title(title[i])\n        # getting the pixel values between [0, 1] to plot it.\n        plt.imshow(display_list[i] * 0.5 + 0.5)\n        plt.axis('off')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-17T08:46:46.410173Z","iopub.execute_input":"2024-08-17T08:46:46.410550Z","iopub.status.idle":"2024-08-17T08:46:46.416053Z","shell.execute_reply.started":"2024-08-17T08:46:46.410522Z","shell.execute_reply":"2024-08-17T08:46:46.415227Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# to_monet = cycle_gan_model.predict(example_photo)\n# to_photo = cycle_gan_model.predict(example_monet)\n# plt.figure(figsize=(8, 8))\n# contrast = 8\n\n# imgs = [example_photo, to_monet, example_monet, to_photo]\n# title = ['Photo', 'To Monet Style', 'Monet', 'To Original Photo']\n\n# for i in range(len(imgs)):\n#     plt.subplot(2, 2, i+1)\n#     plt.title(title[i])\n#     if i % 2 == 0:\n#         plt.imshow(imgs[i][0] * 0.5 + 0.5)\n#     else:\n#         plt.imshow(imgs[i][0] * 0.5 * contrast + 0.5)\n# plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-17T08:34:38.586162Z","iopub.execute_input":"2024-08-17T08:34:38.586450Z","iopub.status.idle":"2024-08-17T08:34:38.590497Z","shell.execute_reply.started":"2024-08-17T08:34:38.586423Z","shell.execute_reply":"2024-08-17T08:34:38.589593Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"_, ax = plt.subplots(5, 2, figsize=(12, 12))\nfor i, img in enumerate(photo_ds.take(5)):\n    prediction = gen_G(img,training=False)[0].numpy()\n    prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n    img = (img[0] * 127.5 + 127.5).numpy().astype(np.uint8)\n\n    ax[i, 0].imshow(img)\n    ax[i, 1].imshow(prediction)\n    ax[i, 0].set_title(\"Input Photo\")\n    ax[i, 1].set_title(\"Monet-esque\")\n    ax[i, 0].axis(\"off\")\n    ax[i, 1].axis(\"off\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-17T11:57:19.322276Z","iopub.execute_input":"2024-08-17T11:57:19.323180Z","iopub.status.idle":"2024-08-17T11:57:30.682290Z","shell.execute_reply.started":"2024-08-17T11:57:19.323133Z","shell.execute_reply":"2024-08-17T11:57:30.681075Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# EPOCHS = 50","metadata":{"execution":{"iopub.status.busy":"2024-08-16T09:18:00.986819Z","iopub.execute_input":"2024-08-16T09:18:00.987342Z","iopub.status.idle":"2024-08-16T09:18:00.991133Z","shell.execute_reply.started":"2024-08-16T09:18:00.987310Z","shell.execute_reply":"2024-08-16T09:18:00.990334Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# pix2pix_obj=pix2pix.Pix2pix(EPOCHS,True)\n# pix2pix_obj.generator_optimizer = tf.keras.optimizers.Adam(5e-4, beta_1=0.5)","metadata":{"execution":{"iopub.status.busy":"2024-08-16T09:18:01.325092Z","iopub.execute_input":"2024-08-16T09:18:01.325489Z","iopub.status.idle":"2024-08-16T09:18:01.759351Z","shell.execute_reply.started":"2024-08-16T09:18:01.325457Z","shell.execute_reply":"2024-08-16T09:18:01.758131Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"from IPython.display import clear_output\nfor epoch in range(EPOCHS):\n    start = time.time()\n\n    n = 0\n    for image_x, image_y in tf.data.Dataset.zip((photo_ds, monet_ds)):\n        pix2pix_obj.train_step(image_x, image_y)\n        if n % 10 == 0:\n              print ('.', end='')\n        n += 1\n\n    clear_output(wait=True)\n    # Using a consistent image (sample_horse) so that the progress of the model\n    # is clearly visible.\n#     generate_images(generator_g, example_photo)\n    generate_images(pix2pix_obj.generator, example_photo)\n\n    if (epoch + 1) % 5 == 0:\n        ckpt_save_path = ckpt_manager.save()\n        print ('Saving checkpoint for epoch {} at {}'.format(epoch+1,\n                                                         ckpt_save_path))\n\n    print ('Time taken for epoch {} is {} sec\\n'.format(epoch + 1,\n                                                      time.time()-start))","metadata":{"execution":{"iopub.status.busy":"2024-08-15T12:55:14.162748Z","iopub.execute_input":"2024-08-15T12:55:14.163147Z","iopub.status.idle":"2024-08-15T12:55:18.700675Z","shell.execute_reply.started":"2024-08-15T12:55:14.163112Z","shell.execute_reply":"2024-08-15T12:55:18.699303Z"}}},{"cell_type":"code","source":"# pix2pix_obj.train(tf.data.Dataset.zip((photo_ds, monet_ds)),\"\")","metadata":{"execution":{"iopub.status.busy":"2024-08-16T09:24:46.298905Z","iopub.execute_input":"2024-08-16T09:24:46.299766Z","iopub.status.idle":"2024-08-16T09:33:49.140996Z","shell.execute_reply.started":"2024-08-16T09:24:46.299725Z","shell.execute_reply":"2024-08-16T09:33:49.139706Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import PIL\n! mkdir ../images","metadata":{"execution":{"iopub.status.busy":"2024-08-17T10:41:36.115873Z","iopub.execute_input":"2024-08-17T10:41:36.116695Z","iopub.status.idle":"2024-08-17T10:41:36.354344Z","shell.execute_reply.started":"2024-08-17T10:41:36.116652Z","shell.execute_reply":"2024-08-17T10:41:36.352977Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"i = 1\nphoto_ds_test = load_dataset(PHOTO_FILENAMES, labeled=True).batch(1)\nfor img in photo_ds_test:\n    prediction = gen_G(img, training=False)[0].numpy()\n#     prediction = pix2pix_obj.generator(img,training=False)[0].numpy()\n    prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n    im = PIL.Image.fromarray(prediction)\n    im.save(\"../images/\" + str(i) + \".jpg\")\n    i += 1\n#     print(i)\nprint(f\"Completed :{i}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-17T11:27:35.232708Z","iopub.execute_input":"2024-08-17T11:27:35.233362Z","iopub.status.idle":"2024-08-17T11:27:38.009883Z","shell.execute_reply.started":"2024-08-17T11:27:35.233328Z","shell.execute_reply":"2024-08-17T11:27:38.008761Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import shutil\nshutil.make_archive(\"/kaggle/working/images\", 'zip', \"/kaggle/images\")","metadata":{},"execution_count":null,"outputs":[]}]}