build-diffuser-model.ipynb

build-diffuser-model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "A100",
      "authorship_tag": "ABX9TyOgXmmaUCVbYdtokIlBILBY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/dvoils/b717937f9b24ed0a54f6d909c16136b5/build-diffuser-model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CNNs for Denoising using Autoencoders\n",
        "\n",
        "Convolutional Neural Networks (CNNs) can be effectively employed for image denoising through an architecture known as a convolutional autoencoder. This type of neural network learns to transform noisy images into clean ones by compressing and then reconstructing the image data. The autoencoder consists of two main components: the encoder and the decoder.\n",
        "\n",
        "The encoder compresses the input image into a lower-dimensional representation, capturing essential features while reducing noise. This compression process allows the network to focus on the most important aspects of the image, discarding the irrelevant noise. The decoder then reconstructs the denoised image from this compressed representation, aiming to restore the image to its original, noise-free state. The decoder effectively learns to upsample and refine the compressed data back into a clear and detailed image.\n",
        "\n",
        "The training process involves feeding the autoencoder pairs of noisy and clean images. The network learns to minimize the difference between its output (the denoised image) and the clean image. This process typically involves creating a dataset of noisy and corresponding clean images. During training, the noisy images are used as input, and the clean images serve as targets. The autoencoder iteratively adjusts its parameters to reduce the error between its predictions and the actual clean images, learning to map noisy inputs to clean outputs.\n",
        "\n",
        "Once trained, the autoencoder can take new noisy images and effectively denoise them, restoring them to their cleaner versions. This method leverages the power of CNNs to capture and preserve important features while removing noise, making it a robust solution for image denoising tasks. By transforming noisy images into clean ones, convolutional autoencoders offer a powerful tool for enhancing image quality in various applications.\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "IQ3gI-z-XdF4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import MNIST\n",
        "from torch.utils.data import DataLoader\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import MNIST\n",
        "from torch.utils.data import DataLoader\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "InQCT8VOW0tx"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def add_noise(img):\n",
        "    noise = torch.randn(img.size()) * 0.3\n",
        "    noisy_img = img + noise\n",
        "    return noisy_img\n",
        "\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Lambda(add_noise)\n",
        "])\n",
        "\n",
        "# Load the MNIST training set with noise added\n",
        "train_set = MNIST(root='./data', download=True, train=True, transform=transform)\n",
        "\n",
        "# Normal transform for clean images\n",
        "test_transform = transforms.Compose([\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "\n",
        "# Load the MNIST test set without noise for validation\n",
        "test_set = MNIST(root='./data', download=True, train=False, transform=test_transform)\n",
        "\n",
        "# DataLoader\n",
        "train_loader = DataLoader(train_set, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_set, batch_size=64, shuffle=False)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7z4oYszcW_ba",
        "outputId": "8f71664d-db51-49dc-fe45-f74a4d23cf7a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:08<00:00, 1136413.92it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 57784.10it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:01<00:00, 1255868.85it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 6539831.37it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convolutional Neural Networks\n",
        "### 1. **Convolution Operation**\n",
        "\n",
        "The convolution operation is used in convolutional layers to extract features from input data such as images. The convolution involves sliding a smaller matrix (filter or kernel) over the input matrix (image) to produce a feature map.\n",
        "\n",
        "Given an input image matrix $X$ and a filter matrix $K$, the convolution ($\\ast$) operation is defined for each element $(i, j)$ of the output feature map $Y$ as:\n",
        "\n",
        "$$\n",
        "Y(i, j) = (K \\ast X)(i, j) = \\sum_m \\sum_n K(m, n) \\cdot X(i-m, j-n)\n",
        "$$\n",
        "\n",
        "- $m, n$ are the dimensions of the kernel.\n",
        "- $i, j$ are the coordinates in the output feature map.\n",
        "\n",
        "**Edge Handling**: Typically, the input is padded with zeros (zero-padding) to control the spatial size of the output feature map.\n",
        "\n",
        "### 2. **Activation Functions**\n",
        "\n",
        "After convolution, an activation function is applied element-wise to introduce non-linearities into the model, allowing it to learn more complex patterns. A common activation function is the Rectified Linear Unit (ReLU), defined as:\n",
        "\n",
        "$$\n",
        "\\text{ReLU}(x) = \\max(0, x)\n",
        "$$\n",
        "\n",
        "This function replaces negative values in the output of the convolution with zero while maintaining non-negative values as they are.\n",
        "\n",
        "### 3. **Pooling Layers**\n",
        "\n",
        "Pooling (or subsampling) reduces the spatial dimensions (width and height) of the input volume for the next convolutional layer. It helps reduce the computational cost and control overfitting by providing an abstracted form of the representation.\n",
        "\n",
        "The most common form is max pooling, where the maximum element is selected from the region of the feature map covered by the filter, defined for a 2x2 pooling size as:\n",
        "\n",
        "$$\n",
        "Y(i, j) = \\max_{\\substack{a \\in [i, i+1] \\\\ b \\in [j, j+1]}} X(a, b)\n",
        "$$\n",
        "\n",
        "This operation reduces the dimensions of the input feature map by the size of the pooling region.\n",
        "\n",
        "### 4. **Fully Connected Layers**\n",
        "\n",
        "After several convolutional and pooling layers, the high-level reasoning in the neural network is done via fully connected layers. Neurons in a fully connected layer have connections to all activations in the previous layer. Their outputs are computed with a matrix multiplication followed by a bias offset:\n",
        "\n",
        "$$\n",
        "Y = WX + b\n",
        "$$\n",
        "\n",
        "- $W$ is the weight matrix,\n",
        "- $X$ is the input vector to the fully connected layer,\n",
        "- $b$ is the bias vector.\n",
        "\n",
        "### Example in a Simple CNN:\n",
        "\n",
        "Let’s assume a simple CNN architecture for clearer understanding:\n",
        "1. **Input Layer**: Assume an input image of size 32x32x3 (width x height x channels).\n",
        "2. **Convolutional Layer**: Use ten 5x5 filters without padding, stride = 1.\n",
        "   - Output size: $(32 - 5 + 1) \\times (32 - 5 + 1) \\times 10 = 28 \\times 28 \\times 10$\n",
        "3. **Activation Layer**: Apply ReLU.\n",
        "4. **Pooling Layer**: Apply 2x2 max pooling with stride = 2.\n",
        "   - Output size: $14 \\times 14 \\times 10$\n",
        "5. **Fully Connected Layer**: Flatten the output and connect to a fully connected layer with 100 units.\n",
        "   - Flatten size: $14 \\times 14 \\times 10 = 1960$\n",
        "   - Output size: 100 (from the FC layer)\n",
        "\n",
        "These operations transform raw input into a form suitable for classification or other high-accuracy tasks.\n"
      ],
      "metadata": {
        "id": "Bgmh_oTnuZTR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DenoiseCNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(DenoiseCNN, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # output: [16, 14, 14]\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(16, 32, 3, stride=2, padding=1),  # output: [32, 7, 7]\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(32, 64, 7)  # output: [64, 1, 1]\n",
        "        )\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.ConvTranspose2d(64, 32, 7),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1),\n",
        "            nn.Sigmoid()  # output: [1, 28, 28]\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n"
      ],
      "metadata": {
        "id": "9zEvKJ87XiQP"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = DenoiseCNN().to(device)"
      ],
      "metadata": {
        "id": "bcFiPXKCdjm-"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The Training Loop\n",
        "\n",
        "The training loop iterates over batches of data provided by a DataLoader. Each batch of data is used to compute the loss and update the model's parameters.\n",
        "\n",
        "Before the model can perform a backward pass, the existing gradients need to be zeroed out. This is because gradients in PyTorch accumulate by default, which is useful for certain types of models but not for standard training procedures.\n",
        "\n",
        "## Forward Pass\n",
        "In a neural network, the operation `output = model(data)` involves passing the input data through various layers of the network. Each layer computes a weighted sum of its inputs and applies an activation function. The forward pass through the network can be mathematically represented as follows for each layer $i$:\n",
        "\n",
        "### Linear Combination\n",
        "The input to each layer $i$, denoted as $x_i$ (where $x_0$ is the initial data), is transformed by a linear combination of weights $W_i$ and biases $b_i$. This is given by the equation:\n",
        "\n",
        "$$\n",
        " z_i = W_i \\cdot x_i + b_i\n",
        "$$\n",
        "\n",
        "Here, $z_i$ is the result of the linear combination at layer \\(i\\).\n",
        "### Activation\n",
        "The linear combination output $z_i$ is then passed through an activation function $f_i$, which introduces non-linearity into the model and helps to capture complex patterns in the data. The output of this activation function is:\n",
        "\n",
        "$$\n",
        "  x_{i+1} = f_i(z_i)\n",
        "$$\n",
        "\n",
        "   - $x_{i+1}$ becomes the input for the next layer $i+1$.\n",
        "\n",
        "The process is repeated for each layer until the final output layer is reached. The output of the network, after processing through all layers, is:\n",
        "\n",
        "$$\n",
        "output = x_n = f_{n-1}(W_{n-1} \\cdot x_{n-1} + b_{n-1})\n",
        "$$\n",
        "\n",
        "This represents the network's output based on the initial input data after passing through all the transformations and activations of the layers.\n"
      ],
      "metadata": {
        "id": "VH6n7hAAFJMH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Loss function\n",
        "\n",
        "In the training of neural networks, especially in tasks like regression or autoencoders, measuring how well the model's predictions match the actual data is crucial. This is done using a loss function, which quantifies the difference between the predicted values and the actual values. In this case, we use the Mean Squared Error (MSE) loss, which is commonly used for these types of problems.\n",
        "\n",
        "The MSE loss is calculated as follows:\n",
        "\n",
        "- **Mean Squared Error Loss**:\n",
        "  - The MSE loss measures the average squared difference between the predicted outputs and the actual outputs. It is given by the equation:\n",
        "    $$\n",
        "    \\text{MSE} = \\frac{1}{n} \\sum_{i=1}^n (\\text{output}_i - \\text{data}_i)^2\n",
        "    $$\n",
        "  - Here, $\\text{output}_i$ refers to the predicted output of the model for the $i$-th element, and $\\text{data}_i$ refers to the actual value corresponding to the $i$-th element. The sum of squared differences is averaged over all $n$ elements in the dataset.\n",
        "\n",
        "The code `loss = nn.MSELoss()(output, data)` calculates this loss using PyTorch's `nn.MSELoss`, which automatically handles the computation of the squared differences and the averaging:\n",
        "\n",
        "- `nn.MSELoss()`: Creates an instance of the MSE loss function.\n",
        "- `nn.MSELoss()(output, data)`: Computes the MSE loss between `output` and `data`.\n",
        "\n",
        "This loss value is then used during the training process to update the model's weights with the goal of minimizing the loss, thereby improving the model's accuracy in predicting the data.\n"
      ],
      "metadata": {
        "id": "urz4tnOON7dG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Back Propagation\n",
        "\n",
        "In training neural networks, the `loss.backward()` operation is pivotal as it initiates backpropagation, which is crucial for learning. This method calculates the gradients of the loss function with respect to the network's parameters, enabling their optimization during training.\n",
        "\n",
        "### Mathematical Background of `loss.backward()`\n",
        "\n",
        "- **Gradient Computation**:\n",
        "  - Consider a neural network where the output depends on the input data through a series of transformations (layers). Let the loss function be denoted by $L$. For each parameter $\\theta$ in the network (including weights and biases), the gradient of $L$ with respect to $\\theta$ is represented as $\\frac{\\partial L}{\\partial \\theta}$.\n",
        "  \n",
        "  - The gradient $\\frac{\\partial L}{\\partial \\theta}$ indicates the direction and magnitude of change in $L$ when $\\theta$ is altered slightly. Backpropagation computes these gradients using the chain rule of calculus, applying it layer by layer from the output back to the input.\n",
        "\n",
        "- **Chain Rule Application**:\n",
        "  - If the network output $y$ is a function of the weights $W$ (and biases $b$), and the loss $L$ depends on $y$, then by the chain rule, the gradient of $L$ with respect to each weight $w_{ij}$ in $W$ is:\n",
        "\n",
        "    $$\n",
        "    \\frac{\\partial L}{\\partial w_{ij}} = \\frac{\\partial L}{\\partial y} \\cdot \\frac{\\partial y}{\\partial w_{ij}}\n",
        "    $$\n",
        "    \n",
        "  - This process reverses through the network (hence 'backpropagation'), starting from the output layer and moving towards the input, updating the gradient at each layer based on the gradients computed in subsequent layers.\n",
        "\n",
        "- **Efficiency of Backpropagation**:\n",
        "  - This approach is efficient because it allows for the simultaneous updates of all gradients using a technique called reverse mode differentiation. This only requires a single pass from the output back to the input to compute all necessary gradients, minimizing computational overhead and improving training speed.\n",
        "\n",
        "This methodical approach ensures that every parameter in the network is adjusted appropriately to minimize the loss, thus enhancing the model's predictive accuracy.\n"
      ],
      "metadata": {
        "id": "f1gpL1-wGXNw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train(model, device, train_loader, optimizer, epoch):\n",
        "    model.train()\n",
        "    for batch_idx, (data, _) in enumerate(train_loader):\n",
        "        data = data.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        output = model(data)\n",
        "        loss = nn.MSELoss()(output, data)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        if batch_idx % 100 == 0:\n",
        "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
        "                epoch, batch_idx * len(data), len(train_loader.dataset),\n",
        "                100. * batch_idx / len(train_loader), loss.item()))\n"
      ],
      "metadata": {
        "id": "ffmRc0QxXo1l"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "\n",
        "for epoch in range(1, 6):\n",
        "    train(model, device, train_loader, optimizer, epoch)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qztHURcQXwr1",
        "outputId": "5723054b-2fab-4ed0-9865-7efe124a2acc"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.327067\n",
            "Train Epoch: 1 [6400/60000 (11%)]\tLoss: 0.159962\n",
            "Train Epoch: 1 [12800/60000 (21%)]\tLoss: 0.160823\n",
            "Train Epoch: 1 [19200/60000 (32%)]\tLoss: 0.154230\n",
            "Train Epoch: 1 [25600/60000 (43%)]\tLoss: 0.140378\n",
            "Train Epoch: 1 [32000/60000 (53%)]\tLoss: 0.118569\n",
            "Train Epoch: 1 [38400/60000 (64%)]\tLoss: 0.109507\n",
            "Train Epoch: 1 [44800/60000 (75%)]\tLoss: 0.103985\n",
            "Train Epoch: 1 [51200/60000 (85%)]\tLoss: 0.100498\n",
            "Train Epoch: 1 [57600/60000 (96%)]\tLoss: 0.098651\n",
            "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.098425\n",
            "Train Epoch: 2 [6400/60000 (11%)]\tLoss: 0.099546\n",
            "Train Epoch: 2 [12800/60000 (21%)]\tLoss: 0.095994\n",
            "Train Epoch: 2 [19200/60000 (32%)]\tLoss: 0.098282\n",
            "Train Epoch: 2 [25600/60000 (43%)]\tLoss: 0.096209\n",
            "Train Epoch: 2 [32000/60000 (53%)]\tLoss: 0.095288\n",
            "Train Epoch: 2 [38400/60000 (64%)]\tLoss: 0.096000\n",
            "Train Epoch: 2 [44800/60000 (75%)]\tLoss: 0.094006\n",
            "Train Epoch: 2 [51200/60000 (85%)]\tLoss: 0.094433\n",
            "Train Epoch: 2 [57600/60000 (96%)]\tLoss: 0.094849\n",
            "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.092818\n",
            "Train Epoch: 3 [6400/60000 (11%)]\tLoss: 0.093319\n",
            "Train Epoch: 3 [12800/60000 (21%)]\tLoss: 0.092815\n",
            "Train Epoch: 3 [19200/60000 (32%)]\tLoss: 0.092602\n",
            "Train Epoch: 3 [25600/60000 (43%)]\tLoss: 0.093454\n",
            "Train Epoch: 3 [32000/60000 (53%)]\tLoss: 0.092860\n",
            "Train Epoch: 3 [38400/60000 (64%)]\tLoss: 0.093124\n",
            "Train Epoch: 3 [44800/60000 (75%)]\tLoss: 0.092819\n",
            "Train Epoch: 3 [51200/60000 (85%)]\tLoss: 0.093516\n",
            "Train Epoch: 3 [57600/60000 (96%)]\tLoss: 0.091468\n",
            "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.092095\n",
            "Train Epoch: 4 [6400/60000 (11%)]\tLoss: 0.090435\n",
            "Train Epoch: 4 [12800/60000 (21%)]\tLoss: 0.091019\n",
            "Train Epoch: 4 [19200/60000 (32%)]\tLoss: 0.090567\n",
            "Train Epoch: 4 [25600/60000 (43%)]\tLoss: 0.091290\n",
            "Train Epoch: 4 [32000/60000 (53%)]\tLoss: 0.090119\n",
            "Train Epoch: 4 [38400/60000 (64%)]\tLoss: 0.090886\n",
            "Train Epoch: 4 [44800/60000 (75%)]\tLoss: 0.091868\n",
            "Train Epoch: 4 [51200/60000 (85%)]\tLoss: 0.090584\n",
            "Train Epoch: 4 [57600/60000 (96%)]\tLoss: 0.090982\n",
            "Train Epoch: 5 [0/60000 (0%)]\tLoss: 0.091345\n",
            "Train Epoch: 5 [6400/60000 (11%)]\tLoss: 0.090041\n",
            "Train Epoch: 5 [12800/60000 (21%)]\tLoss: 0.090048\n",
            "Train Epoch: 5 [19200/60000 (32%)]\tLoss: 0.090627\n",
            "Train Epoch: 5 [25600/60000 (43%)]\tLoss: 0.089962\n",
            "Train Epoch: 5 [32000/60000 (53%)]\tLoss: 0.091128\n",
            "Train Epoch: 5 [38400/60000 (64%)]\tLoss: 0.089472\n",
            "Train Epoch: 5 [44800/60000 (75%)]\tLoss: 0.089823\n",
            "Train Epoch: 5 [51200/60000 (85%)]\tLoss: 0.090318\n",
            "Train Epoch: 5 [57600/60000 (96%)]\tLoss: 0.090904\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_examples(model, device, data_loader, num_images=6):\n",
        "    model.eval()\n",
        "    figure, ax = plt.subplots(nrows=num_images, ncols=3, figsize=(9, num_images * 3))\n",
        "    with torch.no_grad():\n",
        "        for batch_idx, (data, _) in enumerate(data_loader):\n",
        "            noisy_data = add_noise(data)  # Add noise to the original data for visualization\n",
        "            noisy_data = noisy_data.to(device)\n",
        "            output = model(noisy_data)  # Denoise the noisy data\n",
        "            for i in range(num_images):\n",
        "                if batch_idx * data_loader.batch_size + i >= num_images:\n",
        "                    break\n",
        "\n",
        "                # Plot original image\n",
        "                ax[i, 0].imshow(data[i].cpu().squeeze().numpy(), cmap='gray')\n",
        "                ax[i, 0].title.set_text('Original Images')\n",
        "                ax[i, 0].axis('off')\n",
        "\n",
        "                # Plot noisy image\n",
        "                ax[i, 1].imshow(noisy_data[i].cpu().squeeze().numpy(), cmap='gray')\n",
        "                ax[i, 1].title.set_text('Noisy Images')\n",
        "                ax[i, 1].axis('off')\n",
        "\n",
        "                # Plot denoised image\n",
        "                ax[i, 2].imshow(output[i].cpu().squeeze().numpy(), cmap='gray')\n",
        "                ax[i, 2].title.set_text('Denoised Images')\n",
        "                ax[i, 2].axis('off')\n",
        "\n",
        "                if batch_idx * data_loader.batch_size + i + 1 == num_images:\n",
        "                    break\n",
        "            if batch_idx * data_loader.batch_size + i + 1 >= num_images:\n",
        "                break\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "# Assuming model, device, and test_loader are already defined\n",
        "plot_examples(model, device, test_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "FQEXjUvTbNOS",
        "outputId": "d3673e00-64d9-4b49-c8ea-3e132a6f4fb8"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x1800 with 18 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}