Basics/multiclass_classification_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import random\n",
    "import torch\n",
    "from torch import nn, optim\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "DATASET_PATH = \"../data\"\n",
    "CHECKPOINT_PATH = \"../saved_models/multi_classifier_MNIST/simple_model.pth\"\n",
    "\n",
    "def set_seed(seed):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.cuda.manual_seed_all(seed)\n",
    "set_seed(42)\n",
    "\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = False\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.ToTensor()\n",
    "train_dataset = datasets.MNIST(root=DATASET_PATH, train=True, download=True, transform=transform)\n",
    "test_dataset = datasets.MNIST(root=DATASET_PATH, train=False, download=True, transform=transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset MNIST\n",
      "    Number of datapoints: 60000\n",
      "    Root location: ../data\n",
      "    Split: Train\n",
      "    StandardTransform\n",
      "Transform: ToTensor()\n",
      "Dataset MNIST\n",
      "    Number of datapoints: 10000\n",
      "    Root location: ../data\n",
      "    Split: Test\n",
      "    StandardTransform\n",
      "Transform: ToTensor()\n",
      "60000\n",
      "10000\n"
     ]
    }
   ],
   "source": [
    "print(train_dataset)\n",
    "print(test_dataset)\n",
    "print(len(train_dataset))\n",
    "print(len(test_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0 - zero',\n",
       " '1 - one',\n",
       " '2 - two',\n",
       " '3 - three',\n",
       " '4 - four',\n",
       " '5 - five',\n",
       " '6 - six',\n",
       " '7 - seven',\n",
       " '8 - eight',\n",
       " '9 - nine']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x1a253ed3d10>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(train_dataset.data[0], cmap=\"gray\")\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset MNIST\n",
       "    Number of datapoints: 60000\n",
       "    Root location: ../data\n",
       "    Split: Train\n",
       "    StandardTransform\n",
       "Transform: ToTensor()"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_loader.dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1, 28, 28]) torch.Size([32])\n"
     ]
    }
   ],
   "source": [
    "x_batch, y_batch = next(iter(train_loader))\n",
    "print(x_batch.shape, y_batch.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What transforms.ToTensor() do?\n",
    "\n",
    "In generally, image data saved by [H, W, C] (Height, Width, Channel) and the range of value is 0 ~ 255\n",
    "\n",
    "Thus, ToTensor change to\n",
    "- change to tensor\n",
    "- [C, H, W]\n",
    "- Value of data transform to 0.0 ~ 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before ToTensor: torch.Size([60000, 28, 28])\n",
      "After ToTensor: torch.Size([32, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "print(\"Before ToTensor:\", train_dataset.data.shape)\n",
    "\n",
    "print(\"After ToTensor:\", x_batch.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_classes):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.fc2 = nn.Linear(hidden_size, num_classes)\n",
    "\n",
    "        # self.fcs = nn.Sequential(\n",
    "        #     nn.Linear(input_size, hidden_size),\n",
    "        #     nn.ReLU(),\n",
    "        #     nn.Linear(hidden_size, num_classes)\n",
    "        # )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32, 784])\n"
     ]
    }
   ],
   "source": [
    "x_batch, _ = next(iter(train_loader))\n",
    "print(x_batch.shape)\n",
    "flat_images = torch.flatten(x_batch, 1)\n",
    "print(flat_images.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
      "  (relu): ReLU()\n",
      "  (fc2): Linear(in_features=128, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "model = Net(28*28, 128, 10).to(device)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 10])\n"
     ]
    }
   ],
   "source": [
    "x_batch = x_batch.to(device)\n",
    "print(model(x_batch).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:05<00:00, 369.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/10], Loss: 0.2904\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 452.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [2/10], Loss: 0.1253\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 458.91it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [3/10], Loss: 0.0859\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 450.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [4/10], Loss: 0.0651\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 462.27it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [5/10], Loss: 0.0510\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 462.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [6/10], Loss: 0.0408\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 465.24it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [7/10], Loss: 0.0320\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:04<00:00, 468.52it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [8/10], Loss: 0.0269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:03<00:00, 472.61it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [9/10], Loss: 0.0214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [00:03<00:00, 471.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [10/10], Loss: 0.0174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "LEARNING_RATE = 1e-3\n",
    "EPOCHS = 10\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n",
    "\n",
    "def train(model, train_loader, criterion, optimizer, EPOCHS):\n",
    "    model.train()\n",
    "    \n",
    "    for ep in range(EPOCHS):\n",
    "        running_loss = 0.0\n",
    "        total_samples = 0\n",
    "        \n",
    "        for x_batch, y_batch in tqdm(train_loader):\n",
    "            x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "\n",
    "            # model inference\n",
    "            y_hat = model(x_batch)\n",
    "            # loss\n",
    "            loss = criterion(y_hat, y_batch)\n",
    "            # update\n",
    "            optimizer.zero_grad() # gradient Initialize (초기화 하지 않으면 gradient가 누적됨)\n",
    "            loss.backward() # backpropagation\n",
    "            optimizer.step() # weight update\n",
    "\n",
    "            # loss accumulation\n",
    "            batch_size = x_batch.size(0)\n",
    "            running_loss += loss.item() * batch_size\n",
    "            total_samples += batch_size\n",
    "        \n",
    "        # 각 epoch의 평균 loss 계산\n",
    "        epoch_loss = running_loss / total_samples\n",
    "        print(f'Epoch [{ep+1}/{EPOCHS}], Loss: {epoch_loss:.4f}')\n",
    "\n",
    "train(model, train_loader, criterion, optimizer, EPOCHS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict({'fc1.weight': tensor([[ 0.0315, -0.0262,  0.0310,  ...,  0.0344, -0.0162,  0.0241],\n",
      "        [ 0.0181, -0.0299,  0.0230,  ..., -0.0213,  0.0084, -0.0042],\n",
      "        [-0.0162,  0.0150,  0.0003,  ...,  0.0155,  0.0046,  0.0110],\n",
      "        ...,\n",
      "        [-0.0070,  0.0022,  0.0340,  ..., -0.0229, -0.0272,  0.0094],\n",
      "        [-0.0249,  0.0003, -0.0107,  ..., -0.0346, -0.0113, -0.0264],\n",
      "        [-0.0220, -0.0219,  0.0265,  ...,  0.0218,  0.0336, -0.0083]],\n",
      "       device='cuda:0'), 'fc1.bias': tensor([-0.3283, -0.0329, -0.0271,  0.2090, -0.0809, -0.0505,  0.0197, -0.0212,\n",
      "         0.0852, -0.1440, -0.0373, -0.0951, -0.0032, -0.1256,  0.0297,  0.0183,\n",
      "        -0.0007, -0.0152,  0.0631, -0.0649, -0.0041,  0.0552,  0.1317,  0.0136,\n",
      "        -0.0253,  0.0320, -0.0056,  0.0745, -0.0144,  0.0409,  0.0364, -0.2009,\n",
      "         0.0488,  0.1773, -0.1909,  0.1071, -0.1066,  0.1205,  0.1432, -0.0286,\n",
      "         0.1432,  0.2029,  0.0199,  0.0313,  0.0396,  0.2770, -0.0922, -0.0534,\n",
      "        -0.0467,  0.2593,  0.3008,  0.1032, -0.1240, -0.0144, -0.0894, -0.0189,\n",
      "        -0.1728, -0.0513, -0.0101,  0.0180,  0.0541, -0.0201, -0.0100,  0.1805,\n",
      "         0.2225, -0.0281, -0.0615,  0.1980,  0.1684, -0.0207, -0.0971,  0.1744,\n",
      "         0.1301, -0.0218, -0.0777,  0.0385,  0.0255, -0.0443,  0.2895,  0.2608,\n",
      "         0.0149, -0.1159, -0.0999,  0.2137,  0.2974,  0.2426,  0.0568, -0.0941,\n",
      "         0.0998, -0.1805, -0.1847, -0.1246, -0.0444, -0.0681,  0.1466, -0.0023,\n",
      "         0.0719,  0.2085,  0.0212,  0.3514,  0.0771, -0.0004,  0.2004, -0.0243,\n",
      "         0.0645,  0.2598,  0.0447,  0.2078, -0.1712,  0.0926,  0.1080,  0.0948,\n",
      "         0.0263,  0.0580, -0.0350, -0.1724, -0.0490, -0.1276, -0.1119, -0.0861,\n",
      "        -0.0688, -0.0745,  0.2330,  0.0854, -0.0088,  0.2889, -0.0363,  0.0135],\n",
      "       device='cuda:0'), 'fc2.weight': tensor([[ 0.2505, -0.2052, -0.8251,  ..., -0.4539,  0.3398,  0.0358],\n",
      "        [ 0.1712,  0.2864,  0.1340,  ..., -0.2038, -0.2191, -0.3952],\n",
      "        [ 0.1342, -0.0779, -0.0674,  ..., -0.4107,  0.1420,  0.4005],\n",
      "        ...,\n",
      "        [ 0.1418,  0.1877, -0.0637,  ...,  0.1698, -0.2711,  0.2321],\n",
      "        [ 0.0611,  0.1882,  0.1410,  ..., -0.1122,  0.2598, -0.4824],\n",
      "        [-0.7888, -0.2570, -0.2531,  ...,  0.1951,  0.0312, -0.2749]],\n",
      "       device='cuda:0'), 'fc2.bias': tensor([-0.0350, -0.0772, -0.1085, -0.2657,  0.2124,  0.0670,  0.0338, -0.1421,\n",
      "         0.2178,  0.1237], device='cuda:0')})\n"
     ]
    }
   ],
   "source": [
    "state_dict = model.state_dict()\n",
    "print(state_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs(os.path.dirname(CHECKPOINT_PATH), exist_ok=True)\n",
    "torch.save(state_dict, CHECKPOINT_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\joy4m\\AppData\\Local\\Temp\\ipykernel_108408\\2168638086.py:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  load_model.load_state_dict(torch.load(CHECKPOINT_PATH, map_location=device))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_model = Net(28*28, 128, 10).to(device)\n",
    "load_model.load_state_dict(torch.load(CHECKPOINT_PATH, map_location=device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:00<00:00, 604.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 9747/10000 97.47%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "def test(model, test_loader):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        running_correct = 0\n",
    "        for x_batch, y_batch in tqdm(test_loader):\n",
    "            x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "            y_hat = model(x_batch)\n",
    "            \n",
    "            pred = y_hat.argmax(dim=1, keepdim=True)\n",
    "            running_correct += torch.sum(pred == y_batch.view_as(pred)).item() \n",
    "\n",
    "        acc = running_correct / len(test_loader.dataset) * 100\n",
    "        print(f'Accuracy: {running_correct}/{len(test_loader.dataset)} {acc:.2f}%')\n",
    "\n",
    "test(load_model, test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:00<00:00, 626.29it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "\n",
    "def plot_confusion_matrix(model, test_loader):\n",
    "    model.eval()\n",
    "    all_preds = []\n",
    "    all_labels = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for x_batch, y_batch in tqdm(test_loader):\n",
    "            x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "            y_hat = model(x_batch)\n",
    "            preds = y_hat.argmax(dim=1, keepdim=True)\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "            all_labels.extend(y_batch.cpu().numpy())\n",
    "    \n",
    "    cm = confusion_matrix(all_labels, all_preds)\n",
    "    plt.figure(figsize=(10, 8))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=range(10), yticklabels=range(10))\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('True')\n",
    "    plt.title('Confusion Matrix')\n",
    "    plt.show()\n",
    "\n",
    "plot_confusion_matrix(load_model, test_loader)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DL_pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}