03_M04L02_Lab_Implementing_Diffusion_Models__M2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9f8a6280-256d-41e1-8913-985ddbfcba77"
      },
      "source": [
        "<p style=\"text-align:center\">\n",
        "    <a href=\"https://skills.network\" target=\"_blank\">\n",
        "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n",
        "    </a>\n",
        "</p>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ab84a4f-7efc-4c88-9a41-193e9f84c509"
      },
      "source": [
        "# **Lab: Implementing Diffusion Models**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "606aa0b1-967b-41e5-a445-1bda3e2b5054"
      },
      "source": [
        "Estimated time needed: **45** minutes\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3e051b57-b738-4d99-b60d-64eb5e70bbb5"
      },
      "source": [
        "In this lab, you will learn how to implement, train, and evaluate diffusion models using Keras.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5b8c4b33-da36-43cc-b6a0-c16a7eb93efd"
      },
      "source": [
        "## Learning Objectives\n",
        "\n",
        "By the end of this lab, you will:\n",
        "- Acquire practical understanding of diffusion model architectures, data processing, model training, and performance evaluation\n",
        "- Implement, train, and evaluate diffusion models using Keras\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c5a7efa9-6624-4851-9b12-4cdc0313687b"
      },
      "source": [
        "----\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "62f3609d-acaf-435d-bc33-68eddd2af1d3"
      },
      "source": [
        "### Prerequisites\n",
        "\n",
        "- Basic understanding of Python and Keras\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1308bd43-4e1f-4a32-98e0-1ca3b71bbb5c"
      },
      "source": [
        "### Steps\n",
        "\n",
        "#### Step 1: Preprocess data\n",
        "\n",
        "Prepare the MNIST data set for training by normalizing the pixel values and reshaping the images to have a single color channel. Normalization helps in faster convergence during training, and reshaping is required because the input layer of your diffusion model expects a three-dimensional tensor.\n",
        "\n",
        "**1. Load and preprocess the MNIST data set:**\n",
        "\n",
        "- Use Keras to load the MNIST data set.\n",
        "- Normalize the image pixel values to the range [0, 1].\n",
        "\n",
        "**2. Reshape the Data:**\n",
        "- Expand the dimensions of the images to match the input shape required by the model (28x28x1).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "258fc8f1-0bb5-4654-b607-a1209780feb8"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install tensorflow-cpu==2.16.2\n",
        "\n",
        "import os\n",
        "# Suppress oneDNN optimizations and lower TensorFlow logging level\n",
        "os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'\n",
        "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n"
      ],
      "execution_count": 1
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "763bef99-835e-4542-8a24-386303dfaa47",
        "outputId": "5d59a0c3-dbde-4f3a-8c29-3045a00a8079"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.26.4)\n"
          ]
        }
      ],
      "source": [
        "!pip install numpy"
      ],
      "execution_count": 2
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cea66bd9-c1b6-4650-b196-a63a375f26da",
        "outputId": "aa694155-b0c0-47e3-e4dd-b2d405408ebd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.8.0)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.55.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.7)\n",
            "Requirement already satisfied: numpy<2,>=1.21 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.26.4)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (24.2)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (11.0.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.2.0)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n"
          ]
        }
      ],
      "source": [
        "!pip install matplotlib"
      ],
      "execution_count": 3
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a9964fab-1381-4841-b4eb-ec072e205400",
        "outputId": "75c7f140-960c-467a-ff95-83693e6d078c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "\u001b[1m11490434/11490434\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.datasets import mnist\n",
        "from tensorflow.keras.layers import Input, Conv2D, Flatten, Dense, Reshape, Conv2DTranspose\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "\n",
        "# Load the data set\n",
        "(x_train, _), (x_test, _) = mnist.load_data()\n",
        "\n",
        "# Normalize the pixel values\n",
        "x_train = x_train.astype('float32') / 255.\n",
        "x_test = x_test.astype('float32') / 255.\n",
        "\n",
        "# Expand dimensions to match the input shape (28, 28, 1)\n",
        "x_train = np.expand_dims(x_train, axis=-1)\n",
        "x_test = np.expand_dims(x_test, axis=-1)\n",
        "\n",
        "# Add noise to the data\n",
        "noise_factor = 0.5\n",
        "x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)\n",
        "x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)\n",
        "\n",
        "# Clip the values to be within the range [0, 1]\n",
        "x_train_noisy = np.clip(x_train_noisy, 0., 1.)\n",
        "x_test_noisy = np.clip(x_test_noisy, 0., 1.)\n"
      ],
      "execution_count": 4
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bfef8996-5e81-456b-8a7e-d882af59b553"
      },
      "source": [
        "#### Step 2: Build the diffusion model\n",
        "\n",
        "Build a simple diffusion model with an encoder that compresses the input image into a latent representation and a decoder that reconstructs the image from this representation. The model is compiled with the Adam optimizer and binary cross-entropy loss.\n",
        "\n",
        "**1. Define the encoder:**\n",
        "- Create an input layer with the shape (28, 28, 1).\n",
        "- Add two Conv2D layers with increasing filter sizes and ReLU activation.\n",
        "\n",
        "**2. Define the bottleneck:**\n",
        "- Add a flattened layer followed by a dense layer with ReLU activation.\n",
        "\n",
        "**3. Define the decoder:**\n",
        "- Add a Dense layer to expand the bottleneck representation.\n",
        "- Reshape the output to match the original image dimensions.\n",
        "- Add two Conv2DTranspose layers with decreasing filter sizes and ReLU activation.\n",
        "  \n",
        "**4. Compile the model:**\n",
        "- Use the Adam optimizer and binary cross-entropy loss.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 444
        },
        "id": "5932ddce-92d0-42d6-9d0f-be6ff945bacb",
        "outputId": "a8406b6b-e439-443c-ecdd-8dfa32a25751"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1mModel: \"functional\"\u001b[0m\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional\"</span>\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                        \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape               \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m        Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m)           │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m16\u001b[0m)          │             \u001b[38;5;34m160\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │           \u001b[38;5;34m4,640\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m25088\u001b[0m)               │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense (\u001b[38;5;33mDense\u001b[0m)                        │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)                  │       \u001b[38;5;34m1,605,696\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m25088\u001b[0m)               │       \u001b[38;5;34m1,630,720\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ reshape (\u001b[38;5;33mReshape\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose (\u001b[38;5;33mConv2DTranspose\u001b[0m)   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │           \u001b[38;5;34m9,248\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_1 (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m16\u001b[0m)          │           \u001b[38;5;34m4,624\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m)           │             \u001b[38;5;34m145\u001b[0m │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃<span style=\"font-weight: bold\"> Layer (type)                         </span>┃<span style=\"font-weight: bold\"> Output Shape                </span>┃<span style=\"font-weight: bold\">         Param # </span>┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ input_layer (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)           │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>)          │             <span style=\"color: #00af00; text-decoration-color: #00af00\">160</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │           <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25088</span>)               │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                        │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)                  │       <span style=\"color: #00af00; text-decoration-color: #00af00\">1,605,696</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25088</span>)               │       <span style=\"color: #00af00; text-decoration-color: #00af00\">1,630,720</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ reshape (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>)   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │           <span style=\"color: #00af00; text-decoration-color: #00af00\">9,248</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>)          │           <span style=\"color: #00af00; text-decoration-color: #00af00\">4,624</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">145</span> │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,255,233\u001b[0m (12.42 MB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">3,255,233</span> (12.42 MB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,255,233\u001b[0m (12.42 MB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">3,255,233</span> (12.42 MB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Define the diffusion model architecture with reduced complexity\n",
        "input_layer = Input(shape=(28, 28, 1))\n",
        "x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_layer)  # Reduced filters\n",
        "x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)  # Reduced filters\n",
        "x = Flatten()(x)\n",
        "x = Dense(64, activation='relu')(x)  # Reduced size\n",
        "x = Dense(28*28*32, activation='relu')(x)  # Reduced size\n",
        "x = Reshape((28, 28, 32))(x)\n",
        "x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)  # Reduced filters\n",
        "x = Conv2DTranspose(16, (3, 3), activation='relu', padding='same')(x)  # Reduced filters\n",
        "output_layer = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)\n",
        "diffusion_model = Model(input_layer, output_layer)\n",
        "\n",
        "# Compile the model with mixed precision and a different loss function\n",
        "diffusion_model.compile(optimizer='adam', loss='mean_squared_error')  # Using MSE for regression tasks\n",
        "\n",
        "# Summary of the optimized model\n",
        "diffusion_model.summary()\n"
      ],
      "execution_count": 5
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "74eea41d-775f-40d4-8be1-e61daad034b8"
      },
      "source": [
        "#### Step 3: Add noise to the data\n",
        "\n",
        "Add random noise to the data set to simulate the diffusion process:\n",
        "- Add Gaussian noise to the training and test data sets.\n",
        "- Clip the values to ensure they remain within the valid range [0, 1].\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "66812d3f-073d-4f91-9121-ab18ff5c74d0"
      },
      "outputs": [],
      "source": [
        "# Cache and prefetch the data using TensorFlow data pipelines for faster loading\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((x_train_noisy, x_train))\n",
        "train_dataset = train_dataset.cache().batch(64).prefetch(tf.data.AUTOTUNE)  # Reduced batch size\n",
        "\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((x_test_noisy, x_test))\n",
        "val_dataset = val_dataset.cache().batch(64).prefetch(tf.data.AUTOTUNE)  # Reduced batch size\n"
      ],
      "execution_count": 6
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "860daa1b-a356-46ac-acfd-f7e25b1fecf4"
      },
      "source": [
        "#### Step 4: Train the diffusion model\n",
        "\n",
        "Train the diffusion model to denoise the MINIST images. Use the noisy images as input and the original images as the target, learning to reverse the noise addition process.\n",
        "- Use the ‘fit’ method to train the model on the noisy training data.\n",
        "- Set the number of epochs to 50 and the batch size to 128.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7c89e776-f4ab-4cfa-b68c-615dfd88157f",
        "outputId": "341f0164-e876-4df6-8455-3d533dda055f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m254s\u001b[0m 266ms/step - loss: 0.0562 - val_loss: 0.0157\n",
            "Epoch 2/3\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m255s\u001b[0m 259ms/step - loss: 0.0135 - val_loss: 0.0129\n",
            "Epoch 3/3\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m243s\u001b[0m 259ms/step - loss: 0.0113 - val_loss: 0.0126\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x79b617346500>"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "# Implement early stopping based on validation loss\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=2, restore_best_weights=True)\n",
        "\n",
        "# Train the model with early stopping and smaller batch size\n",
        "diffusion_model.fit(\n",
        "    train_dataset,\n",
        "    epochs=3,\n",
        "    shuffle=True,\n",
        "    validation_data=val_dataset,\n",
        "    callbacks=[early_stopping]\n",
        ")"
      ],
      "execution_count": 7
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2672625c-9d40-43e8-8104-be8a1436c44f"
      },
      "source": [
        "#### Step 5: Evaluate the diffusion model\n",
        "\n",
        "Evaluate the performance of the trained diffusion model by predicting the denoised images and visualizing the results. Comparing the original, noisy, and denoised images will help you understand how well the model has learned to remove noise from the images.\n",
        "\n",
        "**1. Reconstruct images:**\n",
        "- Use the diffusion model to predict the denoised test images.  \n",
        "- Compare the original, noisy, and denoised images.\n",
        "\n",
        "**2. Visualize the results:**\n",
        "- Plot a few examples of original, noisy, and denoised images side by side.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "c0b93515-f310-4da1-95ca-e6dfee0c1983",
        "outputId": "2cd5f631-577e-4d41-b5a5-d32ef812be72"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 36ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x600 with 30 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Predict the denoised images\n",
        "denoised_images = diffusion_model.predict(x_test_noisy)\n",
        "\n",
        "# Visualize the results\n",
        "n = 10  # Number of digits to display\n",
        "plt.figure(figsize=(20, 6))\n",
        "for i in range(n):\n",
        "    # Display original\n",
        "    ax = plt.subplot(3, n, i + 1)\n",
        "    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "\n",
        "    # Display noisy\n",
        "    ax = plt.subplot(3, n, i + 1 + n)\n",
        "    plt.imshow(x_test_noisy[i].reshape(28, 28), cmap='gray')\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "\n",
        "    # Display denoised\n",
        "    ax = plt.subplot(3, n, i + 1 + 2*n)\n",
        "    plt.imshow(denoised_images[i].reshape(28, 28), cmap='gray')\n",
        "    ax.get_xaxis().set_visible(False)\n",
        "    ax.get_yaxis().set_visible(False)\n",
        "plt.show()"
      ],
      "execution_count": 8
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53cbe48b-fc76-4c82-bc5d-0d8bd3c16ce5"
      },
      "source": [
        "#### Step 6: Fine-tune the diffusion model\n",
        "\n",
        "Fine-tune the diffusion model by unfreezing some layers and retraining the model to improve its performance.\n",
        "\n",
        "**1. Unfreeze the model layers:**\n",
        "- Unfreeze the last few layers of the model to allow them to be retrained.\n",
        "\n",
        "**2. Compile and train the model:**\n",
        "- Recompile the model.\n",
        "- Train the model again for an additional 10 epochs.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4243ee12-9f69-4046-9f38-f2648e5d6504",
        "outputId": "430ecbe1-d00f-4761-89a3-7d859970cbfd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m254s\u001b[0m 269ms/step - loss: 0.0928 - val_loss: 0.0958\n",
            "Epoch 2/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m260s\u001b[0m 267ms/step - loss: 0.0887 - val_loss: 0.0960\n",
            "Epoch 3/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m260s\u001b[0m 265ms/step - loss: 0.0858 - val_loss: 0.0976\n",
            "Epoch 4/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m258s\u001b[0m 261ms/step - loss: 0.0838 - val_loss: 0.0981\n",
            "Epoch 5/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m265s\u001b[0m 264ms/step - loss: 0.0821 - val_loss: 0.0995\n",
            "Epoch 6/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m261s\u001b[0m 262ms/step - loss: 0.0807 - val_loss: 0.1007\n",
            "Epoch 7/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m266s\u001b[0m 267ms/step - loss: 0.0797 - val_loss: 0.1018\n",
            "Epoch 8/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m257s\u001b[0m 261ms/step - loss: 0.0788 - val_loss: 0.1031\n",
            "Epoch 9/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m265s\u001b[0m 264ms/step - loss: 0.0780 - val_loss: 0.1050\n",
            "Epoch 10/10\n",
            "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m261s\u001b[0m 263ms/step - loss: 0.0774 - val_loss: 0.1057\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x79b6171f0820>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "# Unfreeze the top layers of the model\n",
        "for layer in diffusion_model.layers[-4:]:\n",
        "    layer.trainable = True\n",
        "\n",
        "# Compile the model again\n",
        "diffusion_model.compile(optimizer='adam', loss='binary_crossentropy')\n",
        "\n",
        "# Train the model again\n",
        "diffusion_model.fit(x_train_noisy, x_train,\n",
        "                    epochs=10,\n",
        "                    batch_size=64,\n",
        "                    shuffle=True,\n",
        "                    validation_data=(x_test_noisy, x_test))\n"
      ],
      "execution_count": 9
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c8d230bc-794f-4192-9888-132afb6e728b"
      },
      "source": [
        "# Exercises\n",
        "\n",
        "### Exercise 1: Modify the noise factor\n",
        "\n",
        "#### Objective:\n",
        "- Change the noise factor and see how it affects the model’s ability to denoise images.\n",
        "#### Instructions:\n",
        "1. Change the noise factor to 0.3.\n",
        "2. Add noise to the training and test data sets with the new noise factor.\n",
        "3. Retrain the model with the new noisy data.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ed6a669b-8f01-46d5-8346-af890fc295c5",
        "outputId": "f1f609e0-37e1-4ab4-83e5-2426b148f051"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m223s\u001b[0m 474ms/step - loss: 0.0804 - val_loss: 0.0778\n",
            "Epoch 2/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m256s\u001b[0m 462ms/step - loss: 0.0771 - val_loss: 0.0774\n",
            "Epoch 3/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m262s\u001b[0m 463ms/step - loss: 0.0764 - val_loss: 0.0769\n",
            "Epoch 4/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m260s\u001b[0m 460ms/step - loss: 0.0759 - val_loss: 0.0768\n",
            "Epoch 5/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m217s\u001b[0m 462ms/step - loss: 0.0753 - val_loss: 0.0765\n",
            "Epoch 6/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m264s\u001b[0m 466ms/step - loss: 0.0751 - val_loss: 0.0764\n",
            "Epoch 7/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m261s\u001b[0m 464ms/step - loss: 0.0746 - val_loss: 0.0764\n",
            "Epoch 8/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m259s\u001b[0m 457ms/step - loss: 0.0746 - val_loss: 0.0764\n",
            "Epoch 9/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m262s\u001b[0m 457ms/step - loss: 0.0743 - val_loss: 0.0764\n",
            "Epoch 10/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m262s\u001b[0m 458ms/step - loss: 0.0740 - val_loss: 0.0765\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x79b6047b97b0>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "# Write your code here\n",
        "# Modify the noise factor to 0.3\n",
        "noise_factor = 0.3\n",
        "\n",
        "# Add noise to the data with the new noise factor\n",
        "x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)\n",
        "x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)\n",
        "\n",
        "# Clip the values to be within the range [0, 1]\n",
        "x_train_noisy = np.clip(x_train_noisy, 0., 1.)\n",
        "x_test_noisy = np.clip(x_test_noisy, 0., 1.)\n",
        "\n",
        "# Retrain the model\n",
        "diffusion_model.fit(x_train_noisy, x_train,\n",
        "                    # epochs=50,\n",
        "                    epochs=10,\n",
        "                    batch_size=128,\n",
        "                    shuffle=True,\n",
        "                    validation_data=(x_test_noisy, x_test))"
      ],
      "execution_count": 10
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bb7d49c1-fa95-48f8-955d-7b2e4fe126d1"
      },
      "source": [
        "<details>\n",
        "    <summary>Click here for Solution</summary>\n",
        "\n",
        "```python\n",
        "# Modify the noise factor to 0.3\n",
        "noise_factor = 0.3\n",
        "\n",
        "# Add noise to the data with the new noise factor\n",
        "x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)\n",
        "x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)\n",
        "\n",
        "# Clip the values to be within the range [0, 1]\n",
        "x_train_noisy = np.clip(x_train_noisy, 0., 1.)\n",
        "x_test_noisy = np.clip(x_test_noisy, 0., 1.)\n",
        "\n",
        "# Retrain the model\n",
        "diffusion_model.fit(x_train_noisy, x_train,\n",
        "                    epochs=50,\n",
        "                    batch_size=128,\n",
        "                    shuffle=True,\n",
        "                    validation_data=(x_test_noisy, x_test))\n",
        "```\n",
        "\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3fdbd857-88c6-42df-8682-12380cbfd351"
      },
      "source": [
        "### Exercise 2 - Add more layers to the model\n",
        "\n",
        "#### Objective:\n",
        "- Experiment with adding more layers to the model to see how it affects performance.\n",
        "\n",
        "#### Instructions:\n",
        "1. Add an additional Conv2D layer with 128 filters in the encoder.\n",
        "2. Add an additional Conv2DTranspose layer with 128 filters in the decoder.\n",
        "3. Rebuild, compile, and train the model.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 612
        },
        "id": "162eae91-7861-4b96-a8a1-af7b553b6bd1",
        "outputId": "9f4631bf-baed-40c2-a3d5-c79f07663b79"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional_1\"</span>\n",
              "</pre>\n"
            ],
            "text/plain": [
              "\u001b[1mModel: \"functional_1\"\u001b[0m\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃<span style=\"font-weight: bold\"> Layer (type)                         </span>┃<span style=\"font-weight: bold\"> Output Shape                </span>┃<span style=\"font-weight: bold\">         Param # </span>┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ input_layer_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)           │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │             <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)          │          <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)         │          <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)                  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100352</span>)              │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)                 │      <span style=\"color: #00af00; text-decoration-color: #00af00\">12,845,184</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50176</span>)               │       <span style=\"color: #00af00; text-decoration-color: #00af00\">6,472,704</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ reshape_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Reshape</span>)                  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)          │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)         │          <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)          │          <span style=\"color: #00af00; text-decoration-color: #00af00\">73,792</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)          │          <span style=\"color: #00af00; text-decoration-color: #00af00\">18,464</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">289</span> │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
              "</pre>\n"
            ],
            "text/plain": [
              "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                        \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape               \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m        Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m)           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m)           │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │             \u001b[38;5;34m320\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m64\u001b[0m)          │          \u001b[38;5;34m18,496\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m128\u001b[0m)         │          \u001b[38;5;34m73,856\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m)                  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100352\u001b[0m)              │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_2 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m)                 │      \u001b[38;5;34m12,845,184\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_3 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50176\u001b[0m)               │       \u001b[38;5;34m6,472,704\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ reshape_1 (\u001b[38;5;33mReshape\u001b[0m)                  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m64\u001b[0m)          │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_2 (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m128\u001b[0m)         │          \u001b[38;5;34m73,856\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_3 (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m64\u001b[0m)          │          \u001b[38;5;34m73,792\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_transpose_4 (\u001b[38;5;33mConv2DTranspose\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m32\u001b[0m)          │          \u001b[38;5;34m18,464\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m1\u001b[0m)           │             \u001b[38;5;34m289\u001b[0m │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">19,576,961</span> (74.68 MB)\n",
              "</pre>\n"
            ],
            "text/plain": [
              "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m19,576,961\u001b[0m (74.68 MB)\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">19,576,961</span> (74.68 MB)\n",
              "</pre>\n"
            ],
            "text/plain": [
              "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m19,576,961\u001b[0m (74.68 MB)\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
              "</pre>\n"
            ],
            "text/plain": [
              "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1630s\u001b[0m 3s/step - loss: 0.2523 - val_loss: 0.1027\n",
            "Epoch 2/10\n",
            "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1636s\u001b[0m 3s/step - loss: 0.1006 - val_loss: 0.0940\n",
            "Epoch 3/10\n",
            "\u001b[1m394/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━━━\u001b[0m \u001b[1m4:06\u001b[0m 3s/step - loss: 0.0927"
          ]
        }
      ],
      "source": [
        "# Write your code here\n",
        "# Define the modified diffusion model architecture with additional layers\n",
        "input_layer = Input(shape=(28, 28, 1))\n",
        "\n",
        "x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_layer)\n",
        "x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n",
        "x = Conv2D(128, (3, 3), activation='relu', padding='same')(x) # Additional layer\n",
        "x = Flatten()(x)\n",
        "x = Dense(128, activation='relu')(x)\n",
        "x = Dense(28*28*64, activation='relu')(x)\n",
        "x = Reshape((28, 28, 64))(x)\n",
        "x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x) # Additional layer\n",
        "x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)\n",
        "x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)\n",
        "output_layer = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)\n",
        "\n",
        "diffusion_model = Model(input_layer, output_layer)\n",
        "\n",
        "# Compile the model\n",
        "diffusion_model.compile(optimizer='adam', loss='binary_crossentropy')\n",
        "\n",
        "# Summary of the model\n",
        "diffusion_model.summary()\n",
        "\n",
        "# Train the model\n",
        "diffusion_model.fit(x_train_noisy, x_train,\n",
        "                    # epochs=50,\n",
        "                    epochs=10,\n",
        "                    batch_size=128,\n",
        "                    shuffle=True,\n",
        "                    validation_data=(x_test_noisy, x_test))"
      ],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1515be8a-73b9-4d2c-90be-28e002c1d6bc"
      },
      "source": [
        "<details>\n",
        "    <summary>Click here for Solution</summary>\n",
        "\n",
        "```python\n",
        "# Define the modified diffusion model architecture with additional layers\n",
        "input_layer = Input(shape=(28, 28, 1))\n",
        "\n",
        "x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_layer)\n",
        "x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n",
        "x = Conv2D(128, (3, 3), activation='relu', padding='same')(x) # Additional layer\n",
        "x = Flatten()(x)\n",
        "x = Dense(128, activation='relu')(x)\n",
        "x = Dense(28*28*64, activation='relu')(x)\n",
        "x = Reshape((28, 28, 64))(x)\n",
        "x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x) # Additional layer\n",
        "x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)\n",
        "x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)\n",
        "output_layer = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)\n",
        "\n",
        "diffusion_model = Model(input_layer, output_layer)\n",
        "\n",
        "# Compile the model\n",
        "diffusion_model.compile(optimizer='adam', loss='binary_crossentropy')\n",
        "\n",
        "\n",
        "# Summary of the model\n",
        "diffusion_model.summary()\n",
        "\n",
        "# Train the model\n",
        "diffusion_model.fit(x_train_noisy, x_train,\n",
        "                    epochs=50,\n",
        "                    batch_size=128,\n",
        "                    shuffle=True,\n",
        "                    validation_data=(x_test_noisy, x_test))\n",
        "```\n",
        "\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "37ad53cb-1ce2-41b7-bab4-d4d9c1b1e8b0"
      },
      "source": [
        "### Exercise 3: Visualize the effect of noise\n",
        "\n",
        "#### Objective:\n",
        "- Compare the impact of different noise levels on the denoising performance of the model.\n",
        "\n",
        "#### Instructions:\n",
        "1. Add noise with different factors (e.g., 0.1, 0.5, 0.7) to the test data.\n",
        "2. Use the model to predict the denoised images for each noise level.\n",
        "3. Visualize the original, noisy, and denoised images side by side for each noise level.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ce10e275-706a-475b-a5fc-babc0affc9d5"
      },
      "outputs": [],
      "source": [
        "# Write your code here\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Function to add noise and predict denoised images\n",
        "def add_noise_and_predict(noise_factor):\n",
        "    x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)\n",
        "    x_test_noisy = np.clip(x_test_noisy, 0., 1.)\n",
        "    denoised_images = diffusion_model.predict(x_test_noisy)\n",
        "    return x_test_noisy, denoised_images\n",
        "\n",
        "# Noise levels to test\n",
        "noise_levels = [0.1, 0.5, 0.7]\n",
        "\n",
        "# Visualize the results\n",
        "n = 5  # Number of digits to display\n",
        "plt.figure(figsize=(20, 12))\n",
        "for idx, noise_factor in enumerate(noise_levels):\n",
        "    x_test_noisy, denoised_images = add_noise_and_predict(noise_factor)\n",
        "\n",
        "    for i in range(n):\n",
        "      # Display original\n",
        "      ax = plt.subplot(3 * len(noise_levels), n, i + 1 + idx * 3 * n)\n",
        "      plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n",
        "      ax.get_xaxis().set_visible(False)\n",
        "      ax.get_yaxis().set_visible(False)\n",
        "\n",
        "      if i == 0:\n",
        "        ax.set_title(f'Original (Noise: {noise_factor})')\n",
        "\n",
        "        # Display noisy\n",
        "        ax = plt.subplot(3 * len(noise_levels), n, i + 1 + n + idx * 3 * n)\n",
        "        plt.imshow(x_test_noisy[i].reshape(28, 28), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)\n",
        "\n",
        "        # Display denoised\n",
        "        ax = plt.subplot(3 * len(noise_levels), n, i + 1 + 2 * n + idx * 3 * n)\n",
        "        plt.imshow(denoised_images[i].reshape(28, 28), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)\n",
        "plt.show()"
      ],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8ff5d58-2fb4-4140-8961-cbb0fd18d1c2"
      },
      "source": [
        "<details>\n",
        "    <summary>Click here for Solution</summary>\n",
        "\n",
        "```python\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "# Function to add noise and predict denoised images\n",
        "def add_noise_and_predict(noise_factor):\n",
        "    x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)\n",
        "    x_test_noisy = np.clip(x_test_noisy, 0., 1.)\n",
        "    denoised_images = diffusion_model.predict(x_test_noisy)\n",
        "    return x_test_noisy, denoised_images\n",
        "\n",
        "# Noise levels to test\n",
        "noise_levels = [0.1, 0.5, 0.7]\n",
        "\n",
        "# Visualize the results\n",
        "n = 5  # Number of digits to display\n",
        "plt.figure(figsize=(20, 12))\n",
        "for idx, noise_factor in enumerate(noise_levels):\n",
        "    x_test_noisy, denoised_images = add_noise_and_predict(noise_factor)\n",
        "\n",
        "    for i in range(n):\n",
        "        # Display original\n",
        "        ax = plt.subplot(3 * len(noise_levels), n, i + 1 + idx * 3 * n)\n",
        "        plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)\n",
        "\n",
        "        if i == 0:\n",
        "            ax.set_title(f'Original (Noise: {noise_factor})')\n",
        "\n",
        "        # Display noisy\n",
        "        ax = plt.subplot(3 * len(noise_levels), n, i + 1 + n + idx * 3 * n)\n",
        "        plt.imshow(x_test_noisy[i].reshape(28, 28), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)\n",
        "\n",
        "\n",
        "        # Display denoised\n",
        "        ax = plt.subplot(3 * len(noise_levels), n, i + 1 + 2 * n + idx * 3 * n)\n",
        "        plt.imshow(denoised_images[i].reshape(28, 28), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)\n",
        "plt.show()\n",
        "```\n",
        "\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ca0973be-83a5-44cd-a05d-80dadfe22999"
      },
      "source": [
        "### Summary\n",
        "\n",
        "By completing these exercises, students will:\n",
        "1. Understand the impact of different noise factors on the model’s denoising capabilities.\n",
        "2. Learn how adding more layers to the model affects its performance.\n",
        "3. Visualize how different levels of noise affect the denoising results of the model.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b3733bf8-c459-46d6-8031-0521e6147109"
      },
      "source": [
        "### Conclusion\n",
        "\n",
        "Congratulations! You have gained practical experience in implementing diffusion models using Keras. You learned how to preprocess data, construct a basic diffusion model architecture, add noise to the data set, train the model, and evaluate its performance. Additionally, you explored fine-tuning techniques to enhance the model’s performance.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "097f545f-88e5-4dae-bba3-1df445117b89"
      },
      "source": [
        "Copyright © IBM Corporation. All rights reserved.\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.9"
    },
    "prev_pub_hash": "7fa2b9c1faf3c0610fe958f16376a50e069db649db190e3bcc210b7f9e13f25e",
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}