Assignment 3: Deep Learning A05442-001 @ PKNU

20210622-assignment-pknu-dl-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e275dec6",
   "metadata": {},
   "source": [
    "# Assignment 3\n",
    "## Deep Learning A05442-001\n",
    "\n",
    " * Date: 2021-06-22\n",
    " * Author: Jongmin Kim <jmkim@pukyong.ac.kr> 201955277\n",
    " \n",
    "## 목차\n",
    " 1. Code preparation\n",
    " 2. CNN\n",
    "     - 모델 설명\n",
    "         - 모델 레이어 구성의 자세한 설명\n",
    "     - 결과 분석\n",
    " 3. RNN\n",
    "     - 모델 설명\n",
    "     - 결과 분석\n",
    " - CNN, FNN 비교 분석"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c16c02b",
   "metadata": {},
   "source": [
    "## 1. Code preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "45d21856",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a644115d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID:      0\n",
      "Name:    GeForce RTX 2080 Ti\n",
      "Memory:\n",
      "    Allocated:   0.0 GB\n",
      "    Cached:      0.0 GB\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(201955277)\n",
    "if device.type == \"cuda\":\n",
    "    torch.cuda.manual_seed(201955277)\n",
    "    print(\"ID:     \", torch.cuda.current_device())\n",
    "    print(\"Name:   \", torch.cuda.get_device_name(torch.cuda.current_device()))\n",
    "    print(\"Memory:\")\n",
    "    print(\"    Allocated:  \", round(torch.cuda.memory_allocated(torch.cuda.current_device())/1024**3,1), 'GB')\n",
    "    print(\"    Cached:     \", round(torch.cuda.memory_reserved(torch.cuda.current_device())/1024**3,1), 'GB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7aae0a4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_root = \"./data\"\n",
    "output_root = \"./output_jmkim\"\n",
    "batch_size = 4096\n",
    "num_workers = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fb76c766",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform_train = transforms.Compose([\n",
    "    transforms.RandomRotation(15),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0.5], [0.5])\n",
    "])\n",
    "\n",
    "transform_valid = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0.5], [0.5])\n",
    "])\n",
    "\n",
    "trainset = torchvision.datasets.FashionMNIST(root=dataset_root, train=True, download=True, transform=transform_train)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)\n",
    "\n",
    "validset = torchvision.datasets.FashionMNIST(root=dataset_root, train=False, download=True, transform=transform_valid)\n",
    "validloader = torch.utils.data.DataLoader(validset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\n",
    "\n",
    "classes = ('T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3b0edb00",
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(inp):\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    mean = 0.5\n",
    "    std = 0.5\n",
    "    inp = std * inp + mean\n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    plt.imshow(inp)\n",
    "    plt.show()\n",
    "    \n",
    "    xb, tb = next(iter(trainloader))\n",
    "    \n",
    "    print(xb[0].shape)\n",
    "    \n",
    "    imshow(torchvision.util.make_grid(xb[0:8]))\n",
    "    print(\" \".join(\"%5s\" % classes[tb[j]] for j in range(8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b0d4732c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, loss_fn, optimizer, n_epochs, file_name):\n",
    "    best_valid_acc = 0.0\n",
    "    best_epoch = 0\n",
    "\n",
    "    train_loss, train_acc = np.zeros((n_epochs,)), np.zeros((n_epochs, ))\n",
    "    valid_loss, valid_acc = np.zeros((n_epochs,)), np.zeros((n_epochs))\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        model.train()\n",
    "        for xb, tb in trainloader:\n",
    "            xb, tb = xb.to(device), tb.to(device)\n",
    "            y = model(xb)\n",
    "            _, pred = torch.max(y, 1)\n",
    "            loss = loss_fn(y, tb)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            train_loss[epoch] += loss.item()/len(trainloader)\n",
    "            train_acc[epoch] += torch.sum(pred == tb).item()/pred.shape[0]/len(trainloader)\n",
    " \n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            for xb, tb in validloader:\n",
    "                xb, tb = xb.to(device), tb.to(device)\n",
    "                y = model(xb)\n",
    "                _, pred = torch.max(y, 1)\n",
    "                valid_loss[epoch] += loss_fn(y, tb).item()/len(validloader)\n",
    "                valid_acc[epoch] += torch.sum(pred == tb).item()/pred.shape[0]/len(validloader)\n",
    "\n",
    "            if valid_acc[epoch] > best_valid_acc:\n",
    "                best_valid_acc = valid_acc[epoch]\n",
    "                best_epoch = epoch\n",
    "                torch.save(model, os.path.join(output_root, file_name))\n",
    "\n",
    "        print('Epoch: %d, Train loss/acc: %3f/%3f, Valid loss/acc: %3f/%3f'\n",
    "                % (epoch, train_loss[epoch], train_acc[epoch], valid_loss[epoch], valid_acc[epoch]))\n",
    "\n",
    "    plt.plot(train_loss, 'ro-', label='Train loss') \n",
    "    plt.plot(valid_loss, 'b*-', label='Valid loss') \n",
    "    plt.plot(best_epoch, train_loss[best_epoch], 'ks', linewidth=5, markersize=10)  \n",
    "    plt.plot(best_epoch, valid_loss[best_epoch], 'ks', linewidth=5, markersize=10)\n",
    "    plt.xlabel('Epochs') \n",
    "    plt.ylabel('Cross entropy') \n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(train_acc, 'ro-', label='Train Acc.')\n",
    "    plt.plot(valid_acc, 'b*-', label='Valid Acc.')\n",
    "    plt.plot(best_epoch, train_acc[best_epoch], 'ks', linewidth=5, markersize=10) \n",
    "    plt.plot(best_epoch, valid_acc[best_epoch], 'ks', linewidth=5, markersize=10)\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edb1c374",
   "metadata": {},
   "source": [
    "## 2. CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aaab3f52",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Sequential(\n",
    "            # input size: 28 * 28\n",
    "            nn.Conv2d(1, 32, 3, padding=1),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2, 2)\n",
    "            # output size: 14 * 14\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Sequential(\n",
    "            # input size: 14 * 14\n",
    "            nn.Conv2d(32, 64, 3, padding=1),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2, 2)\n",
    "            # output size: 7 * 7\n",
    "        )\n",
    "\n",
    "        self.linear1 = nn.Sequential(\n",
    "            nn.Linear(7*7*64, 256),\n",
    "            nn.BatchNorm1d(256),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear2 = nn.Linear(256, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = x.view(-1, 7*7*64)\n",
    "        x = self.linear1(x)\n",
    "        x = self.linear2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e41c5acd",
   "metadata": {},
   "source": [
    "### 모델 설명\n",
    "Fashion MNIST 데이터셋의 각 이미지 크기는 일괄적으로, 28 * 28 크기의 greyscale 이미지입니다. 따라서 `nn.Conv2d`의 입력 채널 수는 `1`입니다. 데이터셋의 클래스는 10개로 이루어져 있으므로, 최종 출력의 개수는 10개입니다.\n",
    "\n",
    "저는 본 모델을 2개의 컨벌루션 레이어와, 2개의 풀링 레이어, 1개의 완전 연결(Fully connected) 레이어, 1개의 출력 레이어로 구성하였습니다. 차례로 (입력)컨벌루션 → 풀링 → 컨벌루션 → 풀링 → 완전연결(Flattening) → 출력 순서로 구성하였습니다. 출력 레이어를 제외한 모든 레이어의 활성 함수는 ReLU를 사용하였습니다.\n",
    "\n",
    "\n",
    "#### 모델 레이어 구성의 자세한 설명\n",
    "\n",
    "자세한 파라미터는 다음과 같이 구성하였습니다:\n",
    "\n",
    "   1. 컨벌루션 레이어 (이미지 입력 레이어)\n",
    "       - 입력 텐서 크기: 28 * 28 * 1 * 1\n",
    "           - 이미지 크기: 28 * 28\n",
    "           - 레이어(이미지) 개수: 1\n",
    "           - 채널 수: 1\n",
    "       - 컨벌루션\n",
    "           - 커널 크기: 3\n",
    "           - Stride 크기: 1\n",
    "           - Padding 크기: 1\n",
    "       - 출력 텐서 크기: 28 * 28 * 32 * 1\n",
    "           - 이미지 크기: 28 * 28\n",
    "           - 레이어 개수: 32\n",
    "           - 채널 수: 1\n",
    "   2. 풀링 레이어\n",
    "       - 입력 텐서 크기: 28 * 28 * 32 * 1\n",
    "           - 이미지 크기: 28 * 28\n",
    "           - 레이어 개수: 32\n",
    "           - 채널 수: 1\n",
    "       - 풀링\n",
    "           - 기법: Max Pool\n",
    "           - 풀링 크기: 2\n",
    "           - Stride 크기: 2\n",
    "       - 출력 텐서 크기: 14 * 14 * 32 * 1\n",
    "           - 이미지 크기: 14 * 14\n",
    "           - 레이어 개수: 32\n",
    "           - 채널 수: 1\n",
    "   3. 컨벌루션 레이어\n",
    "       - 입력 텐서 크기: 14 * 14 * 32 * 1\n",
    "           - 이미지 크기: 14 * 14\n",
    "           - 레이어 개수: 32\n",
    "           - 채널 수: 1\n",
    "       - 컨벌루션\n",
    "           - 커널 크기: 3\n",
    "           - Stride 크기: 1\n",
    "           - Padding 크기: 1\n",
    "       - 출력 텐서 크기: 14 * 14 * 64 * 1\n",
    "           - 이미지 크기: 14 * 14\n",
    "           - 레이어 개수: 64\n",
    "           - 채널 수: 1\n",
    "   4. 풀링 레이어\n",
    "       - 입력 텐서 크기: 14 * 14 * 64 * 1\n",
    "           - 이미지 크기: 14 * 14\n",
    "           - 레이어 개수: 64\n",
    "           - 채널 수: 1\n",
    "       - 풀링\n",
    "           - 기법: Max Pool\n",
    "           - 풀링 크기: 2\n",
    "           - Stride 크기: 2\n",
    "       - 출력 텐서 크기: 7 * 7 * 64 * 1\n",
    "           - 이미지 크기: 7 * 7\n",
    "           - 레이어 개수: 64\n",
    "           - 채널 수: 1\n",
    "   5. 완전 연결 레이어\n",
    "       - 입력 텐서 크기: 7 * 7 * 64 * 1\n",
    "           - 이미지 크기: 7 * 7\n",
    "           - 레이어 개수: 64\n",
    "           - 채널 수: 1\n",
    "       - 출력 텐서 크기: 256\n",
    "   6. 출력 레이어\n",
    "       - 입력 텐서 크기: 256\n",
    "       - 출력 텐서 크기: 10\n",
    "           - 레이어(Fashion MNIST 카테고리) 개수: 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "84201001",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CNN(\n",
       "  (conv1): Sequential(\n",
       "    (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (conv2): Sequential(\n",
       "    (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (linear1): Sequential(\n",
       "    (0): Linear(in_features=3136, out_features=256, bias=True)\n",
       "    (1): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear2): Linear(in_features=256, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cnn = CNN()\n",
    "cnn.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4118e556",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss/acc: 0.899103/0.709642, Valid loss/acc: 1.001191/0.759633\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/idblab/anaconda3/envs/jupyter/lib/python3.7/site-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type CNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Train loss/acc: 0.511695/0.828435, Valid loss/acc: 0.587723/0.820490\n",
      "Epoch: 2, Train loss/acc: 0.409647/0.857232, Valid loss/acc: 0.426924/0.853563\n",
      "Epoch: 3, Train loss/acc: 0.355436/0.874923, Valid loss/acc: 0.352013/0.876292\n",
      "Epoch: 4, Train loss/acc: 0.323561/0.885531, Valid loss/acc: 0.323052/0.882725\n",
      "Epoch: 5, Train loss/acc: 0.300779/0.893810, Valid loss/acc: 0.311838/0.887103\n",
      "Epoch: 6, Train loss/acc: 0.285152/0.898426, Valid loss/acc: 0.299657/0.895005\n",
      "Epoch: 7, Train loss/acc: 0.272691/0.903325, Valid loss/acc: 0.292194/0.890037\n",
      "Epoch: 8, Train loss/acc: 0.260531/0.907817, Valid loss/acc: 0.276123/0.901428\n",
      "Epoch: 9, Train loss/acc: 0.256170/0.907343, Valid loss/acc: 0.279262/0.899898\n",
      "Epoch: 10, Train loss/acc: 0.246141/0.911466, Valid loss/acc: 0.264001/0.902627\n",
      "Epoch: 11, Train loss/acc: 0.237494/0.915266, Valid loss/acc: 0.265648/0.901109\n",
      "Epoch: 12, Train loss/acc: 0.226930/0.918256, Valid loss/acc: 0.257190/0.906836\n",
      "Epoch: 13, Train loss/acc: 0.223539/0.920206, Valid loss/acc: 0.242488/0.913605\n",
      "Epoch: 14, Train loss/acc: 0.217071/0.921844, Valid loss/acc: 0.242902/0.909787\n",
      "Epoch: 15, Train loss/acc: 0.210581/0.924736, Valid loss/acc: 0.238212/0.916019\n",
      "Epoch: 16, Train loss/acc: 0.206077/0.925983, Valid loss/acc: 0.241575/0.913442\n",
      "Epoch: 17, Train loss/acc: 0.201502/0.928217, Valid loss/acc: 0.239454/0.914484\n",
      "Epoch: 18, Train loss/acc: 0.200647/0.927846, Valid loss/acc: 0.271321/0.906201\n",
      "Epoch: 19, Train loss/acc: 0.198829/0.928007, Valid loss/acc: 0.235554/0.916307\n",
      "Epoch: 20, Train loss/acc: 0.190927/0.930164, Valid loss/acc: 0.246428/0.912092\n",
      "Epoch: 21, Train loss/acc: 0.188382/0.932401, Valid loss/acc: 0.232253/0.918367\n",
      "Epoch: 22, Train loss/acc: 0.186197/0.933339, Valid loss/acc: 0.226165/0.919642\n",
      "Epoch: 23, Train loss/acc: 0.181591/0.934056, Valid loss/acc: 0.227763/0.918845\n",
      "Epoch: 24, Train loss/acc: 0.176405/0.936520, Valid loss/acc: 0.235328/0.917322\n",
      "Epoch: 25, Train loss/acc: 0.176017/0.936595, Valid loss/acc: 0.235674/0.918412\n",
      "Epoch: 26, Train loss/acc: 0.172676/0.938497, Valid loss/acc: 0.228330/0.918438\n",
      "Epoch: 27, Train loss/acc: 0.168088/0.939740, Valid loss/acc: 0.272960/0.908040\n",
      "Epoch: 28, Train loss/acc: 0.164810/0.940544, Valid loss/acc: 0.221023/0.924291\n",
      "Epoch: 29, Train loss/acc: 0.165133/0.941229, Valid loss/acc: 0.228195/0.916822\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(cnn.parameters(), lr=0.001)\n",
    "\n",
    "train(cnn, loss_fn, optimizer, 30, \"best_cnn.pth\")\n",
    "\n",
    "del(cnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8791b2ec",
   "metadata": {},
   "source": [
    "### 결과 분석\n",
    "\n",
    "학습률(Learning rate)은 0.001로 설정하였으며, 에폭(Epoch)은 30번 수행하였습니다.\n",
    "\n",
    "수행 결과, Train loss와 Valid loss가 꾸준히 함께 감소하는 모습을 보였습니다. Valid loss는 Train loss에 미치지는 않지만 근사하게 줄어드는 모습을 보였습니다. 에폭이 지날수록 잘 훈련되는 모습을 보였습니다.\n",
    "\n",
    "Train loss를 살펴보면, 에폭 28에서 loss가 상승하고 accuracy가 감소한 모습을 보였습니다. 이 즈음의 Train accuracy는 94% 정도의 accuracy에 수렴하는 모습을 보였습니다.\n",
    "한편, Valid loss는 몇 번 loss가 상승하거나 accuracy가 감소하는 모습을 보였지만, 대체로 loss 하향(accuracy 상향) 수렴하는 모습을 보였습니다. 92% 정도에 수렴한 정확도(accuracy)를 보였으며, 잘 훈련된 모델이라 볼 수 있다고 생각합니다.\n",
    "\n",
    "이외에 연산의 빠른 수행을 위해 Batch size를 4096으로 조정하거나 Reproducible하도록 random seed를 학번(201955277)으로 고정하는 등 모델의 성능 향상에 영향을 끼치지 않는 파라미터를 몇몇 조정한 바 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a9c736",
   "metadata": {},
   "source": [
    "## 3. Run FNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b5d61f03",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.linear1 = nn.Sequential(\n",
    "            nn.Linear(28*28, 4096),\n",
    "            nn.BatchNorm1d(4096),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear2 = nn.Sequential(\n",
    "            nn.Linear(4096, 2048),\n",
    "            nn.BatchNorm1d(2048),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear3 = nn.Sequential(\n",
    "            nn.Linear(2048, 1024),\n",
    "            nn.BatchNorm1d(1024),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear4 = nn.Sequential(\n",
    "            nn.Linear(1024, 512),\n",
    "            nn.BatchNorm1d(512),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear5 = nn.Sequential(\n",
    "            nn.Linear(512, 256),\n",
    "            nn.BatchNorm1d(256),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "        self.linear6 = nn.Linear(256, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28*28)\n",
    "        x = self.linear1(x)\n",
    "        x = self.linear2(x)\n",
    "        x = self.linear3(x)\n",
    "        x = self.linear4(x)\n",
    "        x = self.linear5(x)\n",
    "        x = self.linear6(x)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e11a665",
   "metadata": {},
   "source": [
    "### 모델 설명\n",
    "\n",
    "Fashion MNIST 데이터셋의 각 이미지 크기는 일괄적으로, 28 * 28 크기를 가지고 있습니다.\n",
    "\n",
    "저는 본 모델을 5개의 완전 연결(Fully connected) 레이어와, 1개의 출력 레이어로 구성하였습니다.\n",
    "\n",
    "임의의 표기법 `(x) → (y)` 에서, `→`를 완전 연결 레이어, `(x)`의 문자 `x`를 입력 개수, `(y)`의 문자 `y`를 출력의 개수라 할 때, 차례로:\n",
    "\n",
    "```\n",
    "(28 * 28) → (4096) → (2048) → (1024) → (512) → (256)\n",
    "```\n",
    "\n",
    "순서로 5개의 완전 연결 레이어를 구성하였으며, 이와 이어지도록 출력 레이어를 구성하였습니다. 출력 레이어를 제외한 모든 레이어의 활성 함수는 ReLU를 사용하였습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9c379c38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FNN(\n",
       "  (linear1): Sequential(\n",
       "    (0): Linear(in_features=784, out_features=4096, bias=True)\n",
       "    (1): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear2): Sequential(\n",
       "    (0): Linear(in_features=4096, out_features=2048, bias=True)\n",
       "    (1): BatchNorm1d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear3): Sequential(\n",
       "    (0): Linear(in_features=2048, out_features=1024, bias=True)\n",
       "    (1): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear4): Sequential(\n",
       "    (0): Linear(in_features=1024, out_features=512, bias=True)\n",
       "    (1): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear5): Sequential(\n",
       "    (0): Linear(in_features=512, out_features=256, bias=True)\n",
       "    (1): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  )\n",
       "  (linear6): Linear(in_features=256, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fnn = FNN()\n",
    "fnn.to(device)          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7f28b659",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/idblab/anaconda3/envs/jupyter/lib/python3.7/site-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type FNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss/acc: 0.803998/0.726864, Valid loss/acc: 0.810076/0.722377\n",
      "Epoch: 1, Train loss/acc: 0.464235/0.834057, Valid loss/acc: 0.636247/0.780691\n",
      "Epoch: 2, Train loss/acc: 0.410156/0.850685, Valid loss/acc: 0.560476/0.805647\n",
      "Epoch: 3, Train loss/acc: 0.378311/0.862722, Valid loss/acc: 0.418152/0.845159\n",
      "Epoch: 4, Train loss/acc: 0.359343/0.866854, Valid loss/acc: 0.451178/0.837739\n",
      "Epoch: 5, Train loss/acc: 0.336994/0.875836, Valid loss/acc: 0.387398/0.858119\n",
      "Epoch: 6, Train loss/acc: 0.328688/0.877760, Valid loss/acc: 0.410624/0.848019\n",
      "Epoch: 7, Train loss/acc: 0.313705/0.881822, Valid loss/acc: 0.390327/0.857191\n",
      "Epoch: 8, Train loss/acc: 0.307144/0.885795, Valid loss/acc: 0.396981/0.853937\n",
      "Epoch: 9, Train loss/acc: 0.296322/0.888926, Valid loss/acc: 0.417271/0.844058\n",
      "Epoch: 10, Train loss/acc: 0.290890/0.891831, Valid loss/acc: 0.424834/0.843358\n",
      "Epoch: 11, Train loss/acc: 0.283157/0.894270, Valid loss/acc: 0.333803/0.878541\n",
      "Epoch: 12, Train loss/acc: 0.272464/0.897872, Valid loss/acc: 0.324606/0.881313\n",
      "Epoch: 13, Train loss/acc: 0.268604/0.899767, Valid loss/acc: 0.352171/0.869888\n",
      "Epoch: 14, Train loss/acc: 0.264922/0.900938, Valid loss/acc: 0.331090/0.880429\n",
      "Epoch: 15, Train loss/acc: 0.259172/0.902385, Valid loss/acc: 0.360817/0.871311\n",
      "Epoch: 16, Train loss/acc: 0.257291/0.904428, Valid loss/acc: 0.341761/0.875188\n",
      "Epoch: 17, Train loss/acc: 0.253238/0.904457, Valid loss/acc: 0.345044/0.877462\n",
      "Epoch: 18, Train loss/acc: 0.248496/0.906692, Valid loss/acc: 0.327107/0.878068\n",
      "Epoch: 19, Train loss/acc: 0.237097/0.909787, Valid loss/acc: 0.339478/0.881134\n",
      "Epoch: 20, Train loss/acc: 0.236125/0.912511, Valid loss/acc: 0.347306/0.879392\n",
      "Epoch: 21, Train loss/acc: 0.232623/0.911108, Valid loss/acc: 0.323449/0.882653\n",
      "Epoch: 22, Train loss/acc: 0.225367/0.915233, Valid loss/acc: 0.328902/0.881861\n",
      "Epoch: 23, Train loss/acc: 0.221245/0.915654, Valid loss/acc: 0.316807/0.886043\n",
      "Epoch: 24, Train loss/acc: 0.218323/0.916960, Valid loss/acc: 0.319766/0.886965\n",
      "Epoch: 25, Train loss/acc: 0.212960/0.919120, Valid loss/acc: 0.334582/0.885512\n",
      "Epoch: 26, Train loss/acc: 0.212961/0.919279, Valid loss/acc: 0.335623/0.884437\n",
      "Epoch: 27, Train loss/acc: 0.204531/0.921409, Valid loss/acc: 0.320582/0.887118\n",
      "Epoch: 28, Train loss/acc: 0.202206/0.924083, Valid loss/acc: 0.341422/0.882859\n",
      "Epoch: 29, Train loss/acc: 0.201795/0.923449, Valid loss/acc: 0.338368/0.882990\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(fnn.parameters(), lr=0.001)\n",
    "\n",
    "train(fnn, loss_fn, optimizer, 30, \"best_fnn.pth\")\n",
    "\n",
    "del(fnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f047c348",
   "metadata": {},
   "source": [
    "### 결과 분석\n",
    "\n",
    "학습률(Learning rate)은 0.001로 설정하였으며, 에폭(Epoch)은 30번 수행하였습니다.\n",
    "\n",
    "수행 결과, Train loss는 지속적으로 감소하는 모습을 보였으나, Valid loss는 수렴하는 모습을 보였습니다. 에폭 초반에는 잘 훈련되는 모습처럼 보였으나, 에폭 5 이후로는 Valid loss와 accuracy가 수렴하며 진동하는 모습을 보였습니다. 하지만 대체로 감소하는 모습이므로, 이 모델의 경우 이 이상 훈련할 가치가 없다고 해석할 수 있다고 생각합니다.\n",
    "\n",
    "Train loss를 살펴보면, 에폭 5까지는 급격한 loss의 상승과 accuracy의 감소를 보였으며, 이후 완만한 감소세를 보였습니다. 에폭이 지날 수록 Train accuracy는 1에 가깝게 올라가는 추세를 보였으며, 마지막 에폭(29) 기준으로 92%를 보였습니다.\n",
    "Valid loss는, 에폭 5까지는 급격한 loss의 상승과 accuracy의 감소를 보였으나, 이후 수렴 진동하는 모습을 보였습니다. 진동하는 동안의 Valid accuracy는 88% 정도를 보였습니다. 따라서 에폭 5 이후로는 훈련이 잘 되지 않는 모습을 보였으나, 그럼에도 정확도가 88% 정도를 보이므로 비교적 잘 훈련된 모델이라 볼 수 있다고 생각합니다.\n",
    "\n",
    "이외에 연산의 빠른 수행을 위해 Batch size를 4096으로 조정하거나 Reproducible하도록 random seed를 학번(201955277)으로 고정하는 등 모델의 성능 향상에 영향을 끼치지 않는 파라미터를 몇몇 조정한 바 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cda6314",
   "metadata": {},
   "source": [
    "## CNN, FNN 비교 분석\n",
    "\n",
    "CNN의 경우 92%정도의 정확도를 보이도록 비교적 쉽게 훈련시킬 수 있었으나, FNN의 경우 88% 정도의 정확도를 넘어서도록 훈련하기가 힘들었습니다. 오랜 시간동안 다양한 구조로 FNN을 개선시키려 노력하였으나, 제가 수행한 실험에서 가장 높은 정확도를 보인 모델이 상기의 모델(88%의 정확도)입니다.\n",
    "\n",
    "CNN은 이미지라는 2차원적으로 연속적인 데이터에 대해 컨벌루션 연산으로 평면 상 일정 간격으로 모든 영역의 특징점을 모으거나(컨벌루션) 뭉개뜨려서 주요 특징점 이외에는 도태되도록 하는(풀링) 등 이미지의 특징을 살리는 연산을 할 수 있도록 만들어졌다고 생각합니다.\n",
    "\n",
    "반면, FNN은 2차원 이미지를 1차원에 나열하여, 평면 상의 두 축에 대해 한 축에 대한 연속성은 고려될 수 있겠으나 다른 축에 대한 연속성은 무시되는 문제가 있다고 생각합니다.\n",
    "\n",
    "이는 본 실험에서도 모델 훈련의 정확도(CNN: 92%, FNN: 88%)와 난이도(CNN: 비교적 쉬움, FNN: 시간을 투자하여 개선시키려 노력하였으나 추가 개선이 어려움)의 차이에서 볼 수 있습니다."
   ]
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}