03_M04_Lab_Implementing_Diffusion_Models__M1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "source": [
    "# **Lab: Implementing Diffusion Models**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time needed: **45** minutes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will learn how to implement, train, and evaluate diffusion models using Keras. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "source": [
    "----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prerequisites \n",
    "\n",
    "- Basic understanding of Python and Keras \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 1,
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in /opt/conda/lib/python3.11/site-packages (1.26.4)\n"
     ]
    }
   ],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.11/site-packages (3.9.2)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (1.3.1)\n",
      "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (4.55.0)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (1.4.7)\n",
      "Requirement already satisfied: numpy>=1.23 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (1.26.4)\n",
      "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (24.0)\n",
      "Requirement already satisfied: pillow>=8 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (11.0.0)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (3.2.0)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.11/site-packages (from matplotlib) (2.9.0)\n",
      "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 5,
   "metadata": {},
   "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\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"functional\"\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 (<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: #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",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</span>)               │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ conv2d_transpose_1              │ (<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",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2DTranspose</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"
      ],
      "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;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",
       "│ (\u001b[38;5;33mConv2DTranspose\u001b[0m)               │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ conv2d_transpose_1              │ (\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",
       "│ (\u001b[38;5;33mConv2DTranspose\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"
      ]
     },
     "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\">3,255,233</span> (12.42 MB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,255,233\u001b[0m (12.42 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\">3,255,233</span> (12.42 MB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,255,233\u001b[0m (12.42 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"
    }
   ],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 6,
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m498s\u001b[0m 528ms/step - loss: 0.0811 - val_loss: 0.0445\n",
      "Epoch 2/3\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m499s\u001b[0m 532ms/step - loss: 0.0385 - val_loss: 0.0361\n",
      "Epoch 3/3\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m499s\u001b[0m 532ms/step - loss: 0.0339 - val_loss: 0.0346\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.history.History at 0x7fa977aaf350>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 80ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x600 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m491s\u001b[0m 522ms/step - loss: 0.1591 - val_loss: 0.1575\n",
      "Epoch 2/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m488s\u001b[0m 520ms/step - loss: 0.1551 - val_loss: 0.1556\n",
      "Epoch 3/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m488s\u001b[0m 520ms/step - loss: 0.1525 - val_loss: 0.1549\n",
      "Epoch 4/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m490s\u001b[0m 523ms/step - loss: 0.1514 - val_loss: 0.1548\n",
      "Epoch 5/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m488s\u001b[0m 520ms/step - loss: 0.1497 - val_loss: 0.1547\n",
      "Epoch 6/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m485s\u001b[0m 517ms/step - loss: 0.1487 - val_loss: 0.1546\n",
      "Epoch 7/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m485s\u001b[0m 517ms/step - loss: 0.1484 - val_loss: 0.1545\n",
      "Epoch 8/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m486s\u001b[0m 518ms/step - loss: 0.1474 - val_loss: 0.1561\n",
      "Epoch 9/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m484s\u001b[0m 516ms/step - loss: 0.1468 - val_loss: 0.1548\n",
      "Epoch 10/10\n",
      "\u001b[1m938/938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m482s\u001b[0m 514ms/step - loss: 0.1459 - val_loss: 0.1556\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.history.History at 0x7fa977f53e10>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m410s\u001b[0m 874ms/step - loss: 0.1439 - val_loss: 0.1421\n",
      "Epoch 2/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m408s\u001b[0m 869ms/step - loss: 0.1419 - val_loss: 0.1415\n",
      "Epoch 3/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m409s\u001b[0m 871ms/step - loss: 0.1407 - val_loss: 0.1415\n",
      "Epoch 4/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m406s\u001b[0m 865ms/step - loss: 0.1407 - val_loss: 0.1412\n",
      "Epoch 5/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m409s\u001b[0m 871ms/step - loss: 0.1396 - val_loss: 0.1405\n",
      "Epoch 6/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m407s\u001b[0m 868ms/step - loss: 0.1396 - val_loss: 0.1403\n",
      "Epoch 7/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m407s\u001b[0m 868ms/step - loss: 0.1387 - val_loss: 0.1403\n",
      "Epoch 8/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m408s\u001b[0m 870ms/step - loss: 0.1386 - val_loss: 0.1399\n",
      "Epoch 9/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 877ms/step - loss: 0.1381 - val_loss: 0.1400\n",
      "Epoch 10/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 876ms/step - loss: 0.1377 - val_loss: 0.1404\n",
      "Epoch 11/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m409s\u001b[0m 872ms/step - loss: 0.1373 - val_loss: 0.1398\n",
      "Epoch 12/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m412s\u001b[0m 879ms/step - loss: 0.1371 - val_loss: 0.1399\n",
      "Epoch 13/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m410s\u001b[0m 874ms/step - loss: 0.1365 - val_loss: 0.1399\n",
      "Epoch 14/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 876ms/step - loss: 0.1364 - val_loss: 0.1400\n",
      "Epoch 15/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 877ms/step - loss: 0.1357 - val_loss: 0.1401\n",
      "Epoch 16/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 876ms/step - loss: 0.1353 - val_loss: 0.1399\n",
      "Epoch 17/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m412s\u001b[0m 878ms/step - loss: 0.1349 - val_loss: 0.1407\n",
      "Epoch 18/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m416s\u001b[0m 886ms/step - loss: 0.1351 - val_loss: 0.1407\n",
      "Epoch 19/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m416s\u001b[0m 887ms/step - loss: 0.1347 - val_loss: 0.1403\n",
      "Epoch 20/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m410s\u001b[0m 874ms/step - loss: 0.1344 - val_loss: 0.1405\n",
      "Epoch 21/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m411s\u001b[0m 876ms/step - loss: 0.1341 - val_loss: 0.1407\n",
      "Epoch 22/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m412s\u001b[0m 880ms/step - loss: 0.1340 - val_loss: 0.1407\n",
      "Epoch 23/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m412s\u001b[0m 878ms/step - loss: 0.1337 - val_loss: 0.1414\n",
      "Epoch 24/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m413s\u001b[0m 880ms/step - loss: 0.1336 - val_loss: 0.1407\n",
      "Epoch 25/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m413s\u001b[0m 880ms/step - loss: 0.1332 - val_loss: 0.1411\n",
      "Epoch 26/50\n",
      "\u001b[1m469/469\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m416s\u001b[0m 888ms/step - loss: 0.1329 - val_loss: 0.1410\n",
      "Epoch 27/50\n",
      "\u001b[1m232/469\u001b[0m \u001b[32m━━━━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━\u001b[0m \u001b[1m3:19\u001b[0m 840ms/step - loss: 0.1327"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "\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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here\n",
    "\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",
    "                    batch_size=128,\n",
    "                    shuffle=True,\n",
    "                    validation_data=(x_test_noisy, x_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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": {},
   "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": {},
   "source": [
    "Copyright © IBM Corporation. All rights reserved.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}