{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"#@title\n!pip install tensorflow-addons==0.16.1\nimport tensorflow_addons as tfa","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-02-28T19:45:26.654826Z","iopub.execute_input":"2023-02-28T19:45:26.655301Z","iopub.status.idle":"2023-02-28T19:45:48.753173Z","shell.execute_reply.started":"2023-02-28T19:45:26.655258Z","shell.execute_reply":"2023-02-28T19:45:48.751695Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"Requirement already satisfied: tensorflow-addons==0.16.1 in /opt/conda/lib/python3.7/site-packages (0.16.1)\nRequirement already satisfied: typeguard>=2.7 in /opt/conda/lib/python3.7/site-packages (from tensorflow-addons==0.16.1) (2.13.3)\n\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n\u001b[0m","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/tensorflow_addons/utils/ensure_tf_install.py:67: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.6.0 and strictly below 2.9.0 (nightly versions are not supported). \n The versions of TensorFlow you are currently using is 2.11.0 and is not supported. \nSome things might work, some things might not.\nIf you were to encounter a bug, do not file an issue.\nIf you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. \nYou can find the compatibility matrix in TensorFlow Addon's readme:\nhttps://github.com/tensorflow/addons\n  UserWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.utils import plot_model\nimport tensorflow_addons as tfa\nimport tensorflow_datasets as tfds\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom functools import partial\nfrom albumentations import (\n    Compose, RandomBrightness, JpegCompression, HueSaturationValue, RandomContrast, HorizontalFlip,\n    Rotate\n)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:48.755546Z","iopub.execute_input":"2023-02-28T19:45:48.75641Z","iopub.status.idle":"2023-02-28T19:45:51.695781Z","shell.execute_reply.started":"2023-02-28T19:45:48.756362Z","shell.execute_reply":"2023-02-28T19:45:51.69441Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"try:\n    gpus = tf.config.experimental.list_physical_devices('GPU')\n    if gpus:\n        tf.config.experimental.set_visible_devices(gpus[0], 'GPU')\n        print('Device:', gpus[0])\n    else:\n        print('No GPU available')\n    strategy = tf.distribute.OneDeviceStrategy(\"GPU:0\")\nexcept:\n    print('failed GPU')\n    strategy = tf.distribute.get_strategy()\nprint('Number of replicas:', strategy.num_replicas_in_sync)\nAUTOTUNE = tf.data.AUTOTUNE","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:51.69773Z","iopub.execute_input":"2023-02-28T19:45:51.698829Z","iopub.status.idle":"2023-02-28T19:45:51.725985Z","shell.execute_reply.started":"2023-02-28T19:45:51.698782Z","shell.execute_reply":"2023-02-28T19:45:51.724427Z"},"trusted":true},"execution_count":4,"outputs":[{"name":"stdout","text":"No GPU available\nNumber of replicas: 1\n","output_type":"stream"}]},{"cell_type":"code","source":"MONET_FILENAMES = tf.io.gfile.glob('/kaggle/input/content-grey-2/*.tfrec')\nprint('Monet TFRecord Files:', len(MONET_FILENAMES))\n\nPHOTO_FILENAMES = tf.io.gfile.glob('/kaggle/input/gan-getting-started/photo_tfrec/*.tfrec')\nprint('Photo TFRecord Files:', len(PHOTO_FILENAMES))","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:51.729714Z","iopub.execute_input":"2023-02-28T19:45:51.730602Z","iopub.status.idle":"2023-02-28T19:45:51.756966Z","shell.execute_reply.started":"2023-02-28T19:45:51.730552Z","shell.execute_reply":"2023-02-28T19:45:51.755577Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stdout","text":"Monet TFRecord Files: 5\nPhoto TFRecord Files: 20\n","output_type":"stream"}]},{"cell_type":"code","source":"IMAGE_SIZE = [256, 256]\n\ndef normalize(image):\n    return (tf.cast(image, tf.float32) / 127.5) - 1\n\ndef decode_image(image):\n    image = tf.image.decode_jpeg(image, channels=3)\n    image = tf.reshape(image, [*IMAGE_SIZE, 3])\n    image = tf.image.resize(image, (320, 320), method='bilinear')\n    return image\n\ndef random_crop(image):\n    cropped_image = tf.image.random_crop(image, size=[320, 320, 3])\n    return cropped_image\n\ndef random_jitter(image):\n    image = tf.image.resize(image, [int(320*1.3), int(320*1.3)],\n                          method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n    image = random_crop(image)\n    return image\n\ndef flip(image):\n    return tf.image.flip_left_right(image)\n\ndef preprocess_image_train(image, label=None):\n    image = random_jitter(image)\n    return image\n\ndef read_tfrecord(example):\n    tfrecord_format = {\n        \"image\": 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\n\ndef load_dataset(filenames, labeled=False, ordered=False, repeats=200):\n    dataset = tf.data.TFRecordDataset(filenames)\n    dataset = dataset.map(read_tfrecord, num_parallel_calls=AUTOTUNE)\n    dataset = dataset.concatenate(dataset.map(flip, num_parallel_calls=AUTOTUNE).shuffle(100000))\n    dataset = dataset.concatenate(dataset.map(random_jitter, num_parallel_calls=AUTOTUNE).shuffle(10000, reshuffle_each_iteration=True).repeat(repeats))\n    dataset = dataset.map(normalize, num_parallel_calls=AUTOTUNE).shuffle(10000)\n    return dataset","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:51.758787Z","iopub.execute_input":"2023-02-28T19:45:51.759224Z","iopub.status.idle":"2023-02-28T19:45:51.774073Z","shell.execute_reply.started":"2023-02-28T19:45:51.75918Z","shell.execute_reply":"2023-02-28T19:45:51.772713Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"monet_ds = load_dataset(MONET_FILENAMES, labeled=True, repeats=50).batch(100, drop_remainder=True)\nphoto_ds = load_dataset(PHOTO_FILENAMES, labeled=True, repeats=2  ).batch(100, drop_remainder=True)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:51.775878Z","iopub.execute_input":"2023-02-28T19:45:51.77685Z","iopub.status.idle":"2023-02-28T19:45:52.325208Z","shell.execute_reply.started":"2023-02-28T19:45:51.776792Z","shell.execute_reply":"2023-02-28T19:45:52.323909Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"code","source":"OUTPUT_CHANNELS = 3\nLATENT_DIM = 1024\n\ndef downsample(filters, size, activation, dropout, strides=2,padding='same', apply_instancenorm=True, \n                                                   apply_dropout=False):\n    initializer = tf.random_normal_initializer(0., 0.02)\n    gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n    result = keras.Sequential()\n    result.add(layers.Conv2D(filters, size, strides, padding,\n                             kernel_initializer=initializer, use_bias=False))\n    #result.add(layers.MaxPool2D()) replaced\n\n    if apply_instancenorm:\n        result.add(tfa.layers.InstanceNormalization(gamma_initializer=gamma_init))\n    if apply_dropout:\n        result.add(layers.Dropout(dropout))\n    \n    if activation == \"leakyrelu\":\n        result.add(layers.LeakyReLU())\n    elif activation == \"relu\":\n        result.add(layers.ReLU())\n\n    return result","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.327348Z","iopub.execute_input":"2023-02-28T19:45:52.327946Z","iopub.status.idle":"2023-02-28T19:45:52.33826Z","shell.execute_reply.started":"2023-02-28T19:45:52.327885Z","shell.execute_reply":"2023-02-28T19:45:52.336724Z"},"trusted":true},"execution_count":8,"outputs":[]},{"cell_type":"code","source":"def upsample(filters, size, activation, dropout,strides=2,padding='same', apply_dropout=False):\n    initializer = tf.random_normal_initializer(0., 0.02)\n    gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n    result = keras.Sequential()\n    result.add(layers.Conv2DTranspose(filters, size, strides,\n                                      padding,\n                                      kernel_initializer=initializer,\n                                      use_bias=False))\n\n    result.add(tfa.layers.InstanceNormalization(gamma_initializer=gamma_init))\n\n    if apply_dropout:\n        result.add(layers.Dropout(dropout))\n\n    if activation == \"leakyrelu\":\n        result.add(layers.LeakyReLU())\n    elif activation == \"relu\":\n        result.add(layers.ReLU())\n\n    return result","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.340535Z","iopub.execute_input":"2023-02-28T19:45:52.341369Z","iopub.status.idle":"2023-02-28T19:45:52.354066Z","shell.execute_reply.started":"2023-02-28T19:45:52.341297Z","shell.execute_reply":"2023-02-28T19:45:52.35271Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"EPOCHS = 100\n\ngen_lrate = 0.0002\ndis_lrate = 0.0002\n\nbeta_1=0.9\nbeta_2=0.999\n\nlabel_real = .9","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.355691Z","iopub.execute_input":"2023-02-28T19:45:52.356217Z","iopub.status.idle":"2023-02-28T19:45:52.368507Z","shell.execute_reply.started":"2023-02-28T19:45:52.35618Z","shell.execute_reply":"2023-02-28T19:45:52.367094Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"def CycleGenerator():\n    inputs = layers.Input(shape=[256,256,3])\n\n    down_stack = [\n        downsample(64, 4, \"relu\", 0.8, apply_instancenorm=False, apply_dropout=True),\n        downsample(128, 4, \"relu\", 0.5, apply_dropout=True),\n        downsample(256, 4, \"relu\", 0.5, apply_dropout=True),\n        downsample(512, 4, \"relu\", 0.5),\n        downsample(512, 4, \"relu\", 0.5),\n        downsample(512, 4, \"relu\", 0.5),\n        downsample(512, 4, \"relu\", 0.5,strides=1, padding='valid'),\n        downsample(512, 4, \"relu\", 0.5),\n    ]\n\n    up_stack = [\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5,strides=1, padding='valid', apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=True),\n        upsample(256, 4, \"relu\", 0.5, apply_dropout=False),\n        upsample(128, 4, \"relu\", 0.5 ,apply_dropout=False), \n        upsample(64, 4, \"relu\", 0.5, apply_dropout=False),\n    ]\n\n    initializer = tf.random_normal_initializer(0., 0.02)\n    last = layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,\n                                  strides=2,\n                                  padding='same',\n                                  kernel_initializer=initializer,\n                                  activation='tanh')\n\n    x = inputs\n\n    skips = []\n    for down in down_stack:\n        x = down(x)\n        skips.append(x)\n\n    skips = reversed(skips[:-1])\n\n    for up, skip in zip(up_stack, skips):\n        x = up(x)\n        x = layers.Concatenate()([x, skip])\n\n    x = last(x)\n\n    return keras.Model(inputs=inputs, outputs=x)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.374878Z","iopub.execute_input":"2023-02-28T19:45:52.375368Z","iopub.status.idle":"2023-02-28T19:45:52.389906Z","shell.execute_reply.started":"2023-02-28T19:45:52.3753Z","shell.execute_reply":"2023-02-28T19:45:52.388641Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"def CycleGenerator_test():\n    inputs = layers.Input(shape=[256,256,3])\n\n    down_stack = [\n        downsample(64, 4, \"leakyrelu\", 0.8, apply_instancenorm=False, apply_dropout=False),\n        downsample(128, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n        downsample(256, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n        downsample(512, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n        downsample(512, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n        downsample(512, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n        downsample(512, 4, \"leakyrelu\", 0.5,strides=1, padding='valid', apply_dropout=False),\n        downsample(512, 4, \"leakyrelu\", 0.5, apply_dropout=False),\n    ]\n\n    up_stack = [\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5,strides=1, padding='valid', apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=True),\n        upsample(512, 4, \"relu\", 0.5, apply_dropout=False),\n        upsample(256, 4, \"relu\", 0.5, apply_dropout=False),\n        upsample(128, 4, \"relu\", 0.5, apply_dropout=False), \n        upsample(64, 4, \"relu\", 0.5, apply_dropout=False),\n    ]\n\n    initializer = tf.random_normal_initializer(0., 0.02)\n    last = layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,\n                                  strides=2,\n                                  padding='same',\n                                  kernel_initializer=initializer,\n                                  activation='tanh')\n\n    x = inputs\n\n    skips = []\n    for down in down_stack:\n        x = down(x)\n        skips.append(x)\n\n    skips = reversed(skips[:-1])\n\n    for up, skip in zip(up_stack, skips):\n        x = up(x)\n        x = layers.Concatenate()([x, skip])\n\n    x = last(x)\n\n    return keras.Model(inputs=inputs, outputs=x)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.391828Z","iopub.execute_input":"2023-02-28T19:45:52.392585Z","iopub.status.idle":"2023-02-28T19:45:52.408711Z","shell.execute_reply.started":"2023-02-28T19:45:52.392542Z","shell.execute_reply":"2023-02-28T19:45:52.407374Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"def CycleDiscriminator():\n    initializer = tf.random_normal_initializer(0., 0.02)\n    gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n    inp = layers.Input(shape=[256, 256, 3], name='input_image')\n\n    x = inp\n\n    down1 = downsample(64, 4, \"leakyrelu\", 0.8, apply_instancenorm = False, apply_dropout=True)(x) # (bs, 128, 128, 64)\n    down2 = downsample(128, 4, \"leakyrelu\", 0.5)(down1)\n    down3 = downsample(256, 4, \"leakyrelu\", 0.5)(down2)\n\n    zero_pad1 = layers.ZeroPadding2D()(down3)\n    conv = layers.Conv2D(512, 4, strides=1,\n                         kernel_initializer=initializer,\n                         use_bias=False)(zero_pad1)\n\n    norm1 = tfa.layers.InstanceNormalization(gamma_initializer=gamma_init)(conv)\n\n    leaky_relu = layers.LeakyReLU()(norm1)\n\n    zero_pad2 = layers.ZeroPadding2D()(leaky_relu)\n\n    last_conv = layers.Conv2D(1, 4, strides=1,\n                         kernel_initializer=initializer)(zero_pad2)\n\n    last_relu = layers.LeakyReLU(alpha=0.2)(last_conv)\n    last_pool = layers.Flatten()(last_relu)\n    last = layers.Dense(1, activation='sigmoid')(last_pool)\n\n    return tf.keras.Model(inputs=inp, outputs=last)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.410303Z","iopub.execute_input":"2023-02-28T19:45:52.410727Z","iopub.status.idle":"2023-02-28T19:45:52.4275Z","shell.execute_reply.started":"2023-02-28T19:45:52.410688Z","shell.execute_reply":"2023-02-28T19:45:52.42629Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"def CycleDiscriminator_test():\n    initializer = tf.random_normal_initializer(0., 0.02)\n    gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n    inp = layers.Input(shape=[256, 256, 3], name='input_image')\n\n    x = inp\n\n    down1 = downsample(64, 4, \"leakyrelu\", 0.8, apply_instancenorm = False, apply_dropout=False)(x) # (bs, 128, 128, 64)\n    down2 = downsample(128, 4, \"leakyrelu\", 0.5, apply_dropout=False)(down1)\n    down3 = downsample(256, 4, \"leakyrelu\", 0.5, apply_dropout=False)(down2)\n\n    zero_pad1 = layers.ZeroPadding2D()(down3)\n    conv = layers.Conv2D(512, 4, strides=1,\n                         kernel_initializer=initializer,\n                         use_bias=False)(zero_pad1)\n\n    norm1 = tfa.layers.InstanceNormalization(gamma_initializer=gamma_init)(conv)\n\n    leaky_relu = layers.LeakyReLU()(norm1)\n\n    zero_pad2 = layers.ZeroPadding2D()(leaky_relu)\n\n    last_conv = layers.Conv2D(1, 4, strides=1,\n                         kernel_initializer=initializer)(zero_pad2)\n\n    last_relu = layers.LeakyReLU(alpha=0.2)(last_conv)\n    last_pool = layers.Flatten()(last_relu)\n    last = layers.Dense(1, activation='sigmoid')(last_pool)\n\n    return tf.keras.Model(inputs=inp, outputs=last)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.428834Z","iopub.execute_input":"2023-02-28T19:45:52.429227Z","iopub.status.idle":"2023-02-28T19:45:52.445018Z","shell.execute_reply.started":"2023-02-28T19:45:52.429188Z","shell.execute_reply":"2023-02-28T19:45:52.443904Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    monet_cycle_generator = CycleGenerator_test() # Photos to Monet \n    photo_cycle_generator = CycleGenerator_test() #  Monet to Photos\n\n    monet_cycle_discriminator = CycleDiscriminator_test() \n    photo_cycle_discriminator = CycleDiscriminator_test() ","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:52.44643Z","iopub.execute_input":"2023-02-28T19:45:52.446805Z","iopub.status.idle":"2023-02-28T19:45:57.663464Z","shell.execute_reply.started":"2023-02-28T19:45:52.446768Z","shell.execute_reply":"2023-02-28T19:45:57.662256Z"},"trusted":true},"execution_count":15,"outputs":[]},{"cell_type":"code","source":"plot_model(monet_cycle_discriminator, show_shapes = True, show_layer_names = True)\n","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:57.664762Z","iopub.execute_input":"2023-02-28T19:45:57.665097Z","iopub.status.idle":"2023-02-28T19:45:58.075064Z","shell.execute_reply.started":"2023-02-28T19:45:57.665064Z","shell.execute_reply":"2023-02-28T19:45:58.073903Z"},"trusted":true},"execution_count":16,"outputs":[{"execution_count":16,"output_type":"execute_result","data":{"image/png":"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\n","text/plain":"<IPython.core.display.Image object>"},"metadata":{}}]},{"cell_type":"code","source":"class CycleGan(keras.Model):\n    def __init__(\n        self,\n        monet_generator,\n        photo_generator,\n        monet_discriminator,\n        photo_discriminator,\n        lambda_cycle=10,\n        label_real=.5\n    ):\n        super(CycleGan, self).__init__()\n        self.m_gen = monet_generator\n        self.p_gen = photo_generator\n        self.m_disc = monet_discriminator\n        self.p_disc = photo_discriminator\n        self.lambda_cycle = lambda_cycle\n        self.label_real = label_real\n        \n    def compile(\n        self,\n        m_gen_optimizer,\n        p_gen_optimizer,\n        m_disc_optimizer,\n        p_disc_optimizer,\n        gen_loss_fn,\n        disc_loss_fn,\n        cycle_loss_fn,\n        identity_loss_fn\n    ):\n        super(CycleGan, self).compile()\n        self.m_gen_optimizer = m_gen_optimizer\n        self.p_gen_optimizer = p_gen_optimizer\n        self.m_disc_optimizer = m_disc_optimizer\n        self.p_disc_optimizer = p_disc_optimizer\n        self.gen_loss_fn = gen_loss_fn\n        self.disc_loss_fn = disc_loss_fn\n        self.cycle_loss_fn = cycle_loss_fn\n        self.identity_loss_fn = identity_loss_fn\n        \n    def train_step(self, batch_data):\n        real_monet, real_photo = batch_data\n        \n        batch_size = tf.shape(real_photo)[0]\n        labels_real = tf.zeros((batch_size, 1)) + self.label_real\n        labels_real += 0.05 * tf.random.uniform(tf.shape(labels_real))        \n        \n        with tf.GradientTape(persistent=True) as tape:\n            # photo to monet back to photo\n            fake_monet = self.m_gen(real_photo, training=True)\n            cycled_photo = self.p_gen(fake_monet, training=True)\n\n            # monet to photo back to monet\n            fake_photo = self.p_gen(real_monet, training=True)\n            cycled_monet = self.m_gen(fake_photo, training=True)\n\n            # generating itself\n            same_monet = self.m_gen(real_monet, training=True)\n            same_photo = self.p_gen(real_photo, training=True)\n\n            # discriminator used to check, inputing real images\n            disc_real_monet = self.m_disc(real_monet, training=True)\n            disc_real_photo = self.p_disc(real_photo, training=True)\n\n            # discriminator used to check, inputing fake images\n            disc_fake_monet = self.m_disc(fake_monet, training=True)\n            disc_fake_photo = self.p_disc(fake_photo, training=True)\n\n            # evaluates generator loss\n            monet_gen_loss = self.gen_loss_fn(disc_real_monet, disc_fake_monet, labels_real)\n            photo_gen_loss = self.gen_loss_fn(disc_real_photo, disc_fake_photo, labels_real)\n\n            # evaluates total cycle consistency loss\n            total_cycle_loss = self.cycle_loss_fn(real_monet, cycled_monet, self.lambda_cycle) + self.cycle_loss_fn(real_photo, cycled_photo, self.lambda_cycle)\n\n            # evaluates total generator loss\n            total_monet_gen_loss = monet_gen_loss + total_cycle_loss + self.identity_loss_fn(real_monet, same_monet, self.lambda_cycle)\n            total_photo_gen_loss = photo_gen_loss + total_cycle_loss + self.identity_loss_fn(real_photo, same_photo, self.lambda_cycle)\n\n            # evaluates discriminator loss\n            monet_disc_loss = self.disc_loss_fn(disc_real_monet, disc_fake_monet, labels_real)\n            photo_disc_loss = self.disc_loss_fn(disc_real_photo, disc_fake_photo, labels_real)\n\n        # Calculate the gradients for generator and discriminator\n        monet_generator_gradients = tape.gradient(total_monet_gen_loss,\n                                                  self.m_gen.trainable_variables)\n        photo_generator_gradients = tape.gradient(total_photo_gen_loss,\n                                                  self.p_gen.trainable_variables)\n\n        monet_discriminator_gradients = tape.gradient(monet_disc_loss,\n                                                      self.m_disc.trainable_variables)\n        photo_discriminator_gradients = tape.gradient(photo_disc_loss,\n                                                      self.p_disc.trainable_variables)\n\n        # Apply the gradients to the optimizer\n        self.m_gen_optimizer.apply_gradients(zip(monet_generator_gradients,\n                                                 self.m_gen.trainable_variables))\n\n        self.p_gen_optimizer.apply_gradients(zip(photo_generator_gradients,\n                                                 self.p_gen.trainable_variables))\n\n        self.m_disc_optimizer.apply_gradients(zip(monet_discriminator_gradients,\n                                                  self.m_disc.trainable_variables))\n\n        self.p_disc_optimizer.apply_gradients(zip(photo_discriminator_gradients,\n                                                  self.p_disc.trainable_variables))\n        \n        return {\n            \"monet_gen_loss\": total_monet_gen_loss,\n            \"photo_gen_loss\": total_photo_gen_loss,\n            \"monet_disc_loss\": monet_disc_loss,\n            \"photo_disc_loss\": photo_disc_loss\n        }","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.077088Z","iopub.execute_input":"2023-02-28T19:45:58.077579Z","iopub.status.idle":"2023-02-28T19:45:58.104512Z","shell.execute_reply.started":"2023-02-28T19:45:58.07753Z","shell.execute_reply":"2023-02-28T19:45:58.103061Z"},"trusted":true},"execution_count":17,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    def discriminator_loss(predictions_real, predictions_gen, labels_real):\n        return (tf.reduce_mean((predictions_gen  - tf.reduce_mean(predictions_real) + labels_real) ** 2) +\n                tf.reduce_mean((predictions_real - tf.reduce_mean(predictions_gen)  - labels_real) ** 2))/2\n    \n    def generator_loss(predictions_real, predictions_gen, labels_real):\n        return (tf.reduce_mean((predictions_real - tf.reduce_mean(predictions_gen)  + labels_real) ** 2) +\n                tf.reduce_mean((predictions_gen  - tf.reduce_mean(predictions_real) - labels_real) ** 2)) / 2","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.106663Z","iopub.execute_input":"2023-02-28T19:45:58.107149Z","iopub.status.idle":"2023-02-28T19:45:58.120515Z","shell.execute_reply.started":"2023-02-28T19:45:58.1071Z","shell.execute_reply":"2023-02-28T19:45:58.119287Z"},"trusted":true},"execution_count":18,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    def calc_cycle_loss(real_image, cycled_image, LAMBDA):\n        loss1 = tf.reduce_mean(tf.abs(real_image - cycled_image))\n\n        return LAMBDA * loss1","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.122411Z","iopub.execute_input":"2023-02-28T19:45:58.123429Z","iopub.status.idle":"2023-02-28T19:45:58.133374Z","shell.execute_reply.started":"2023-02-28T19:45:58.123383Z","shell.execute_reply":"2023-02-28T19:45:58.131941Z"},"trusted":true},"execution_count":19,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    def identity_loss(real_image, same_image, LAMBDA):\n        loss = tf.reduce_mean(tf.abs(real_image - same_image))\n        return LAMBDA * 0.5 * loss","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.135124Z","iopub.execute_input":"2023-02-28T19:45:58.135603Z","iopub.status.idle":"2023-02-28T19:45:58.146683Z","shell.execute_reply.started":"2023-02-28T19:45:58.135552Z","shell.execute_reply":"2023-02-28T19:45:58.145258Z"},"trusted":true},"execution_count":20,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    monet_generator_optimizer = tf.keras.optimizers.Adam(gen_lrate, beta_1=0.9, beta_2=0.999)\n    photo_generator_optimizer = tf.keras.optimizers.Adam(gen_lrate,  beta_1=0.9, beta_2=0.999)\n\n    monet_discriminator_optimizer = tf.keras.optimizers.Adam(dis_lrate,  beta_1=0.9, beta_2=0.999)\n    photo_discriminator_optimizer = tf.keras.optimizers.Adam(dis_lrate,  beta_1=0.9, beta_2=0.999)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.14862Z","iopub.execute_input":"2023-02-28T19:45:58.149087Z","iopub.status.idle":"2023-02-28T19:45:58.17324Z","shell.execute_reply.started":"2023-02-28T19:45:58.149039Z","shell.execute_reply":"2023-02-28T19:45:58.171713Z"},"trusted":true},"execution_count":21,"outputs":[]},{"cell_type":"code","source":"with strategy.scope():\n    cycle_gan_model = CycleGan(\n        monet_cycle_generator, photo_cycle_generator, monet_cycle_discriminator, photo_cycle_discriminator, label_real=0.66\n    )\n\n    cycle_gan_model.compile(\n        m_gen_optimizer = monet_generator_optimizer,\n        p_gen_optimizer = photo_generator_optimizer,\n        m_disc_optimizer = monet_discriminator_optimizer,\n        p_disc_optimizer = photo_discriminator_optimizer,\n        gen_loss_fn = generator_loss,\n        disc_loss_fn = discriminator_loss,\n        cycle_loss_fn = calc_cycle_loss,\n        identity_loss_fn = identity_loss\n    )","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.175216Z","iopub.execute_input":"2023-02-28T19:45:58.176873Z","iopub.status.idle":"2023-02-28T19:45:58.214427Z","shell.execute_reply.started":"2023-02-28T19:45:58.176811Z","shell.execute_reply":"2023-02-28T19:45:58.212585Z"},"trusted":true},"execution_count":22,"outputs":[]},{"cell_type":"code","source":"history = cycle_gan_model.fit(\n    tf.data.Dataset.zip((monet_ds, photo_ds)),\n    epochs=20\n)","metadata":{"execution":{"iopub.status.busy":"2023-02-28T19:45:58.216076Z","iopub.execute_input":"2023-02-28T19:45:58.216491Z"},"trusted":true},"execution_count":null,"outputs":[{"name":"stdout","text":"Epoch 1/20\n","output_type":"stream"}]}]}