Denoising_autoencoder_code.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Autoencoder_denoising(CNN2).ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OpTwhM-0exw1",
        "outputId": "8bb7f8a8-3204-406d-9bab-6f34a026731d"
      },
      "source": [
        "!nvcc --version"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nvcc: NVIDIA (R) Cuda compiler driver\n",
            "Copyright (c) 2005-2020 NVIDIA Corporation\n",
            "Built on Mon_Oct_12_20:09:46_PDT_2020\n",
            "Cuda compilation tools, release 11.1, V11.1.105\n",
            "Build cuda_11.1.TC455_06.29190527_0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j20IuntPIFuP"
      },
      "source": [
        "import torch \n",
        "import torchvision\n",
        "import numpy as np\n",
        "import torch.nn as nn\n",
        "import torchvision.transforms as transforms\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "import torch.nn.functional as F\n",
        "from torchvision import datasets\n",
        "from torch.utils.data import DataLoader"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MF4Z0kUXiI53",
        "outputId": "17465238-4184-43a1-b47e-01ee9b217006"
      },
      "source": [
        "torch.cuda.is_available()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ubBpLd-4XwaE",
        "outputId": "9dcf1a4b-52a7-4c87-cb77-9386a4b83e89"
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "print(device)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wqxf2FhSQv7"
      },
      "source": [
        "learning_rate = 1e-3\n",
        "batch_size = 64\n",
        "num_epochs = 20\n",
        "noise_factor = 0.5"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HVl7ee1OCZna"
      },
      "source": [
        "# transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5), (0.5))])\n",
        "transform = transforms.ToTensor()\n",
        "trainset = datasets.MNIST(root='./data',train=True, download=True,transform=transform)\n",
        "testset = datasets.MNIST(root='./data',train=False,download=True,transform=transform)\n",
        "trainloader = DataLoader(trainset, batch_size=batch_size,shuffle=True)\n",
        "testloader = DataLoader(testset, batch_size=batch_size, shuffle=True)"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mzWPC7RUSM4X"
      },
      "source": [
        "def addnoise(img,noise_factor):\n",
        "  img_noisy = img + noise_factor * torch.randn(img.shape)\n",
        "  # img_noisy = np.clip(img_noisy, 0., 1.)\n",
        "  return img_noisy"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "69X9zUw2K87J"
      },
      "source": [
        "class Autoencoder(nn.Module):\n",
        "  def __init__(self):\n",
        "    \n",
        "    super().__init__()\n",
        "    self.encoder = nn.Sequential(\n",
        "      nn.Conv2d(1,16,3, stride = 2, padding = 1),\n",
        "      nn.ReLU(),\n",
        "      nn.Conv2d(16,32,3, stride = 2, padding = 1),\n",
        "      nn.ReLU(),\n",
        "      nn.Conv2d(32,64,7)\n",
        "    )\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()\n",
        "  )\n",
        "\n",
        "  def forward(self,input):\n",
        "    encoded_img = self.encoder(input)\n",
        "    decoded_img = self.decoder(encoded_img)\n",
        "    return decoded_img"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "net = Autoencoder()\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(net.parameters(), lr = learning_rate, weight_decay= 1e-5)\n"
      ],
      "metadata": {
        "id": "M-QnExE71ETH"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ajr7B_nttiqb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f1a3298-647b-4645-9544-44aff64df891"
      },
      "source": [
        "net.to(device)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Autoencoder(\n",
              "  (encoder): Sequential(\n",
              "    (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
              "    (1): ReLU()\n",
              "    (2): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
              "    (3): ReLU()\n",
              "    (4): Conv2d(32, 64, kernel_size=(7, 7), stride=(1, 1))\n",
              "  )\n",
              "  (decoder): Sequential(\n",
              "    (0): ConvTranspose2d(64, 32, kernel_size=(7, 7), stride=(1, 1))\n",
              "    (1): ReLU()\n",
              "    (2): ConvTranspose2d(32, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "    (3): ReLU()\n",
              "    (4): ConvTranspose2d(16, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "    (5): Sigmoid()\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Th3qOSzlrHg6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac205e78-f930-45b7-bd26-470341e37648"
      },
      "source": [
        "train_loss = []\n",
        "for epoch in range(num_epochs):\n",
        "  curr_loss = 0\n",
        "  for (img,_) in trainloader:\n",
        "    img_noisy = addnoise(img,0.5)\n",
        "    img_noisy = img_noisy.to(device)\n",
        "    img = img.to(device)\n",
        "    output = net(img_noisy)\n",
        "    loss = criterion(output,img)\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    train_loss.append(loss.item())\n",
        "\n",
        "  print(f'Epoch:{epoch+1}/{num_epochs}, Loss:{loss.item():.3f}')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:1/20, Loss:0.020\n",
            "Epoch:2/20, Loss:0.016\n",
            "Epoch:3/20, Loss:0.011\n",
            "Epoch:4/20, Loss:0.011\n",
            "Epoch:5/20, Loss:0.011\n",
            "Epoch:6/20, Loss:0.012\n",
            "Epoch:7/20, Loss:0.012\n",
            "Epoch:8/20, Loss:0.011\n",
            "Epoch:9/20, Loss:0.009\n",
            "Epoch:10/20, Loss:0.011\n",
            "Epoch:11/20, Loss:0.011\n",
            "Epoch:12/20, Loss:0.009\n",
            "Epoch:13/20, Loss:0.011\n",
            "Epoch:14/20, Loss:0.009\n",
            "Epoch:15/20, Loss:0.011\n",
            "Epoch:16/20, Loss:0.010\n",
            "Epoch:17/20, Loss:0.012\n",
            "Epoch:18/20, Loss:0.012\n",
            "Epoch:19/20, Loss:0.009\n",
            "Epoch:20/20, Loss:0.011\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EqPSy7wnCfKR"
      },
      "source": [
        "# print(train_loss)\n"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2_rLKsMeEPEz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "a139ba5e-2b2e-459a-ac1f-2485c3c61b4c"
      },
      "source": [
        "plt.plot(train_loss)\n",
        "plt.title(\"Training Loss\")\n",
        "plt.xlabel(\"iterations\")\n",
        "plt.ylabel(\"loss\")"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'loss')"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gFyqb04T2r3J"
      },
      "source": [
        "img_noisy = img_noisy.cpu()\n",
        "output = output.cpu()\n",
        "img = img.cpu()\n"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2AZOrFHsMFWE"
      },
      "source": [
        "img  = img.reshape(-1,28,28)\n",
        "img  = img.detach().numpy()"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G8TP2E1Nnq3g"
      },
      "source": [
        "img_noisy  = img_noisy.reshape(-1,28,28)\n",
        "img_noisy  = img_noisy.detach().numpy()\n",
        "  "
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cHb6CviKoR_x"
      },
      "source": [
        "output = output.detach().numpy()\n",
        "output = output.reshape(-1,28,28)"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "flatten = nn.Flatten()\n",
        "def cosine_similarity(inputs, targets):\n",
        "    inputs = flatten(inputs).detach().cpu().numpy()\n",
        "    inputs = inputs / np.linalg.norm(inputs)\n",
        "    targets = flatten(targets).detach().cpu().numpy()\n",
        "    targets = targets / np.linalg.norm(targets)\n",
        "    products = inputs.dot(targets.T)\n",
        "    return products "
      ],
      "metadata": {
        "id": "NpRqH8u6v7hd"
      },
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "iterer = next(iter(testset))\n",
        "total = 0\n",
        "sum = 0\n",
        "with torch.no_grad():\n",
        "  for i in iterer[0]:\n",
        "    total += 1\n",
        "    \n",
        "    i = i.to(device).reshape((1,i.shape[0],i.shape[1]))\n",
        "    sum += cosine_similarity(net(i.to(device)), i)\n",
        "  print(sum/total)"
      ],
      "metadata": {
        "id": "cKvmd_yQv8J9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f90e6295-1a0d-42a7-a741-8bfcaf3f4e2a"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.9815]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Eg6fCkb42g-J",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "outputId": "6a21eaaf-8355-410c-a55f-36a15604eb65"
      },
      "source": [
        "for i in range(1,6):\n",
        "  #plt.figure(figsize=(10,10))\n",
        "  plt.subplot(5,3,(i*3)-2)\n",
        "  plt.imshow(img[i],cmap='gray')\n",
        "\n",
        "\n",
        "for i in range(1,6):\n",
        "  # plt.figure(figsize=(10,10))\n",
        "  plt.subplot(5,3,(i*3)-1)\n",
        "  plt.imshow(img_noisy[i],cmap='gray')\n",
        "  # plt.figure(figsize=(1,1))\n",
        "for j in range(1,6):\n",
        "  # plt.figure(figsize=(10,10))\n",
        "  plt.subplot(5,3,j*3)\n",
        "  plt.imshow(output[j],cmap='gray')\n",
        "  # plt.figure(figsize=(1,1))\n"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 15 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}