3-3_MNIST_MLP_Dropout_ReLU_BN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' 1. Module Import '''\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torchvision import transforms, datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using PyTorch version: 1.6.0+cu101  Device: cuda\n"
     ]
    }
   ],
   "source": [
    "''' 2. 딥러닝 모델을 설계할 때 활용하는 장비 확인 '''\n",
    "if torch.cuda.is_available():\n",
    "    DEVICE = torch.device('cuda')\n",
    "else:\n",
    "    DEVICE = torch.device('cpu')\n",
    "print('Using PyTorch version:', torch.__version__, ' Device:', DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "EPOCHS = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' 3. MNIST 데이터 다운로드 (Train set, Test set 분리하기) '''\n",
    "train_dataset = datasets.MNIST(root = \"../data/MNIST\",\n",
    "                               train = True,\n",
    "                               download = True,\n",
    "                               transform = transforms.ToTensor())\n",
    "\n",
    "test_dataset = datasets.MNIST(root = \"../data/MNIST\",\n",
    "                              train = False,\n",
    "                              transform = transforms.ToTensor())\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset = train_dataset,\n",
    "                                           batch_size = BATCH_SIZE,\n",
    "                                           shuffle = True)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(dataset = test_dataset,\n",
    "                                          batch_size = BATCH_SIZE,\n",
    "                                          shuffle = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train: torch.Size([32, 1, 28, 28]) type: torch.FloatTensor\n",
      "y_train: torch.Size([32]) type: torch.LongTensor\n"
     ]
    }
   ],
   "source": [
    "''' 4. 데이터 확인하기 (1) '''\n",
    "for (X_train, y_train) in train_loader:\n",
    "    print('X_train:', X_train.size(), 'type:', X_train.type())\n",
    "    print('y_train:', y_train.size(), 'type:', y_train.type())\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x72 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 5. 데이터 확인하기 (2) '''\n",
    "pltsize = 1\n",
    "plt.figure(figsize=(10 * pltsize, pltsize))\n",
    "for i in range(10):\n",
    "    plt.subplot(1, 10, i + 1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(X_train[i, :, :, :].numpy().reshape(28, 28), cmap = \"gray_r\")\n",
    "    plt.title('Class: ' + str(y_train[i].item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' 6. Multi Layer Perceptron (MLP) 모델 설계하기 '''\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(28 * 28, 512)\n",
    "        self.fc2 = nn.Linear(512, 256)\n",
    "        self.fc3 = nn.Linear(256, 10)\n",
    "        self.dropout_prob = 0.5\n",
    "        self.batch_norm1 = nn.BatchNorm1d(512)\n",
    "        self.batch_norm2 = nn.BatchNorm1d(256)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28 * 28)\n",
    "        x = self.fc1(x)\n",
    "        x = self.batch_norm1(x)\n",
    "        x = F.relu(x)\n",
    "        x = F.dropout(x, training = self.training, p = self.dropout_prob)\n",
    "        x = self.fc2(x)\n",
    "        x = self.batch_norm2(x)\n",
    "        x = F.relu(x)\n",
    "        x = F.dropout(x, training = self.training, p = self.dropout_prob)\n",
    "        x = self.fc3(x)\n",
    "        x = F.log_softmax(x, dim = 1)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (fc1): Linear(in_features=784, out_features=512, bias=True)\n",
      "  (fc2): Linear(in_features=512, out_features=256, bias=True)\n",
      "  (fc3): Linear(in_features=256, out_features=10, bias=True)\n",
      "  (batch_norm1): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (batch_norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "''' 7. Optimizer, Objective Function 설정하기 '''\n",
    "model = Net().to(DEVICE)\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = 0.01, momentum = 0.5)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' 8. MLP 모델 학습을 진행하며 학습 데이터에 대한 모델 성능을 확인하는 함수 정의 '''\n",
    "def train(model, train_loader, optimizer, log_interval):\n",
    "    model.train()\n",
    "    for batch_idx, (image, label) in enumerate(train_loader):\n",
    "        image = image.to(DEVICE)\n",
    "        label = label.to(DEVICE)\n",
    "        optimizer.zero_grad()\n",
    "        output = model(image)\n",
    "        loss = criterion(output, label)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch_idx % log_interval == 0:\n",
    "            print(\"Train Epoch: {} [{}/{} ({:.0f}%)]\\tTrain Loss: {:.6f}\".format(\n",
    "                epoch, batch_idx * len(image), \n",
    "                len(train_loader.dataset), 100. * batch_idx / len(train_loader), \n",
    "                loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' 9. 학습되는 과정 속에서 검증 데이터에 대한 모델 성능을 확인하는 함수 정의 '''\n",
    "def evaluate(model, test_loader):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for image, label in test_loader:\n",
    "            image = image.to(DEVICE)\n",
    "            label = label.to(DEVICE)\n",
    "            output = model(image)\n",
    "            test_loss += criterion(output, label).item()\n",
    "            prediction = output.max(1, keepdim = True)[1]\n",
    "            correct += prediction.eq(label.view_as(prediction)).sum().item()\n",
    "    \n",
    "    test_loss /= (len(test_loader.dataset) / BATCH_SIZE)\n",
    "    test_accuracy = 100. * correct / len(test_loader.dataset)\n",
    "    return test_loss, test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1 [0/60000 (0%)]\tTrain Loss: 2.408397\n",
      "Train Epoch: 1 [6400/60000 (11%)]\tTrain Loss: 0.565749\n",
      "Train Epoch: 1 [12800/60000 (21%)]\tTrain Loss: 0.529340\n",
      "Train Epoch: 1 [19200/60000 (32%)]\tTrain Loss: 0.337603\n",
      "Train Epoch: 1 [25600/60000 (43%)]\tTrain Loss: 0.587682\n",
      "Train Epoch: 1 [32000/60000 (53%)]\tTrain Loss: 0.371249\n",
      "Train Epoch: 1 [38400/60000 (64%)]\tTrain Loss: 0.757439\n",
      "Train Epoch: 1 [44800/60000 (75%)]\tTrain Loss: 0.523711\n",
      "Train Epoch: 1 [51200/60000 (85%)]\tTrain Loss: 0.288144\n",
      "Train Epoch: 1 [57600/60000 (96%)]\tTrain Loss: 0.253793\n",
      "\n",
      "[EPOCH: 1], \tTest Loss: 0.0048, \tTest Accuracy: 95.26 % \n",
      "\n",
      "Train Epoch: 2 [0/60000 (0%)]\tTrain Loss: 0.408605\n",
      "Train Epoch: 2 [6400/60000 (11%)]\tTrain Loss: 0.290822\n",
      "Train Epoch: 2 [12800/60000 (21%)]\tTrain Loss: 0.197596\n",
      "Train Epoch: 2 [19200/60000 (32%)]\tTrain Loss: 0.256635\n",
      "Train Epoch: 2 [25600/60000 (43%)]\tTrain Loss: 0.263706\n",
      "Train Epoch: 2 [32000/60000 (53%)]\tTrain Loss: 0.269775\n",
      "Train Epoch: 2 [38400/60000 (64%)]\tTrain Loss: 0.330976\n",
      "Train Epoch: 2 [44800/60000 (75%)]\tTrain Loss: 0.063536\n",
      "Train Epoch: 2 [51200/60000 (85%)]\tTrain Loss: 0.278092\n",
      "Train Epoch: 2 [57600/60000 (96%)]\tTrain Loss: 0.370884\n",
      "\n",
      "[EPOCH: 2], \tTest Loss: 0.0037, \tTest Accuracy: 96.38 % \n",
      "\n",
      "Train Epoch: 3 [0/60000 (0%)]\tTrain Loss: 0.473225\n",
      "Train Epoch: 3 [6400/60000 (11%)]\tTrain Loss: 0.359397\n",
      "Train Epoch: 3 [12800/60000 (21%)]\tTrain Loss: 0.335095\n",
      "Train Epoch: 3 [19200/60000 (32%)]\tTrain Loss: 0.061883\n",
      "Train Epoch: 3 [25600/60000 (43%)]\tTrain Loss: 0.148324\n",
      "Train Epoch: 3 [32000/60000 (53%)]\tTrain Loss: 0.295295\n",
      "Train Epoch: 3 [38400/60000 (64%)]\tTrain Loss: 0.143966\n",
      "Train Epoch: 3 [44800/60000 (75%)]\tTrain Loss: 0.027375\n",
      "Train Epoch: 3 [51200/60000 (85%)]\tTrain Loss: 0.296227\n",
      "Train Epoch: 3 [57600/60000 (96%)]\tTrain Loss: 0.146117\n",
      "\n",
      "[EPOCH: 3], \tTest Loss: 0.0031, \tTest Accuracy: 96.92 % \n",
      "\n",
      "Train Epoch: 4 [0/60000 (0%)]\tTrain Loss: 0.128434\n",
      "Train Epoch: 4 [6400/60000 (11%)]\tTrain Loss: 0.144728\n",
      "Train Epoch: 4 [12800/60000 (21%)]\tTrain Loss: 0.251649\n",
      "Train Epoch: 4 [19200/60000 (32%)]\tTrain Loss: 0.080718\n",
      "Train Epoch: 4 [25600/60000 (43%)]\tTrain Loss: 0.185179\n",
      "Train Epoch: 4 [32000/60000 (53%)]\tTrain Loss: 0.388055\n",
      "Train Epoch: 4 [38400/60000 (64%)]\tTrain Loss: 0.169363\n",
      "Train Epoch: 4 [44800/60000 (75%)]\tTrain Loss: 0.044224\n",
      "Train Epoch: 4 [51200/60000 (85%)]\tTrain Loss: 0.206786\n",
      "Train Epoch: 4 [57600/60000 (96%)]\tTrain Loss: 0.246572\n",
      "\n",
      "[EPOCH: 4], \tTest Loss: 0.0028, \tTest Accuracy: 97.29 % \n",
      "\n",
      "Train Epoch: 5 [0/60000 (0%)]\tTrain Loss: 0.072247\n",
      "Train Epoch: 5 [6400/60000 (11%)]\tTrain Loss: 0.243650\n",
      "Train Epoch: 5 [12800/60000 (21%)]\tTrain Loss: 0.123755\n",
      "Train Epoch: 5 [19200/60000 (32%)]\tTrain Loss: 0.073167\n",
      "Train Epoch: 5 [25600/60000 (43%)]\tTrain Loss: 0.055972\n",
      "Train Epoch: 5 [32000/60000 (53%)]\tTrain Loss: 0.302183\n",
      "Train Epoch: 5 [38400/60000 (64%)]\tTrain Loss: 0.355575\n",
      "Train Epoch: 5 [44800/60000 (75%)]\tTrain Loss: 0.080272\n",
      "Train Epoch: 5 [51200/60000 (85%)]\tTrain Loss: 0.410138\n",
      "Train Epoch: 5 [57600/60000 (96%)]\tTrain Loss: 0.532726\n",
      "\n",
      "[EPOCH: 5], \tTest Loss: 0.0026, \tTest Accuracy: 97.54 % \n",
      "\n",
      "Train Epoch: 6 [0/60000 (0%)]\tTrain Loss: 0.082712\n",
      "Train Epoch: 6 [6400/60000 (11%)]\tTrain Loss: 0.242383\n",
      "Train Epoch: 6 [12800/60000 (21%)]\tTrain Loss: 0.073166\n",
      "Train Epoch: 6 [19200/60000 (32%)]\tTrain Loss: 0.065983\n",
      "Train Epoch: 6 [25600/60000 (43%)]\tTrain Loss: 0.153423\n",
      "Train Epoch: 6 [32000/60000 (53%)]\tTrain Loss: 0.106637\n",
      "Train Epoch: 6 [38400/60000 (64%)]\tTrain Loss: 0.181440\n",
      "Train Epoch: 6 [44800/60000 (75%)]\tTrain Loss: 0.217991\n",
      "Train Epoch: 6 [51200/60000 (85%)]\tTrain Loss: 0.047518\n",
      "Train Epoch: 6 [57600/60000 (96%)]\tTrain Loss: 0.152127\n",
      "\n",
      "[EPOCH: 6], \tTest Loss: 0.0024, \tTest Accuracy: 97.55 % \n",
      "\n",
      "Train Epoch: 7 [0/60000 (0%)]\tTrain Loss: 0.074586\n",
      "Train Epoch: 7 [6400/60000 (11%)]\tTrain Loss: 0.285396\n",
      "Train Epoch: 7 [12800/60000 (21%)]\tTrain Loss: 0.101163\n",
      "Train Epoch: 7 [19200/60000 (32%)]\tTrain Loss: 0.222260\n",
      "Train Epoch: 7 [25600/60000 (43%)]\tTrain Loss: 0.096511\n",
      "Train Epoch: 7 [32000/60000 (53%)]\tTrain Loss: 0.184161\n",
      "Train Epoch: 7 [38400/60000 (64%)]\tTrain Loss: 0.040291\n",
      "Train Epoch: 7 [44800/60000 (75%)]\tTrain Loss: 0.186297\n",
      "Train Epoch: 7 [51200/60000 (85%)]\tTrain Loss: 0.321589\n",
      "Train Epoch: 7 [57600/60000 (96%)]\tTrain Loss: 0.179110\n",
      "\n",
      "[EPOCH: 7], \tTest Loss: 0.0022, \tTest Accuracy: 97.74 % \n",
      "\n",
      "Train Epoch: 8 [0/60000 (0%)]\tTrain Loss: 0.041527\n",
      "Train Epoch: 8 [6400/60000 (11%)]\tTrain Loss: 0.089809\n",
      "Train Epoch: 8 [12800/60000 (21%)]\tTrain Loss: 0.173585\n",
      "Train Epoch: 8 [19200/60000 (32%)]\tTrain Loss: 0.122103\n",
      "Train Epoch: 8 [25600/60000 (43%)]\tTrain Loss: 0.102293\n",
      "Train Epoch: 8 [32000/60000 (53%)]\tTrain Loss: 0.140654\n",
      "Train Epoch: 8 [38400/60000 (64%)]\tTrain Loss: 0.190124\n",
      "Train Epoch: 8 [44800/60000 (75%)]\tTrain Loss: 0.364228\n",
      "Train Epoch: 8 [51200/60000 (85%)]\tTrain Loss: 0.095618\n",
      "Train Epoch: 8 [57600/60000 (96%)]\tTrain Loss: 0.050769\n",
      "\n",
      "[EPOCH: 8], \tTest Loss: 0.0022, \tTest Accuracy: 97.87 % \n",
      "\n",
      "Train Epoch: 9 [0/60000 (0%)]\tTrain Loss: 0.289604\n",
      "Train Epoch: 9 [6400/60000 (11%)]\tTrain Loss: 0.199143\n",
      "Train Epoch: 9 [12800/60000 (21%)]\tTrain Loss: 0.064629\n",
      "Train Epoch: 9 [19200/60000 (32%)]\tTrain Loss: 0.038997\n",
      "Train Epoch: 9 [25600/60000 (43%)]\tTrain Loss: 0.132849\n",
      "Train Epoch: 9 [32000/60000 (53%)]\tTrain Loss: 0.466395\n",
      "Train Epoch: 9 [38400/60000 (64%)]\tTrain Loss: 0.095477\n",
      "Train Epoch: 9 [44800/60000 (75%)]\tTrain Loss: 0.124449\n",
      "Train Epoch: 9 [51200/60000 (85%)]\tTrain Loss: 0.069822\n",
      "Train Epoch: 9 [57600/60000 (96%)]\tTrain Loss: 0.073448\n",
      "\n",
      "[EPOCH: 9], \tTest Loss: 0.0021, \tTest Accuracy: 97.98 % \n",
      "\n",
      "Train Epoch: 10 [0/60000 (0%)]\tTrain Loss: 0.060481\n",
      "Train Epoch: 10 [6400/60000 (11%)]\tTrain Loss: 0.127830\n",
      "Train Epoch: 10 [12800/60000 (21%)]\tTrain Loss: 0.053453\n",
      "Train Epoch: 10 [19200/60000 (32%)]\tTrain Loss: 0.273952\n",
      "Train Epoch: 10 [25600/60000 (43%)]\tTrain Loss: 0.150731\n",
      "Train Epoch: 10 [32000/60000 (53%)]\tTrain Loss: 0.040127\n",
      "Train Epoch: 10 [38400/60000 (64%)]\tTrain Loss: 0.267848\n",
      "Train Epoch: 10 [44800/60000 (75%)]\tTrain Loss: 0.110777\n",
      "Train Epoch: 10 [51200/60000 (85%)]\tTrain Loss: 0.167811\n",
      "Train Epoch: 10 [57600/60000 (96%)]\tTrain Loss: 0.026505\n",
      "\n",
      "[EPOCH: 10], \tTest Loss: 0.0021, \tTest Accuracy: 97.92 % \n",
      "\n"
     ]
    }
   ],
   "source": [
    "''' 10. MLP 학습 실행하며 Train, Test set의 Loss 및 Test set Accuracy 확인하기 '''\n",
    "for epoch in range(1, EPOCHS + 1):\n",
    "    train(model, train_loader, optimizer, log_interval = 200)\n",
    "    test_loss, test_accuracy = evaluate(model, test_loader)\n",
    "    print(\"\\n[EPOCH: {}], \\tTest Loss: {:.4f}, \\tTest Accuracy: {:.2f} % \\n\".format(\n",
    "        epoch, test_loss, test_accuracy))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}