{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":21755,"databundleVersionId":1475600,"sourceType":"competition"}],"dockerImageVersionId":30732,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Problem Description\n\nThis project is using GANs to to try to generate images in the style of Claude Monet. The project contains training images of Monet's work, and will be used to train the generator to recreate the style. A discriminator is also included as part of the GAN to determine if the image is real or generated to improve the generator.","metadata":{}},{"cell_type":"code","source":"# Some code is based off of the recommended starter notebook from Amy Jang: https://www.kaggle.com/code/amyjang/monet-cyclegan-tutorial\n\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom keras.models import Sequential, Model\nfrom keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Flatten, Input, Conv2D, Conv2DTranspose, UpSampling2D, Dropout, Activation, Concatenate\nfrom tensorflow.keras.backend import clear_session\nfrom keras.optimizers import Adam\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport os\nfrom PIL import Image\nfrom tensorflow.keras import backend as K\n\nmonet_paintings_path = '/kaggle/input/gan-getting-started/monet_jpg'\nmonet_tfrec_path = '/kaggle/input/gan-getting-started/monet_tfrec'\nphotos_path = '/kaggle/input/gan-getting-started/photo_jpg'\nphotos_tfrec_path = '/kaggle/input/gan-getting-started/photo_tfrec'","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-08-04T16:32:24.774743Z","iopub.execute_input":"2024-08-04T16:32:24.775112Z","iopub.status.idle":"2024-08-04T16:32:38.091793Z","shell.execute_reply.started":"2024-08-04T16:32:24.775075Z","shell.execute_reply":"2024-08-04T16:32:38.090927Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Monet dir info\nmonet_files = [f for f in os.listdir(monet_paintings_path) if f.lower().endswith(('jpg'))]\nprint(\"Monet Paintings len: \" + str(len(monet_files)))\n\nif monet_files:\n    monet_first_image_path = os.path.join(monet_paintings_path, monet_files[0])\n    try:\n        with Image.open(monet_first_image_path) as img:\n            print(\"Monet image details: \" + monet_files[0] + \", Size: \" + str(img.size))\n    except Exception as e:\n        print(\"Error processing file \" + monet_files[0] + \": \" + str(e))\n\n# Photos dir info\nphotos_files = [f for f in os.listdir(photos_path) if f.lower().endswith(('jpg'))]\nprint(\"Photos len: \" + str(len(photos_files)))\n\nif photos_files:\n    photos_first_image_path = os.path.join(photos_path, photos_files[0])\n    try:\n        with Image.open(photos_first_image_path) as img:\n            print(\"photos image details: \" + photos_files[0] + \", Size: \" + str(img.size))\n    except Exception as e:\n        print(\"Error processing file \" + photos_files[0] + \": \" + str(e))","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:32:38.093933Z","iopub.execute_input":"2024-08-04T16:32:38.094932Z","iopub.status.idle":"2024-08-04T16:32:38.286898Z","shell.execute_reply.started":"2024-08-04T16:32:38.094895Z","shell.execute_reply":"2024-08-04T16:32:38.285693Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Exploratory Data Analysis","metadata":{}},{"cell_type":"code","source":"def show_image_examples(directory, name, num_examples=6):\n    files = [f for f in os.listdir(directory) if f.lower().endswith(('jpg'))]\n    plt.figure(figsize=(15, 10))\n    for i, file_name in enumerate(files[:num_examples]):\n        file_path = os.path.join(directory, file_name)\n        with Image.open(file_path) as img:\n            plt.subplot(2, 3, i + 1)\n            plt.imshow(img)\n            plt.title(file_name)\n            plt.axis('off')\n    plt.suptitle(name + \" - Example Images\")\n    plt.show()\n\nshow_image_examples(monet_paintings_path, 'Monet Paintings')\nshow_image_examples(photos_path, 'Photos')","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:32:38.293203Z","iopub.execute_input":"2024-08-04T16:32:38.293673Z","iopub.status.idle":"2024-08-04T16:32:40.556885Z","shell.execute_reply.started":"2024-08-04T16:32:38.293637Z","shell.execute_reply":"2024-08-04T16:32:40.555628Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The images are 256x256x3 (RGB). The monet directory contains the example Monet paintings which have a more muted color pallette, while the photos directory has random images of nature which are much more vibrant and sharper. ","metadata":{}},{"cell_type":"code","source":"def analyze_images(directory):\n    files = [f for f in os.listdir(directory) if f.lower().endswith(('jpg'))]\n    color_distributions = []\n\n    for file_name in files:\n        file_path = os.path.join(directory, file_name)\n        with Image.open(file_path) as img:\n            color_distributions.append(np.array(img).mean(axis=(0, 1)))\n\n    return color_distributions\n\ndef plot_analysis(color_distributions):    \n    plt.figure(figsize=(18, 10))\n    plt.subplot(2, 2, 1)\n    color_distributions = np.array(color_distributions)\n    if color_distributions.ndim == 2:\n        plt.hist(color_distributions[:, 0], bins=30, color='red', alpha=0.5, label='R')\n        plt.hist(color_distributions[:, 1], bins=30, color='green', alpha=0.5, label='G')\n        plt.hist(color_distributions[:, 2], bins=30, color='blue', alpha=0.5, label='B')\n        plt.legend()\n        plt.title('Color Distribution')\n    else:\n        plt.hist(color_distributions, bins=30, color='gray', alpha=0.7)\n        plt.title('Gray-scale Distribution')\n\n    plt.tight_layout()\n    plt.show()\n\ncolor_distributions = analyze_images(monet_paintings_path)\nplot_analysis(color_distributions)\n\ncolor_distributions = analyze_images(photos_path)\nplot_analysis(color_distributions)","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:32:40.558141Z","iopub.execute_input":"2024-08-04T16:32:40.558529Z","iopub.status.idle":"2024-08-04T16:33:28.770534Z","shell.execute_reply.started":"2024-08-04T16:32:40.558488Z","shell.execute_reply":"2024-08-04T16:33:28.769371Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"By looking at the color distribution of the images, it's clear that the photos of the world have a near even distribution of colors with slighty more green. It also is in a normal distribution seeminly. Monet's paintings have less of a clear distribution and certain frequencies which are over-represented compared to the real world, like having more intense R, G, and B values.","metadata":{}},{"cell_type":"markdown","source":"# Data Preprocessing","metadata":{}},{"cell_type":"code","source":"MONET_FILENAMES = [os.path.join(monet_tfrec_path, f) for f in os.listdir(monet_tfrec_path)]\nprint('Monet TFRecord Files:', len(MONET_FILENAMES))\nprint(MONET_FILENAMES)\n\nPHOTO_FILENAMES = [os.path.join(photos_tfrec_path, f) for f in os.listdir(photos_tfrec_path)]\nprint('Photo TFRecord Files:', len(PHOTO_FILENAMES))","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:33:28.772052Z","iopub.execute_input":"2024-08-04T16:33:28.773019Z","iopub.status.idle":"2024-08-04T16:33:28.785559Z","shell.execute_reply.started":"2024-08-04T16:33:28.772981Z","shell.execute_reply":"2024-08-04T16:33:28.784580Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The following is preprocessing code from the example notebook mentioned above. It loads in the .tfrec files for the images and scales the images to -1 to 1, along with setting the channels to 3 for RGB.","metadata":{}},{"cell_type":"code","source":"image_dimensions = [256, 256] # width, height\nAUTOTUNE = tf.data.experimental.AUTOTUNE\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_dimensions, 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\n\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.prefetch(AUTOTUNE)\n\nmonet_ds = load_dataset(MONET_FILENAMES, labeled=True).batch(4).prefetch(AUTOTUNE)\nphoto_ds = load_dataset(PHOTO_FILENAMES, labeled=True).batch(4).prefetch(AUTOTUNE)\n\nprint(monet_ds)\nprint(photo_ds)","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:33:28.786902Z","iopub.execute_input":"2024-08-04T16:33:28.787304Z","iopub.status.idle":"2024-08-04T16:33:29.021720Z","shell.execute_reply.started":"2024-08-04T16:33:28.787254Z","shell.execute_reply":"2024-08-04T16:33:29.020718Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Model Architecture\n\nSince this is a GAN project, there is a generator and a discriminator model. \n\nThe generator takes in the image dimensions as input. It then has downsampling layers which use convolution to extract the features of the image, along with using batchnormalization to lower the amount of training time by stabilizing the network, and leakyrelu as an activation layer. It then has upsampling, which uses convolution transpose layers which increase the spacial dimension of the network, and again uses batch normalization and leakyrelu.\n\nThe discriminator model downsamples the image input and uses leakyrelu and dropout to help prevent overfitting.","metadata":{}},{"cell_type":"code","source":"# Code was inspired by the example notebook, with some modifications\n\n# Generator\n# Input layer\ngenerator_input = Input(shape=(256, 256, 3))\n\n# Downsample\ng1 = Conv2D(64, 3, strides=2, padding='same')(generator_input)\ng1 = LeakyReLU()(g1)\n\ng2 = Conv2D(128, 3, strides=2, padding='same')(g1)\ng2 = BatchNormalization()(g2)\ng2 = LeakyReLU()(g2)\n\ng3 = Conv2D(256, 3, strides=2, padding='same')(g2)\ng3 = BatchNormalization()(g3)\ng3 = LeakyReLU()(g3)\n\n# Upsample\ng4 = Conv2DTranspose(128, 3, strides=2, padding='same')(g3)\ng4 = BatchNormalization()(g4)\ng4 = LeakyReLU()(g4)\ng4 = Concatenate()([g4, g2])\n\ng5 = Conv2DTranspose(64, 3, strides=2, padding='same')(g4)\ng5 = BatchNormalization()(g5)\ng5 = LeakyReLU()(g5)\ng5 = Concatenate()([g5, g1])\n\n# Output layer\ngenerator_output = Conv2DTranspose(3, 3, strides=2, padding='same', activation='tanh')(g5)\n\n# Define the model\ngenerator_model = Model(generator_input, generator_output)\ngenerator_model.summary()\n\n\n# Discriminator\n# Input layer\ndiscriminator_input = Input(shape=(256, 256, 3))\n\n# Convolutional layers\nd1 = Conv2D(64, 3, strides=2, padding='same')(discriminator_input)\nd1 = LeakyReLU()(d1)\nd1 = Dropout(0.3)(d1)\n\nd2 = Conv2D(128, 3, strides=2, padding='same')(d1)\nd2 = LeakyReLU()(d2)\nd2 = Dropout(0.3)(d2)\n\nd3 = Conv2D(256, 3, strides=2, padding='same')(d2)\nd3 = LeakyReLU()(d3)\nd3 = Dropout(0.3)(d3)\n\n# Flatten and output layer\nd4 = Flatten()(d3)\ndiscriminator_output = Dense(1, activation='sigmoid')(d4)\n\n# Define the model\ndiscriminator_model = Model(discriminator_input, discriminator_output)\n\ndiscriminator_model.summary()\n\n# Compile the discriminator model\ndiscriminator_model.compile(loss='binary_crossentropy', optimizer=Adam(0.001, 0.5), metrics=['accuracy'])","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:33:29.023049Z","iopub.execute_input":"2024-08-04T16:33:29.023399Z","iopub.status.idle":"2024-08-04T16:33:29.276807Z","shell.execute_reply.started":"2024-08-04T16:33:29.023371Z","shell.execute_reply":"2024-08-04T16:33:29.275852Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# GAN model to combine both the generator and discriminator\ngan_model = Sequential([\n    generator_model,\n    discriminator_model\n])\n\n# Compile the GAN model\ngan_model.compile(loss='binary_crossentropy', optimizer=Adam(0.001, 0.5))\n\n# Helper function to plot the training history\ndef plot_training_history(discriminator_history, generator_history):\n    # Unpacking the loss and accuracy for both discriminator and generator\n    d_loss, d_accuracy = zip(*discriminator_history)\n    g_loss, g_accuracy = zip(*generator_history)\n    \n    epochs = range(1, len(d_loss) + 1)\n    \n    # Creating subplots\n    fig, ax = plt.subplots(2, 1, figsize=(10, 10))\n    \n    # Plotting Discriminator Loss and Accuracy\n    ax[0].plot(epochs, d_loss, 'bo-', label='Discriminator Loss')\n    ax[0].plot(epochs, d_accuracy, 'ro-', label='Discriminator Accuracy')\n    ax[0].set_title('Discriminator Loss and Accuracy')\n    ax[0].set_xlabel('Epochs')\n    ax[0].set_ylabel('Loss/Accuracy')\n    ax[0].legend()\n    \n    # Plotting Generator Loss and Accuracy\n    ax[1].plot(epochs, g_loss, 'bo-', label='Generator Loss')\n    ax[1].plot(epochs, g_accuracy, 'ro-', label='Generator Accuracy')\n    ax[1].set_title('Generator Loss and Accuracy')\n    ax[1].set_xlabel('Epochs')\n    ax[1].set_ylabel('Loss/Accuracy')\n    ax[1].legend()\n    \n    # Displaying the plot\n    plt.tight_layout()\n    plt.show()\n\n# Helper function to display images\ndef show_imgs(generator_model, real_photos):\n    transformed_images = generator_model.predict(real_photos)  # Transform photos\n\n    # Calculate number of rows and columns to display\n    num_images = transformed_images.shape[0]\n    num_cols = int(np.sqrt(num_images))\n    num_rows = num_cols\n    \n    fig, axs = plt.subplots(num_rows, num_cols, figsize=(5, 5))\n    cnt = 0\n    for i in range(num_rows):\n        for j in range(num_cols):\n            if cnt < num_images:\n                axs[i, j].imshow((transformed_images[cnt] * 0.5 + 0.5))  # Rescale images\n                axs[i, j].axis('off')\n                cnt += 1\n    plt.tight_layout()\n    plt.show()\n    plt.close()\n    \ndef train_gan(generator_model, discriminator_model, gan_model, photo_ds, monet_ds, epochs, batch_size):\n    # Generate real and fake labels for training\n    real = np.ones((batch_size, 1))\n    fake = np.zeros((batch_size, 1))\n\n    # Lists to hold training history\n    discriminator_losses = []\n    generator_losses = []\n\n    total_photos = len(list(photo_ds))\n    total_monets = len(list(monet_ds))\n    steps_per_epoch = min(total_photos, total_monets) // batch_size\n\n    for epoch in range(epochs):\n        # Get next batch of images\n        photo_iter = iter(photo_ds.repeat())\n        monet_iter = iter(monet_ds.repeat())\n\n        # Iterate through the images\n        for i in range(steps_per_epoch):\n            # Retrieve next batch of images for training\n            real_photos = next(photo_iter)\n            real_monets = next(monet_iter)\n\n            # Generate fake Monet images from real photos\n            fake_monets = generator_model.predict(real_photos, verbose=0)\n\n            # Train the discriminator on real and fake images\n            discriminator_model.trainable = True\n            d_loss_real = discriminator_model.train_on_batch(real_monets, real)\n            d_loss_fake = discriminator_model.train_on_batch(fake_monets, fake)\n            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # avg loss for discriminator between the real and generated monets\n            discriminator_losses.append(d_loss)\n\n            # Train the generator \n            discriminator_model.trainable = False\n            g_loss = gan_model.train_on_batch(real_photos, real)\n            generator_losses.append(g_loss[1:])\n\n            # Show training progress and generated image\n            if (i) % 25 == 0:  # Adjust frequency as needed\n                print(f\"Step {i+1}/{steps_per_epoch}, Epoch {epoch+1}/{epochs} - Discriminator Loss: {d_loss[0]}, Accuracy: {round(100 * d_loss[1], 2)}% - Generator Loss: {g_loss[1]}, Accuracy: {round(100 * g_loss[2], 2)}%\")\n                real_photos = next(iter(photo_ds.take(1)))  # Take a batch for display\n                show_imgs(generator_model, real_photos)\n\n    return discriminator_losses, generator_losses\n\ndiscriminator_losses, generator_losses = train_gan(generator_model, discriminator_model, gan_model, photo_ds, monet_ds, epochs=25, batch_size=4)\nplot_training_history(discriminator_losses, generator_losses)","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:37:04.116399Z","iopub.execute_input":"2024-08-04T16:37:04.116788Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Results and Analysis","metadata":{}},{"cell_type":"code","source":"# Delete output dir prior to saving new images\n!rm -rf /kaggle/working/*","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:35:49.796661Z","iopub.status.idle":"2024-08-04T16:35:49.797050Z","shell.execute_reply.started":"2024-08-04T16:35:49.796864Z","shell.execute_reply":"2024-08-04T16:35:49.796883Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport shutil\nimport PIL\n\n# Make dir to save generated images\nos.makedirs(\"/kaggle/working/images\", exist_ok=True)\n\n# New var for single image to generate monet style from\nphoto_dataset = load_dataset(PHOTO_FILENAMES, labeled=True).batch(1)\n\ncounter = 0\n\n# Iterate over the dataset\nfor real_img in photo_dataset:\n    # Predict Monet-style image from real image\n    fake_img = generator_model.predict(real_img, verbose=0)\n    \n    # Rescale both the predicted and real images from [-1,1] to [0,255] and convert to uint8\n    real_img_rescaled = ((real_img.numpy()[0] + 1) * 127.5).astype(np.uint8)\n    fake_img_rescaled = ((fake_img[0] + 1) * 127.5).astype(np.uint8)\n\n    # Convert arrays to images\n    real_image_pil = Image.fromarray(real_img_rescaled)\n    fake_image_pil = Image.fromarray(fake_img_rescaled)\n\n    # Save both images\n    fake_image_pil.save(f\"/kaggle/working/images/{counter}.jpg\")\n\n    if counter % 200 == 0:\n        fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n        ax[0].imshow(real_image_pil)\n        ax[0].set_title('Real Image')\n        ax[0].axis('off')\n\n        ax[1].imshow(fake_image_pil)\n        ax[1].set_title('Generated Image')\n        ax[1].axis('off')\n\n        plt.show()\n\n    counter += 1\n\n# Zip the directory containing the images\nshutil.make_archive(\"/kaggle/working/images\", 'zip', \"/kaggle/working/images\")","metadata":{"execution":{"iopub.status.busy":"2024-08-04T16:35:49.798180Z","iopub.status.idle":"2024-08-04T16:35:49.798584Z","shell.execute_reply.started":"2024-08-04T16:35:49.798389Z","shell.execute_reply":"2024-08-04T16:35:49.798412Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Submission Results\n\n![image.png](attachment:23071b08-68b5-4bdb-a3de-dbcb6ddc1e33.png)","metadata":{},"attachments":{"23071b08-68b5-4bdb-a3de-dbcb6ddc1e33.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"# Conclusion\n\nIn total I'm very happy with this project. I think I was able to make a GAN that ended up putting me on the leaderboards which I wasn't expecting and took so much time to learn about the types of GAN's that work for this project because it's not a regular GAN application.\n\n![image.png](attachment:251b80b9-bdb9-4c47-bef1-55c0986810ce.png)\n\n\nAt this point, I think I could tinker with the GAN architecture, by possibly changing the stride, kernel sizes, and input/output channels. You can see in the generated images artifacts from the convolution layers that make it obvious the image is generated. If I adjusted those settings, I think I could get rid of that to improve the quality and score.\n\nThe starter notebook, even though I ignored it for a long part of the project, was so helpful in showing how the GAN architecture should be setup and was a helpful guide.","metadata":{},"attachments":{"251b80b9-bdb9-4c47-bef1-55c0986810ce.png":{"image/png":"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"}}}]}