04-Neural-Network-For-Fashion/03-overfitting-and-regularization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.3 오버피팅과 정규화 (Overfitting and Regularization)\n",
    "\n",
    "머신러닝 모델\n",
    "과적합(Overfitting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torchvision import transforms, datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42)\n",
    "USE_CUDA = torch.cuda.is_available()\n",
    "DEVICE = torch.device(\"cuda\" if USE_CUDA else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 50\n",
    "BATCH_SIZE = 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 데이터셋에 노이즈 추가하기\n",
    "\n",
    "![original.png](./assets/original.png)\n",
    "\n",
    "![horizontalflip.png](./assets/horizontalflip.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('./.data',\n",
    "                   train=True,\n",
    "                   download=True,\n",
    "                   transform=transforms.Compose([\n",
    "                       transforms.RandomHorizontalFlip(),\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])),\n",
    "    batch_size=BATCH_SIZE, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('./.data',\n",
    "                   train=False, \n",
    "                   transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])),\n",
    "    batch_size=BATCH_SIZE, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 뉴럴넷으로 Fashion MNIST 학습하기\n",
    "\n",
    "입력 `x` 는 `[배치크기, 색, 높이, 넓이]`로 이루어져 있습니다.\n",
    "`x.size()`를 해보면 `[64, 1, 28, 28]`이라고 표시되는 것을 보실 수 있습니다.\n",
    "Fashion MNIST에서 이미지의 크기는 28 x 28, 색은 흑백으로 1 가지 입니다.\n",
    "그러므로 입력 x의 총 특성값 갯수는 28 x 28 x 1, 즉 784개 입니다.\n",
    "\n",
    "우리가 사용할 모델은 3개의 레이어를 가진 뉴럴네트워크 입니다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, dropout_p=0.2):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(784, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 10)\n",
    "        self.dropout_p = dropout_p\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 784)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.dropout(x, training=self.training,\n",
    "                      p=self.dropout_p)\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.dropout(x, training=self.training,\n",
    "                      p=self.dropout_p)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 모델 준비하기 \n",
    "\n",
    "`to()` 함수는 모델의 파라미터들을 지정한 곳으로 보내는 역할을 합니다.\n",
    "일반적으로 CPU 1개만 사용할 경우 필요는 없지만,\n",
    "GPU를 사용하고자 하는 경우 `to(\"cuda\")`로 지정하여 GPU로 보내야 합니다.\n",
    "지정하지 않을 경우 계속 CPU에 남아 있게 되며 빠른 훈련의 이점을 누리실 수 없습니다.\n",
    "\n",
    "최적화 알고리즘으로 파이토치에 내장되어 있는 `optim.SGD`를 사용하겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model        = Net(dropout_p=0.2).to(DEVICE)\n",
    "optimizer    = optim.SGD(model.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 훈련하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, train_loader, optimizer):\n",
    "    model.train()\n",
    "    for data, target in enumerate(train_loader):\n",
    "        data, target = data.to(DEVICE), target.to(DEVICE)\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data)\n",
    "        loss = F.cross_entropy(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 테스트하기\n",
    "\n",
    "아무리 훈련이 잘 되었다고 해도 실제 데이터를 만났을때 성능이 낮다면 쓸모 없는 모델일 것입니다.\n",
    "우리가 진정 원하는 것은 훈련 데이터에 최적화한 모델이 아니라 모든 데이터에서 높은 성능을 보이는 모델이기 때문입니다.\n",
    "세상에 존재하는 모든 데이터에 최적화 하는 것을 \"일반화\"라고 부르고\n",
    "모델이 얼마나 실제 데이터에 적응하는지를 수치로 나타낸 것을 \"일반화 오류\"(Generalization Error) 라고 합니다. \n",
    "\n",
    "우리가 만든 모델이 얼마나 일반화를 잘 하는지 알아보기 위해,\n",
    "그리고 언제 훈련을 멈추어야 할지 알기 위해\n",
    "매 이포크가 끝날때 마다 테스트셋으로 모델의 성능을 측정해보겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, test_loader):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    with torch.no_grad():\n",
    "        for data, target in test_loader:\n",
    "            data, target = data.to(DEVICE), target.to(DEVICE)\n",
    "            output = model(data)\n",
    "            test_loss += F.cross_entropy(output, target,\n",
    "                                         size_average=False).item()\n",
    "            \n",
    "            # 맞춘 갯수 계산\n",
    "            pred = output.max(1, keepdim=True)[1]\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "    test_accuracy = 100. * correct / len(test_loader.dataset)\n",
    "    return test_loss, test_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 코드 돌려보기\n",
    "\n",
    "자, 이제 모든 준비가 끝났습니다. 코드를 돌려서 실제로 훈련이 되는지 확인해봅시다!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] Test Loss: 0.5499, Accuracy: 82.68%\n",
      "[2] Test Loss: 0.4284, Accuracy: 86.36%\n",
      "[3] Test Loss: 0.3552, Accuracy: 89.13%\n",
      "[4] Test Loss: 0.3043, Accuracy: 90.44%\n",
      "[5] Test Loss: 0.2602, Accuracy: 92.07%\n",
      "[6] Test Loss: 0.2321, Accuracy: 92.82%\n",
      "[7] Test Loss: 0.2132, Accuracy: 93.41%\n",
      "[8] Test Loss: 0.1986, Accuracy: 93.85%\n",
      "[9] Test Loss: 0.1824, Accuracy: 94.46%\n",
      "[10] Test Loss: 0.1756, Accuracy: 94.56%\n",
      "[11] Test Loss: 0.1665, Accuracy: 94.87%\n",
      "[12] Test Loss: 0.1555, Accuracy: 95.30%\n",
      "[13] Test Loss: 0.1524, Accuracy: 95.39%\n",
      "[14] Test Loss: 0.1451, Accuracy: 95.58%\n",
      "[15] Test Loss: 0.1399, Accuracy: 95.78%\n",
      "[16] Test Loss: 0.1370, Accuracy: 95.82%\n",
      "[17] Test Loss: 0.1339, Accuracy: 95.93%\n",
      "[18] Test Loss: 0.1289, Accuracy: 96.08%\n",
      "[19] Test Loss: 0.1239, Accuracy: 96.17%\n",
      "[20] Test Loss: 0.1194, Accuracy: 96.27%\n",
      "[21] Test Loss: 0.1153, Accuracy: 96.47%\n",
      "[22] Test Loss: 0.1183, Accuracy: 96.20%\n",
      "[23] Test Loss: 0.1140, Accuracy: 96.49%\n",
      "[24] Test Loss: 0.1101, Accuracy: 96.60%\n",
      "[25] Test Loss: 0.1088, Accuracy: 96.62%\n",
      "[26] Test Loss: 0.1064, Accuracy: 96.66%\n",
      "[27] Test Loss: 0.1028, Accuracy: 96.82%\n",
      "[28] Test Loss: 0.1022, Accuracy: 96.90%\n",
      "[29] Test Loss: 0.1018, Accuracy: 96.70%\n",
      "[30] Test Loss: 0.1002, Accuracy: 96.88%\n",
      "[31] Test Loss: 0.0984, Accuracy: 96.89%\n",
      "[32] Test Loss: 0.0966, Accuracy: 97.04%\n",
      "[33] Test Loss: 0.0979, Accuracy: 96.85%\n",
      "[34] Test Loss: 0.0954, Accuracy: 97.04%\n",
      "[35] Test Loss: 0.0963, Accuracy: 97.00%\n",
      "[36] Test Loss: 0.0944, Accuracy: 97.06%\n",
      "[37] Test Loss: 0.0925, Accuracy: 97.00%\n",
      "[38] Test Loss: 0.0933, Accuracy: 97.13%\n",
      "[39] Test Loss: 0.0918, Accuracy: 97.12%\n",
      "[40] Test Loss: 0.0898, Accuracy: 97.16%\n",
      "[41] Test Loss: 0.0888, Accuracy: 97.24%\n",
      "[42] Test Loss: 0.0884, Accuracy: 97.16%\n",
      "[43] Test Loss: 0.0889, Accuracy: 97.34%\n",
      "[44] Test Loss: 0.0876, Accuracy: 97.22%\n",
      "[45] Test Loss: 0.0860, Accuracy: 97.35%\n",
      "[46] Test Loss: 0.0852, Accuracy: 97.37%\n",
      "[47] Test Loss: 0.0860, Accuracy: 97.29%\n",
      "[48] Test Loss: 0.0866, Accuracy: 97.32%\n",
      "[49] Test Loss: 0.0851, Accuracy: 97.36%\n",
      "[50] Test Loss: 0.0837, Accuracy: 97.26%\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, EPOCHS + 1):\n",
    "    train(model, train_loader, optimizer)\n",
    "    test_loss, test_accuracy = test(model, test_loader)\n",
    "    \n",
    "    print('[{}] Test Loss: {:.4f}, Accuracy: {:.2f}%'.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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}