3-1_MNIST_MLP_Dropout.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",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28 * 28)\n",
    "        x = self.fc1(x)\n",
    "        x = F.sigmoid(x)\n",
    "        x = F.dropout(x, training = self.training, p = self.dropout_prob)\n",
    "        x = self.fc2(x)\n",
    "        x = F.sigmoid(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",
      ")\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": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\justin\\101\\lib\\site-packages\\torch\\nn\\functional.py:1625: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1 [0/60000 (0%)]\tTrain Loss: 2.465242\n",
      "Train Epoch: 1 [6400/60000 (11%)]\tTrain Loss: 2.306811\n",
      "Train Epoch: 1 [12800/60000 (21%)]\tTrain Loss: 2.269554\n",
      "Train Epoch: 1 [19200/60000 (32%)]\tTrain Loss: 2.332778\n",
      "Train Epoch: 1 [25600/60000 (43%)]\tTrain Loss: 2.253882\n",
      "Train Epoch: 1 [32000/60000 (53%)]\tTrain Loss: 2.392977\n",
      "Train Epoch: 1 [38400/60000 (64%)]\tTrain Loss: 2.271408\n",
      "Train Epoch: 1 [44800/60000 (75%)]\tTrain Loss: 2.266852\n",
      "Train Epoch: 1 [51200/60000 (85%)]\tTrain Loss: 2.284899\n",
      "Train Epoch: 1 [57600/60000 (96%)]\tTrain Loss: 2.321651\n",
      "\n",
      "[EPOCH: 1], \tTest Loss: 0.0714, \tTest Accuracy: 18.03 % \n",
      "\n",
      "Train Epoch: 2 [0/60000 (0%)]\tTrain Loss: 2.262630\n",
      "Train Epoch: 2 [6400/60000 (11%)]\tTrain Loss: 2.257258\n",
      "Train Epoch: 2 [12800/60000 (21%)]\tTrain Loss: 2.291954\n",
      "Train Epoch: 2 [19200/60000 (32%)]\tTrain Loss: 2.280940\n",
      "Train Epoch: 2 [25600/60000 (43%)]\tTrain Loss: 2.270547\n",
      "Train Epoch: 2 [32000/60000 (53%)]\tTrain Loss: 2.244217\n",
      "Train Epoch: 2 [38400/60000 (64%)]\tTrain Loss: 2.277828\n",
      "Train Epoch: 2 [44800/60000 (75%)]\tTrain Loss: 2.204417\n",
      "Train Epoch: 2 [51200/60000 (85%)]\tTrain Loss: 2.264808\n",
      "Train Epoch: 2 [57600/60000 (96%)]\tTrain Loss: 2.091909\n",
      "\n",
      "[EPOCH: 2], \tTest Loss: 0.0646, \tTest Accuracy: 39.75 % \n",
      "\n",
      "Train Epoch: 3 [0/60000 (0%)]\tTrain Loss: 2.206783\n",
      "Train Epoch: 3 [6400/60000 (11%)]\tTrain Loss: 2.064043\n",
      "Train Epoch: 3 [12800/60000 (21%)]\tTrain Loss: 1.923739\n",
      "Train Epoch: 3 [19200/60000 (32%)]\tTrain Loss: 1.672903\n",
      "Train Epoch: 3 [25600/60000 (43%)]\tTrain Loss: 1.902599\n",
      "Train Epoch: 3 [32000/60000 (53%)]\tTrain Loss: 1.836077\n",
      "Train Epoch: 3 [38400/60000 (64%)]\tTrain Loss: 1.688588\n",
      "Train Epoch: 3 [44800/60000 (75%)]\tTrain Loss: 1.541492\n",
      "Train Epoch: 3 [51200/60000 (85%)]\tTrain Loss: 1.430701\n",
      "Train Epoch: 3 [57600/60000 (96%)]\tTrain Loss: 1.311218\n",
      "\n",
      "[EPOCH: 3], \tTest Loss: 0.0386, \tTest Accuracy: 61.52 % \n",
      "\n",
      "Train Epoch: 4 [0/60000 (0%)]\tTrain Loss: 1.305975\n",
      "Train Epoch: 4 [6400/60000 (11%)]\tTrain Loss: 1.575562\n",
      "Train Epoch: 4 [12800/60000 (21%)]\tTrain Loss: 1.077880\n",
      "Train Epoch: 4 [19200/60000 (32%)]\tTrain Loss: 1.361190\n",
      "Train Epoch: 4 [25600/60000 (43%)]\tTrain Loss: 1.040486\n",
      "Train Epoch: 4 [32000/60000 (53%)]\tTrain Loss: 1.046731\n",
      "Train Epoch: 4 [38400/60000 (64%)]\tTrain Loss: 0.939643\n",
      "Train Epoch: 4 [44800/60000 (75%)]\tTrain Loss: 1.149699\n",
      "Train Epoch: 4 [51200/60000 (85%)]\tTrain Loss: 1.164859\n",
      "Train Epoch: 4 [57600/60000 (96%)]\tTrain Loss: 0.875005\n",
      "\n",
      "[EPOCH: 4], \tTest Loss: 0.0277, \tTest Accuracy: 71.57 % \n",
      "\n",
      "Train Epoch: 5 [0/60000 (0%)]\tTrain Loss: 1.081894\n",
      "Train Epoch: 5 [6400/60000 (11%)]\tTrain Loss: 1.370590\n",
      "Train Epoch: 5 [12800/60000 (21%)]\tTrain Loss: 1.087004\n",
      "Train Epoch: 5 [19200/60000 (32%)]\tTrain Loss: 1.052157\n",
      "Train Epoch: 5 [25600/60000 (43%)]\tTrain Loss: 1.223841\n",
      "Train Epoch: 5 [32000/60000 (53%)]\tTrain Loss: 0.740738\n",
      "Train Epoch: 5 [38400/60000 (64%)]\tTrain Loss: 0.943647\n",
      "Train Epoch: 5 [44800/60000 (75%)]\tTrain Loss: 0.790824\n",
      "Train Epoch: 5 [51200/60000 (85%)]\tTrain Loss: 0.729670\n",
      "Train Epoch: 5 [57600/60000 (96%)]\tTrain Loss: 0.912352\n",
      "\n",
      "[EPOCH: 5], \tTest Loss: 0.0237, \tTest Accuracy: 75.84 % \n",
      "\n",
      "Train Epoch: 6 [0/60000 (0%)]\tTrain Loss: 0.933268\n",
      "Train Epoch: 6 [6400/60000 (11%)]\tTrain Loss: 0.947774\n",
      "Train Epoch: 6 [12800/60000 (21%)]\tTrain Loss: 0.760683\n",
      "Train Epoch: 6 [19200/60000 (32%)]\tTrain Loss: 0.668853\n",
      "Train Epoch: 6 [25600/60000 (43%)]\tTrain Loss: 0.722454\n",
      "Train Epoch: 6 [32000/60000 (53%)]\tTrain Loss: 0.677378\n",
      "Train Epoch: 6 [38400/60000 (64%)]\tTrain Loss: 0.445301\n",
      "Train Epoch: 6 [44800/60000 (75%)]\tTrain Loss: 0.844144\n",
      "Train Epoch: 6 [51200/60000 (85%)]\tTrain Loss: 0.728118\n",
      "Train Epoch: 6 [57600/60000 (96%)]\tTrain Loss: 0.880896\n",
      "\n",
      "[EPOCH: 6], \tTest Loss: 0.0206, \tTest Accuracy: 80.45 % \n",
      "\n",
      "Train Epoch: 7 [0/60000 (0%)]\tTrain Loss: 0.751742\n",
      "Train Epoch: 7 [6400/60000 (11%)]\tTrain Loss: 0.687919\n",
      "Train Epoch: 7 [12800/60000 (21%)]\tTrain Loss: 0.826463\n",
      "Train Epoch: 7 [19200/60000 (32%)]\tTrain Loss: 0.584632\n",
      "Train Epoch: 7 [25600/60000 (43%)]\tTrain Loss: 0.752852\n",
      "Train Epoch: 7 [32000/60000 (53%)]\tTrain Loss: 0.558399\n",
      "Train Epoch: 7 [38400/60000 (64%)]\tTrain Loss: 0.810356\n",
      "Train Epoch: 7 [44800/60000 (75%)]\tTrain Loss: 0.726763\n",
      "Train Epoch: 7 [51200/60000 (85%)]\tTrain Loss: 0.547987\n",
      "Train Epoch: 7 [57600/60000 (96%)]\tTrain Loss: 0.431549\n",
      "\n",
      "[EPOCH: 7], \tTest Loss: 0.0181, \tTest Accuracy: 82.70 % \n",
      "\n",
      "Train Epoch: 8 [0/60000 (0%)]\tTrain Loss: 0.775636\n",
      "Train Epoch: 8 [6400/60000 (11%)]\tTrain Loss: 0.660315\n",
      "Train Epoch: 8 [12800/60000 (21%)]\tTrain Loss: 0.631106\n",
      "Train Epoch: 8 [19200/60000 (32%)]\tTrain Loss: 0.603776\n",
      "Train Epoch: 8 [25600/60000 (43%)]\tTrain Loss: 0.543177\n",
      "Train Epoch: 8 [32000/60000 (53%)]\tTrain Loss: 0.548135\n",
      "Train Epoch: 8 [38400/60000 (64%)]\tTrain Loss: 0.623748\n",
      "Train Epoch: 8 [44800/60000 (75%)]\tTrain Loss: 0.553701\n",
      "Train Epoch: 8 [51200/60000 (85%)]\tTrain Loss: 0.534373\n",
      "Train Epoch: 8 [57600/60000 (96%)]\tTrain Loss: 0.813260\n",
      "\n",
      "[EPOCH: 8], \tTest Loss: 0.0161, \tTest Accuracy: 84.64 % \n",
      "\n",
      "Train Epoch: 9 [0/60000 (0%)]\tTrain Loss: 0.589929\n",
      "Train Epoch: 9 [6400/60000 (11%)]\tTrain Loss: 0.443540\n",
      "Train Epoch: 9 [12800/60000 (21%)]\tTrain Loss: 0.651524\n",
      "Train Epoch: 9 [19200/60000 (32%)]\tTrain Loss: 0.367655\n",
      "Train Epoch: 9 [25600/60000 (43%)]\tTrain Loss: 0.863036\n",
      "Train Epoch: 9 [32000/60000 (53%)]\tTrain Loss: 0.724021\n",
      "Train Epoch: 9 [38400/60000 (64%)]\tTrain Loss: 0.875995\n",
      "Train Epoch: 9 [44800/60000 (75%)]\tTrain Loss: 0.445317\n",
      "Train Epoch: 9 [51200/60000 (85%)]\tTrain Loss: 0.467477\n",
      "Train Epoch: 9 [57600/60000 (96%)]\tTrain Loss: 0.581248\n",
      "\n",
      "[EPOCH: 9], \tTest Loss: 0.0148, \tTest Accuracy: 85.65 % \n",
      "\n",
      "Train Epoch: 10 [0/60000 (0%)]\tTrain Loss: 1.041706\n",
      "Train Epoch: 10 [6400/60000 (11%)]\tTrain Loss: 0.749753\n",
      "Train Epoch: 10 [12800/60000 (21%)]\tTrain Loss: 0.646062\n",
      "Train Epoch: 10 [19200/60000 (32%)]\tTrain Loss: 0.527050\n",
      "Train Epoch: 10 [25600/60000 (43%)]\tTrain Loss: 0.660469\n",
      "Train Epoch: 10 [32000/60000 (53%)]\tTrain Loss: 0.509758\n",
      "Train Epoch: 10 [38400/60000 (64%)]\tTrain Loss: 0.559824\n",
      "Train Epoch: 10 [44800/60000 (75%)]\tTrain Loss: 0.527527\n",
      "Train Epoch: 10 [51200/60000 (85%)]\tTrain Loss: 0.475507\n",
      "Train Epoch: 10 [57600/60000 (96%)]\tTrain Loss: 0.651053\n",
      "\n",
      "[EPOCH: 10], \tTest Loss: 0.0139, \tTest Accuracy: 86.52 % \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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}