HW4_CNN_Fashion_MNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/0-lingual/Advanced-machine-learning/blob/main/HW4_CNN_Fashion_MNIST.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ls"
      ],
      "metadata": {
        "id": "ECTV6ttGgjVK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee30edcb-e54e-4a3e-8c64-b522e0913995"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "README.md\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X5cGnvi7A3Un",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f0aa741-8be3-432a-b3a5-d6c2070d297a"
      },
      "source": [
        " !nvidia-smi"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mon Apr 29 01:51:57 2024       \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |\n",
            "|-----------------------------------------+----------------------+----------------------+\n",
            "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                                         |                      |               MIG M. |\n",
            "|=========================================+======================+======================|\n",
            "|   0  Tesla T4                       Off | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   36C    P8               9W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                                         |                      |                  N/A |\n",
            "+-----------------------------------------+----------------------+----------------------+\n",
            "                                                                                         \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| Processes:                                                                            |\n",
            "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
            "|        ID   ID                                                             Usage      |\n",
            "|=======================================================================================|\n",
            "|  No running processes found                                                           |\n",
            "+---------------------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Y2OsX2EQU3v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e5d59de-1e67-4230-8348-4452cca2b36b"
      },
      "source": [
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision.datasets as datasets\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# This mounts your google drive storage to this code\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AryDcrN7QU31",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3389fec2-19fc-4108-e754-2d25adbd2965"
      },
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(f\"Using {device} device\")\n",
        "\n",
        "root = '/content/gdrive/My Drive/Test/'\n",
        "\n",
        "# root = './'\n",
        "# if not os.path.exists(root):\n",
        "#     os.makedirs(root)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using cuda device\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6HVAXJ7DQU35"
      },
      "source": [
        "# settings for data normalization\n",
        "# trans = transforms.Compose([transform.ToTensor(), transform.Normalize((0.5,),(1.0,))])\n",
        "trans = transforms.ToTensor()\n",
        "# trans = transforms.Compose([transforms.ToTensor(), transforms.RandomHorizontalFlip()])\n",
        "\n",
        "\n",
        "train_data = datasets.FashionMNIST(\n",
        "    root=root,\n",
        "    train=True,\n",
        "    download=True,\n",
        "    transform=trans,\n",
        ")\n",
        "\n",
        "test_data = datasets.FashionMNIST(\n",
        "    root=root,\n",
        "    train=False,\n",
        "    download=True,\n",
        "    transform=trans,\n",
        ")\n",
        "\n",
        "\n",
        "batch_size = 64 # batch_size를 50에서 64로 변경함\n",
        "train_loader = torch.utils.data.DataLoader(train_data,batch_size=batch_size,shuffle=True)\n",
        "test_loader = torch.utils.data.DataLoader(test_data,batch_size=batch_size,shuffle=False)\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # Linear Classification\n",
        "# class LinearClassification(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super().__init__()\n",
        "#         self.flatten = nn.Flatten()\n",
        "#         self.linear = nn.Sequential(\n",
        "#             nn.Linear(28*28, 10),\n",
        "#         )\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.flatten(x)\n",
        "#         logits = self.linear(x)\n",
        "#         return logits\n",
        "\n",
        "# model = LinearClassification().to(device)\n",
        "# print(model)\n"
      ],
      "metadata": {
        "id": "wdDmKu9z_eu3"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # Multi-layer Perceptron\n",
        "# class NeuralNetwork(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super().__init__()\n",
        "#         self.flatten = nn.Flatten()\n",
        "#         self.linear_relu_stack = nn.Sequential(\n",
        "#             nn.Linear(28*28, 512),\n",
        "#             nn.ReLU(),\n",
        "#             nn.Linear(512, 512),\n",
        "#             nn.ReLU(),\n",
        "#             nn.Linear(512, 10)\n",
        "#         )\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.flatten(x)\n",
        "#         logits = self.linear_relu_stack(x)\n",
        "#         return logits\n",
        "\n",
        "# model = NeuralNetwork().to(device)\n",
        "# print(model)\n"
      ],
      "metadata": {
        "id": "bhPn_4CvsfV9"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4kyTJnAQU39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99f537e1-cdba-41e2-a81f-f8edba770271"
      },
      "source": [
        "# define the CNN:\n",
        "# two convolution layers followed by two linear layers\n",
        "\n",
        "class MyConvNet(nn.Module):   # nn.Module should be inherited for the neural network configuration so that it can work with backpropagation APIs\n",
        "    def __init__(self):    # define layers: two conv layers and two linear (fully connected) layers\n",
        "        super(MyConvNet, self).__init__()\n",
        "        self.conv_layers = nn.Sequential(\n",
        "            nn.Conv2d(1, 32, 5),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(2,2),\n",
        "            nn.Conv2d(32, 64, 5),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(2,2),\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(4*4*64, 512),\n",
        "            nn.Linear(512, 10)\n",
        "        )\n",
        "\n",
        "    # network connection: two conv layers, each followed by relu and max-pooling with (2x2) kernel, and two linear layer\n",
        "    def forward(self, x):\n",
        "        logits = self.conv_layers(x)\n",
        "        return(logits)\n",
        "\n",
        "\n",
        "# generate neural net model\n",
        "model = MyConvNet().to(device)\n",
        "print(model)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MyConvNet(\n",
            "  (conv_layers): Sequential(\n",
            "    (0): Conv2d(1, 32, kernel_size=(5, 5), stride=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1))\n",
            "    (4): ReLU()\n",
            "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (6): Flatten(start_dim=1, end_dim=-1)\n",
            "    (7): Linear(in_features=1024, out_features=512, bias=True)\n",
            "    (8): Linear(in_features=512, out_features=10, bias=True)\n",
            "  )\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TZU3HDu0QU4B"
      },
      "source": [
        "optimizer = optim.AdamW(model.parameters(), lr=1e-3) # optimizer를 AdamW로 변경함\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b0uJzp41QU4G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81f75f15-8737-4ab5-dd26-278e00e7d424"
      },
      "source": [
        "# training and test\n",
        "\n",
        "# epoch: 10\n",
        "# data dimension: batch_size x Channels x Height x Width (NCHW)\n",
        "for epoch in range(10):\n",
        "    # training phase\n",
        "    # model.train()\n",
        "    current_loss= 0.0\n",
        "    for batch_num, (x, target) in enumerate(train_loader):\n",
        "        x, target = x.to(device), target.to(device)\n",
        "\n",
        "        out = model(x)\n",
        "        loss = criterion(out,target)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        current_loss += loss\n",
        "\n",
        "        # display the training loss in every 100 batches\n",
        "        if (batch_num+1)%100 == 0 or (batch_num+1)%100 == len(train_loader):\n",
        "            print('epoch: %d, batch_num: %d, current_loss: %.3f' %(epoch, batch_num+1, current_loss/100))\n",
        "            current_loss = 0.0\n",
        "\n",
        "\n",
        "    # test phase\n",
        "    with torch.no_grad():\n",
        "        # model.eval()\n",
        "        total_samples = 0.0\n",
        "        correct_samples = 0.0\n",
        "        for (x, target) in test_loader:\n",
        "            x, target = x.to(device), target.to(device)\n",
        "            out = model(x)\n",
        "            pred = torch.argmax(out,1)\n",
        "            correct_samples += (pred == target).sum()\n",
        "        print('Accuracy: %.3f' %(100*float(correct_samples) / float(len(test_data))))\n",
        "\n",
        "\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch: 0, batch_num: 100, current_loss: 0.925\n",
            "epoch: 0, batch_num: 200, current_loss: 0.559\n",
            "epoch: 0, batch_num: 300, current_loss: 0.471\n",
            "epoch: 0, batch_num: 400, current_loss: 0.465\n",
            "epoch: 0, batch_num: 500, current_loss: 0.385\n",
            "epoch: 0, batch_num: 600, current_loss: 0.406\n",
            "epoch: 0, batch_num: 700, current_loss: 0.360\n",
            "epoch: 0, batch_num: 800, current_loss: 0.351\n",
            "epoch: 0, batch_num: 900, current_loss: 0.342\n",
            "Accuracy: 86.280\n",
            "epoch: 1, batch_num: 100, current_loss: 0.309\n",
            "epoch: 1, batch_num: 200, current_loss: 0.317\n",
            "epoch: 1, batch_num: 300, current_loss: 0.324\n",
            "epoch: 1, batch_num: 400, current_loss: 0.296\n",
            "epoch: 1, batch_num: 500, current_loss: 0.312\n",
            "epoch: 1, batch_num: 600, current_loss: 0.312\n",
            "epoch: 1, batch_num: 700, current_loss: 0.270\n",
            "epoch: 1, batch_num: 800, current_loss: 0.298\n",
            "epoch: 1, batch_num: 900, current_loss: 0.308\n",
            "Accuracy: 87.790\n",
            "epoch: 2, batch_num: 100, current_loss: 0.262\n",
            "epoch: 2, batch_num: 200, current_loss: 0.274\n",
            "epoch: 2, batch_num: 300, current_loss: 0.277\n",
            "epoch: 2, batch_num: 400, current_loss: 0.257\n",
            "epoch: 2, batch_num: 500, current_loss: 0.261\n",
            "epoch: 2, batch_num: 600, current_loss: 0.275\n",
            "epoch: 2, batch_num: 700, current_loss: 0.241\n",
            "epoch: 2, batch_num: 800, current_loss: 0.275\n",
            "epoch: 2, batch_num: 900, current_loss: 0.264\n",
            "Accuracy: 89.670\n",
            "epoch: 3, batch_num: 100, current_loss: 0.242\n",
            "epoch: 3, batch_num: 200, current_loss: 0.234\n",
            "epoch: 3, batch_num: 300, current_loss: 0.239\n",
            "epoch: 3, batch_num: 400, current_loss: 0.241\n",
            "epoch: 3, batch_num: 500, current_loss: 0.244\n",
            "epoch: 3, batch_num: 600, current_loss: 0.257\n",
            "epoch: 3, batch_num: 700, current_loss: 0.253\n",
            "epoch: 3, batch_num: 800, current_loss: 0.237\n",
            "epoch: 3, batch_num: 900, current_loss: 0.241\n",
            "Accuracy: 89.890\n",
            "epoch: 4, batch_num: 100, current_loss: 0.206\n",
            "epoch: 4, batch_num: 200, current_loss: 0.219\n",
            "epoch: 4, batch_num: 300, current_loss: 0.209\n",
            "epoch: 4, batch_num: 400, current_loss: 0.221\n",
            "epoch: 4, batch_num: 500, current_loss: 0.230\n",
            "epoch: 4, batch_num: 600, current_loss: 0.216\n",
            "epoch: 4, batch_num: 700, current_loss: 0.218\n",
            "epoch: 4, batch_num: 800, current_loss: 0.227\n",
            "epoch: 4, batch_num: 900, current_loss: 0.233\n",
            "Accuracy: 90.240\n",
            "epoch: 5, batch_num: 100, current_loss: 0.197\n",
            "epoch: 5, batch_num: 200, current_loss: 0.201\n",
            "epoch: 5, batch_num: 300, current_loss: 0.197\n",
            "epoch: 5, batch_num: 400, current_loss: 0.208\n",
            "epoch: 5, batch_num: 500, current_loss: 0.204\n",
            "epoch: 5, batch_num: 600, current_loss: 0.211\n",
            "epoch: 5, batch_num: 700, current_loss: 0.203\n",
            "epoch: 5, batch_num: 800, current_loss: 0.218\n",
            "epoch: 5, batch_num: 900, current_loss: 0.203\n",
            "Accuracy: 90.170\n",
            "epoch: 6, batch_num: 100, current_loss: 0.187\n",
            "epoch: 6, batch_num: 200, current_loss: 0.181\n",
            "epoch: 6, batch_num: 300, current_loss: 0.183\n",
            "epoch: 6, batch_num: 400, current_loss: 0.197\n",
            "epoch: 6, batch_num: 500, current_loss: 0.188\n",
            "epoch: 6, batch_num: 600, current_loss: 0.192\n",
            "epoch: 6, batch_num: 700, current_loss: 0.197\n",
            "epoch: 6, batch_num: 800, current_loss: 0.191\n",
            "epoch: 6, batch_num: 900, current_loss: 0.197\n",
            "Accuracy: 90.040\n",
            "epoch: 7, batch_num: 100, current_loss: 0.182\n",
            "epoch: 7, batch_num: 200, current_loss: 0.172\n",
            "epoch: 7, batch_num: 300, current_loss: 0.172\n",
            "epoch: 7, batch_num: 400, current_loss: 0.177\n",
            "epoch: 7, batch_num: 500, current_loss: 0.168\n",
            "epoch: 7, batch_num: 600, current_loss: 0.185\n",
            "epoch: 7, batch_num: 700, current_loss: 0.183\n",
            "epoch: 7, batch_num: 800, current_loss: 0.192\n",
            "epoch: 7, batch_num: 900, current_loss: 0.186\n",
            "Accuracy: 89.350\n",
            "epoch: 8, batch_num: 100, current_loss: 0.163\n",
            "epoch: 8, batch_num: 200, current_loss: 0.156\n",
            "epoch: 8, batch_num: 300, current_loss: 0.153\n",
            "epoch: 8, batch_num: 400, current_loss: 0.160\n",
            "epoch: 8, batch_num: 500, current_loss: 0.165\n",
            "epoch: 8, batch_num: 600, current_loss: 0.172\n",
            "epoch: 8, batch_num: 700, current_loss: 0.159\n",
            "epoch: 8, batch_num: 800, current_loss: 0.166\n",
            "epoch: 8, batch_num: 900, current_loss: 0.181\n",
            "Accuracy: 90.110\n",
            "epoch: 9, batch_num: 100, current_loss: 0.154\n",
            "epoch: 9, batch_num: 200, current_loss: 0.145\n",
            "epoch: 9, batch_num: 300, current_loss: 0.156\n",
            "epoch: 9, batch_num: 400, current_loss: 0.160\n",
            "epoch: 9, batch_num: 500, current_loss: 0.148\n",
            "epoch: 9, batch_num: 600, current_loss: 0.163\n",
            "epoch: 9, batch_num: 700, current_loss: 0.180\n",
            "epoch: 9, batch_num: 800, current_loss: 0.176\n",
            "epoch: 9, batch_num: 900, current_loss: 0.151\n",
            "Accuracy: 90.260\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kdAbm_TvQU4N",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 763
        },
        "outputId": "e9ec42b9-ec96-4e27-eee8-fa99a1fc19df"
      },
      "source": [
        "# Display Some test results\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "classes = [\n",
        "    \"T-shirt/top\",\n",
        "    \"Trouser\",\n",
        "    \"Pullover\",\n",
        "    \"Dress\",\n",
        "    \"Coat\",\n",
        "    \"Sandal\",\n",
        "    \"Shirt\",\n",
        "    \"Sneaker\",\n",
        "    \"Bag\",\n",
        "    \"Ankle boot\",\n",
        "]\n",
        "\n",
        "# take one batch of the data\n",
        "test_data, test_labels = next(iter(test_loader))\n",
        "\n",
        "# if cuda_available:\n",
        "test_data, test_labels = test_data.to(device), test_labels.to(device)\n",
        "out = model(test_data)              # put the test data to the trained network\n",
        "pred = torch.argmax(out,1)          # prediction to the highest probability\n",
        "\n",
        "\n",
        "sample_index = np.random.choice(batch_size, size=12)     # take 12 random sample index\n",
        "num_samples = sample_index.size\n",
        "\n",
        "random_samples = test_data[sample_index].cpu().numpy()\n",
        "\n",
        "plt.figure(figsize=(12, 12))\n",
        "\n",
        "# display test samples\n",
        "for k in range(num_samples):\n",
        "    plt.subplot(4, 4, k + 1)\n",
        "    plt.imshow(random_samples[k].reshape(28, 28),cmap='Greys')\n",
        "    plt.title(\"True: \" + str( classes[test_labels[sample_index[k]].item()]) + \",\\nPred: \" + str(classes[pred[sample_index[k]].item()]))\n",
        "    plt.axis('off')\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 12 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# save model\n",
        "torch.save(model, root + 'my_CNN_model.pth')\n",
        "\n",
        "# load model\n",
        "# model = torch.load('my_CNN_model.pth')"
      ],
      "metadata": {
        "id": "qhPBxl3OO09E"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # save model weights\n",
        "# torch.save(model.state_dict(), 'model_weights.pth')\n",
        "\n",
        "# # load model weights\n",
        "# model = MyConvNet()\n",
        "# model.load_state_dict(torch.load('model_weights.pth'))\n"
      ],
      "metadata": {
        "id": "uLBE-ZKbP0oJ"
      },
      "execution_count": 18,
      "outputs": []
    }
  ]
}