MNIST_Noise.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMnCDw4edngWhaNlESXyu84",
      "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/github/KIIIIT00/B3_Spring/blob/main/MNIST_Noise.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **B3_Spring** ###\n",
        "\n",
        "- Summary: Robustness evaluation on noisy data.\n",
        "- Objective: Train on MNIST images with added noise and verify robustness."
      ],
      "metadata": {
        "id": "m9iO064rckG9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cOkL4CEacd7b",
        "outputId": "1fd99e2b-31ca-41cd-85d6-69b56f5a2117"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (2.5.1+cu124)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/dist-packages (0.20.1+cu124)\n",
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.17.0)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch) (4.12.2)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.5)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch) (2024.10.0)\n",
            "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch)\n",
            "  Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch)\n",
            "  Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch)\n",
            "  Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-curand-cu12==10.3.5.147 (from torch)\n",
            "  Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch)\n",
            "  Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch)\n",
            "  Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
            "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Requirement already satisfied: triton==3.1.0 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.0)\n",
            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch) (1.13.1)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchvision) (1.26.4)\n",
            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/dist-packages (from torchvision) (11.1.0)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
            "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m39.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m40.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m30.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m11.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m63.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12\n",
            "  Attempting uninstall: nvidia-nvjitlink-cu12\n",
            "    Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n",
            "    Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-curand-cu12\n",
            "    Found existing installation: nvidia-curand-cu12 10.3.6.82\n",
            "    Uninstalling nvidia-curand-cu12-10.3.6.82:\n",
            "      Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n",
            "  Attempting uninstall: nvidia-cufft-cu12\n",
            "    Found existing installation: nvidia-cufft-cu12 11.2.3.61\n",
            "    Uninstalling nvidia-cufft-cu12-11.2.3.61:\n",
            "      Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n",
            "  Attempting uninstall: nvidia-cuda-runtime-cu12\n",
            "    Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cuda-nvrtc-cu12\n",
            "    Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cuda-cupti-cu12\n",
            "    Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cublas-cu12\n",
            "    Found existing installation: nvidia-cublas-cu12 12.5.3.2\n",
            "    Uninstalling nvidia-cublas-cu12-12.5.3.2:\n",
            "      Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n",
            "  Attempting uninstall: nvidia-cusparse-cu12\n",
            "    Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n",
            "    Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n",
            "      Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n",
            "  Attempting uninstall: nvidia-cudnn-cu12\n",
            "    Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n",
            "    Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n",
            "      Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n",
            "  Attempting uninstall: nvidia-cusolver-cu12\n",
            "    Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n",
            "    Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n",
            "      Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n",
            "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127\n"
          ]
        }
      ],
      "source": [
        "# Install necessary libraries\n",
        "!pip install torch torchvision tensorflow"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries\n",
        "import os\n",
        "import math\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "from torchvision import datasets, transforms\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "\n"
      ],
      "metadata": {
        "id": "_D49XfpRdtGE"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Class and method definitions ###\n",
        "* add_noise : Add noise and clip pixel values to [0, 1].\n",
        "* NoisyMNIST : Create a noisy dataset.\n",
        "* MNIST_CNN : CNN class for classifying handwritten digits\n",
        "  * forward : Performs forward propagation\n",
        "  * save_model : Saves the model\n",
        "  * load_model : Loads the model\n",
        "* train_model : Model Training Function\n",
        "* show_mnist_comparison : Displays the original images, labels, and predictions"
      ],
      "metadata": {
        "id": "Mmo5eNddfKwk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_noise(images, noise_factor=0.3):\n",
        "  \"\"\"ノイズを追加する関数\"\"\"\n",
        "  noise = torch.randn_like(images) * noise_factor\n",
        "  noisy_images = images + noise\n",
        "  return torch.clamp(noisy_images, -1.0, 1.0)\n",
        "\n",
        "class NoisyMNIST(torch.utils.data.Dataset):\n",
        "  \"\"\"ノイズ付きデータセットを作成するクラス\"\"\"\n",
        "  def __init__(self, dataset, noise_factor=0.3):\n",
        "    self.dataset = dataset\n",
        "    self.noise_factor = noise_factor\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    image, label = self.dataset[index]\n",
        "    noisy_image = add_noise(image, self.noise_factor)\n",
        "    return noisy_image, label\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.dataset)\n",
        "\n",
        "class MNIST_CNN(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(MNIST_CNN, self).__init__()\n",
        "    self.conv1 = nn.Conv2d(1, 16, 3, padding=1)\n",
        "    self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n",
        "    self.pool = nn.MaxPool2d(2, 2)\n",
        "    self.fc1 = nn.Linear(32 * 14 * 14, 128)\n",
        "    self.fc2 = nn.Linear(128, 10)\n",
        "    self.relu = nn.ReLU()\n",
        "\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.relu(self.relu(self.conv1(x)))\n",
        "    x = self.pool(self.relu(self.conv2(x)))\n",
        "    x = x.view(x.size(0), -1)\n",
        "    x = self.relu(self.fc1(x))\n",
        "    x = self.fc2(x)\n",
        "    return x\n",
        "\n",
        "  def save_model(self, model_name):\n",
        "    torch.save(self.state_dict(), f\"{model_name}.pth\")\n",
        "\n",
        "  def load_model(self, model_name):\n",
        "      if os.path.exists(f\"{model_name}.pth\"):\n",
        "          self.load_state_dict(torch.load(f\"{model_name}.pth\"))\n",
        "          print(\"Model loaded successfully\")\n",
        "      else:\n",
        "          print(\"Model not found\")\n",
        "\n",
        "def train_model(model, train_loader, test_loader, epochs=5, learning_rate=0.001):\n",
        "  \"\"\"モデルの学習関数\"\"\"\n",
        "  device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "  model.to(device)\n",
        "\n",
        "  criterion = nn.CrossEntropyLoss()\n",
        "  optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "  train_losses = []\n",
        "  test_accuracies = []\n",
        "\n",
        "  for epoch in range(epochs):\n",
        "      model.train()\n",
        "      running_loss = 0.0\n",
        "      for images, labels in train_loader:\n",
        "          images, labels = images.to(device), labels.to(device)\n",
        "\n",
        "          optimizer.zero_grad()\n",
        "          outputs = model(images)\n",
        "          loss = criterion(outputs, labels)\n",
        "          loss.backward()\n",
        "          optimizer.step()\n",
        "\n",
        "          running_loss += loss.item()\n",
        "\n",
        "      avg_train_loss = running_loss / len(train_loader)\n",
        "      train_losses.append(avg_train_loss)\n",
        "\n",
        "      # Evaluate model\n",
        "      model.eval()\n",
        "      correct = 0\n",
        "      total = 0\n",
        "      with torch.no_grad():\n",
        "          for images, labels in test_loader:\n",
        "              images, labels = images.to(device), labels.to(device)\n",
        "              outputs = model(images)\n",
        "              _, predicted = torch.max(outputs, 1)\n",
        "              total += labels.size(0)\n",
        "              correct += (predicted == labels).sum().item()\n",
        "\n",
        "      test_accuracy = 100 * correct / total\n",
        "      test_accuracies.append(test_accuracy)\n",
        "\n",
        "      print(f\"Epoch {epoch+1}: Loss = {avg_train_loss:.4f}, Test Accuracy = {test_accuracy:.2f}%\")\n",
        "\n",
        "  return train_losses, test_accuracies\n",
        "\n",
        "def show_mnist_comparison(originals, images, labels, predictions):\n",
        "    \"\"\" 元の画像・ラベル・予測結果を比較表示する関数 \"\"\"\n",
        "    num_images = len(images)\n",
        "    cols = min(5, num_images)  # Display up to 5 images per row\n",
        "    rows = math.ceil(num_images / cols) * 2  # Need twice the number of rows for comparison\n",
        "\n",
        "    fig, axes = plt.subplots(rows, cols, figsize=(cols * 2, rows * 2))\n",
        "    fig.subplots_adjust(hspace=0.5) # Increase spacing between images and titles\n",
        "\n",
        "    for i in range(num_images):\n",
        "        # Original images (First row)\n",
        "        ax = axes[i // cols * 2, i % cols]\n",
        "        orig_img = originals[i].cpu().numpy().squeeze()\n",
        "        ax.imshow(orig_img, cmap=\"gray\")\n",
        "        if isinstance(labels[i], torch.Tensor):\n",
        "            label = labels[i].item()\n",
        "        else:\n",
        "            label = labels[i]\n",
        "        ax.set_title(f\"Original Label: {label}\", fontsize=10, pad=8)  # Adjust padding using `pad`\n",
        "        ax.axis(\"off\")\n",
        "\n",
        "        # Predicted images (Second row)\n",
        "        ax = axes[i // cols * 2 + 1, i % cols]\n",
        "        pred_img = images[i].cpu().numpy().squeeze()\n",
        "        ax.imshow(pred_img, cmap=\"gray\")\n",
        "        ax.set_title(f\"Pred Label: {predictions[i].item()}\", fontsize=10, pad=8)\n",
        "        ax.axis(\"off\")\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "def plot_results(normal_losses, normal_acc, noisy_losses, noisy_acc):\n",
        "    \"\"\" 結果をプロットする関数 \"\"\"\n",
        "    plt.figure(figsize=(10, 4))\n",
        "\n",
        "    # Comparsion of Loss\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.plot(normal_losses, label=\"Normal Training Loss\")\n",
        "    plt.plot(noisy_losses, label=\"Noisy Training Loss\")\n",
        "    plt.xlabel(\"Epoch\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.legend()\n",
        "\n",
        "    # Comparsion of Accuracy\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.plot(normal_acc, label=\"Normal Test Accuracy\")\n",
        "    plt.plot(noisy_acc, label=\"Noisy Test Accuracy\")\n",
        "    plt.xlabel(\"Epoch\")\n",
        "    plt.ylabel(\"Accuracy (%)\")\n",
        "    plt.legend()\n",
        "\n",
        "    plt.suptitle(\"Comparison of Normal vs Noisy Training\")\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "mLIo3Yr6fIid"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Preprocessing ##"
      ],
      "metadata": {
        "id": "CTr60_BkkTKl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Data preprocessing\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.5,), (0.5,))\n",
        "])"
      ],
      "metadata": {
        "id": "Xkb17pmIkcnx"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Load MNIST Dataset ##"
      ],
      "metadata": {
        "id": "AxyzOnoRkoF8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 64\n",
        "train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "noisy_train_dataset = NoisyMNIST(train_dataset, noise_factor=0.3)\n",
        "noisy_test_dataset = NoisyMNIST(test_dataset, noise_factor=0.3)\n",
        "\n",
        "noisy_train_loader = DataLoader(noisy_train_dataset, batch_size=batch_size, shuffle=True)\n",
        "noisy_test_loader = DataLoader(noisy_test_dataset, batch_size=batch_size, shuffle=False)"
      ],
      "metadata": {
        "id": "IkjV9hxlkrso",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "026fbb96-804c-4247-a3c0-3258358196e4"
      },
      "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 404: Not Found\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%|██████████| 9.91M/9.91M [00:00<00:00, 10.6MB/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 404: Not Found\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%|██████████| 28.9k/28.9k [00:00<00:00, 352kB/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 404: Not Found\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%|██████████| 1.65M/1.65M [00:00<00:00, 3.19MB/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 404: Not Found\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%|██████████| 4.54k/4.54k [00:00<00:00, 10.1MB/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Learning ##"
      ],
      "metadata": {
        "id": "pCw7jz7AlR5G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Training on normal data\n",
        "print(\"\\nTraining on normal images:\")\n",
        "model_normal = MNIST_CNN()\n",
        "normal_train_losses, normal_test_accuracies = train_model(model_normal, train_loader, test_loader)\n",
        "\n",
        "# Training on noisy data\n",
        "print(\"\\nTraining on noisy images:\")\n",
        "model_noisy = MNIST_CNN()\n",
        "noisy_train_losses, noisy_test_accuracies = train_model(model_noisy, noisy_train_loader, noisy_test_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AJdP1uExlUQ6",
        "outputId": "b6eee8fc-df85-4357-852e-d60f86ebc7d3"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Training on normal images:\n",
            "Epoch 1: Loss = 0.1552, Test Accuracy = 98.50%\n",
            "Epoch 2: Loss = 0.0443, Test Accuracy = 98.42%\n",
            "Epoch 3: Loss = 0.0284, Test Accuracy = 98.66%\n",
            "Epoch 4: Loss = 0.0204, Test Accuracy = 98.82%\n",
            "Epoch 5: Loss = 0.0154, Test Accuracy = 98.71%\n",
            "\n",
            "Training on noisy images:\n",
            "Epoch 1: Loss = 0.1670, Test Accuracy = 98.20%\n",
            "Epoch 2: Loss = 0.0486, Test Accuracy = 98.48%\n",
            "Epoch 3: Loss = 0.0341, Test Accuracy = 98.51%\n",
            "Epoch 4: Loss = 0.0242, Test Accuracy = 98.88%\n",
            "Epoch 5: Loss = 0.0189, Test Accuracy = 98.88%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Result ##"
      ],
      "metadata": {
        "id": "codO0PwYm9a4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plot_results(normal_train_losses, normal_test_accuracies, noisy_train_losses, noisy_test_accuracies)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 414
        },
        "id": "SHIH8E0Hm_OR",
        "outputId": "154cb430-14f1-41d5-dca4-badf148cd022"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "num_images = 10\n",
        "noisy_originals, lables = zip(*[noisy_test_dataset[i] for i in range(num_images)])\n",
        "noisy_images = torch.stack(noisy_originals).to(device)\n",
        "\n",
        "model_noisy.eval()\n",
        "\n",
        "# Batch processing\n",
        "noisy_images = noisy_images.to(device)\n",
        "\n",
        "# Prediction\n",
        "with torch.no_grad():\n",
        "    predictions = model_noisy(noisy_images).argmax(dim=1)\n",
        "\n",
        "#Display images, labels, and predictions\n",
        "show_mnist_comparison(noisy_originals, noisy_images, lables, predictions)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 704
        },
        "id": "gjH-owQH5Apm",
        "outputId": "a037b122-ef7a-4427-8b3f-1132fce85a59"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x800 with 20 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### **Advanced Topics** ###\n",
        "* Summary : Denoising Autoencoder\n",
        "* Objcevite : Construct, train, and evaluate a model that takes noisy images as input and outputs denoised images.\n",
        "\n"
      ],
      "metadata": {
        "id": "_kU70PXqpuRk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Class and method definitions ###\n",
        "* DenoisigingAutoencoder : CNN Autoencoder Model.\n",
        " * forward : Performs forward propagation\n",
        "* train_autoencoder_model : Model Training Function\n",
        "* visualize_denoising : Visualize Noise Removal"
      ],
      "metadata": {
        "id": "EhX1-HSzVscs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DenoisingAutoencoder(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(DenoisingAutoencoder, self).__init__()\n",
        "    self.encoder = nn.Sequential(\n",
        "        nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(2, 2),\n",
        "        nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(2, 2)\n",
        "    )\n",
        "\n",
        "    self.decoder = nn.Sequential(\n",
        "        nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
        "        nn.Tanh()\n",
        "    )\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.encoder(x)\n",
        "    x = self.decoder(x)\n",
        "    return x\n",
        "\n",
        "def train_autoencoder_model(model, train_loader, num_epochs=5):\n",
        "  \"\"\"モデルの学習関数\"\"\"\n",
        "  device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "  model.to(device)\n",
        "  criterion = nn.MSELoss()\n",
        "  optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "  for epoch in range(num_epochs):\n",
        "      for images, _ in train_loader:\n",
        "          images = images.to(torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"))\n",
        "          noisy_images = add_noise(images)\n",
        "          optimizer.zero_grad()\n",
        "          outputs = model(noisy_images)\n",
        "          loss = criterion(outputs, images)\n",
        "          loss.backward()\n",
        "          optimizer.step()\n",
        "      print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}\")\n",
        "\n",
        "def visualize_denoising(model, test_loader):\n",
        "  \"\"\"ノイズ除去の可視化をする関数\"\"\"\n",
        "  model.eval()\n",
        "  with torch.no_grad():\n",
        "      for images, _ in test_loader:\n",
        "          images = images.to(torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"))\n",
        "          noisy_images = add_noise(images)\n",
        "          outputs = model(noisy_images)\n",
        "          break\n",
        "\n",
        "  fig, axes = plt.subplots(3, 7, figsize=(12, 6))\n",
        "  labels = [\"Original\", \"Noisy\", \"Denoised\"]\n",
        "  for row in range(3):\n",
        "        axes[row, 0].text(-0.5, 0.5, labels[row], va='center', ha='center', fontsize=12, transform=axes[row, 0].transAxes)\n",
        "        axes[row, 0].axis(\"off\")\n",
        "\n",
        "  for i in range(6):\n",
        "      axes[0, i + 1].imshow(images[i].cpu().squeeze(), cmap=\"gray\")\n",
        "      axes[1, i + 1].imshow(noisy_images[i].cpu().squeeze(), cmap=\"gray\")\n",
        "      axes[2, i + 1].imshow(outputs[i].cpu().squeeze(), cmap=\"gray\")\n",
        "\n",
        "      for row in range(3):\n",
        "          axes[row, i + 1].axis(\"off\")\n",
        "  fig.subplots_adjust(left=0.15)\n",
        "  plt.show()\n"
      ],
      "metadata": {
        "id": "Gvqt-rVRS8Qy"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Preprocessing ##"
      ],
      "metadata": {
        "id": "atSVPPAvSa6T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Data preprocessing\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.5,), (0.5,))\n",
        "])"
      ],
      "metadata": {
        "id": "gg7XdiOyqH_7"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Load MNIST Dataset ##"
      ],
      "metadata": {
        "id": "OW2HhzlUSib_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 64\n",
        "train_encoder_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "test_encoder_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "\n",
        "train_encoder_loader = torch.utils.data.DataLoader(train_encoder_dataset, batch_size=batch_size, shuffle=True)\n",
        "test_encoder_loader = torch.utils.data.DataLoader(test_encoder_dataset, batch_size=batch_size, shuffle=False)"
      ],
      "metadata": {
        "id": "t5Oqg-O1Slux"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Learning ##"
      ],
      "metadata": {
        "id": "kvSg82yfVMIo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = DenoisingAutoencoder()\n",
        "train_autoencoder_model(model, train_encoder_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FyqX-QZ-VKfm",
        "outputId": "bd6561c8-59cf-425a-dd55-89fe6fcf6276"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/5], Loss: 0.0151\n",
            "Epoch [2/5], Loss: 0.0135\n",
            "Epoch [3/5], Loss: 0.0140\n",
            "Epoch [4/5], Loss: 0.0095\n",
            "Epoch [5/5], Loss: 0.0109\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Result ##"
      ],
      "metadata": {
        "id": "gNiFOEFkVhMo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "visualize_denoising(model, test_encoder_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 410
        },
        "id": "GTeF1DvHVjsq",
        "outputId": "012ebac4-b723-4e98-8f43-b9e68fc09da5"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 21 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}