notebooks/7.4_GoogLeNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [7.4 Networks with Parallel Concatenations (GoogLeNet)](https://d2l.ai/chapter_convolutional-modern/googlenet.html)\n",
    "\n",
    "paper : [Going Deeper with Convolutions (Szegedy et al. 2015)](https://ieeexplore.ieee.org/document/7298594)\n",
    "\n",
    "## Inception block (v1)\n",
    "\n",
    "- What's the best convolution kernel size to use when designing a network? We've seen then use of an 11x11 Conv kernel in **AlexNet**, 3x3 Conv kernels in **VGG**, 5x5 in **LeNet**, and 1x1 in **NiN**. Different kernel sizes explore the image at different extents. \n",
    "\n",
    "\n",
    "- The motivation behind the **inception network block** : just employ **convolutions with various kernel sizes**, **concatenate all the outputs**. Let the network to use all the information to determine which extracted features are more useful.\n",
    "\n",
    "### Structure of the Inception block\n",
    "\n",
    "<img src='./images/fig_7.4.1.png' width='550'/>\n",
    "\n",
    "- The inception block consists of four parallel paths. It extracts information in parallel through convolutional layers of different window shapes and maximum pooling layers. \n",
    "\n",
    "- The middle two paths perform a **1x1 convolution** on the input to **reduce the number of channels**, reducing the model’s complexity. <br>\n",
    "  c.f. In §7.3 Network-in-Network the 1x1 convolution layers are introduced in order to enhance model complexity by allowing interactions of cross channel information. \n",
    "\n",
    "\n",
    "- The four paths all use **appropriate padding** to give the input and output the same height and width.\n",
    "\n",
    "\n",
    "- Finally, the outputs along each path are **concatenated along the channel dimension** and comprise the block’s output.\n",
    "\n",
    "### Versions of Inception block network\n",
    "\n",
    "#### Inception v2  : [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift -- Ioffe & Szegedy  2015](https://arxiv.org/abs/1502.03167)\n",
    "\n",
    "- Adopt Batch normalization -> can train with higher learning rate. \n",
    "- Replace the 5x5 filter in Inception v1 by two 3x3 Conv layers.\n",
    "\n",
    "#### Inception v3  : [Rethinking the Inception Architecture for Computer Vision -- Szegedy et al. 2015](https://arxiv.org/abs/1512.00567)\n",
    "\n",
    "- Replace the 3x3 Conv by 1x3 and 3x1 Conv layers to further reduce number of parameters.\n",
    "\n",
    "#### Inception v4  : [Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning -- Szegedy et al. 2016](https://arxiv.org/abs/1602.07261)\n",
    "\n",
    "- Add residual connections\n",
    "\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;   <sub> * Reference : [Review: Inception-v4 — Evolved From GoogLeNet, Merged with ResNet Idea (Image Classification)](https://towardsdatascience.com/review-inception-v4-evolved-from-googlenet-merged-with-resnet-idea-image-classification-5e8c339d18bc) </sub>\n",
    "\n",
    "## GoogLeNet (simplified version)\n",
    "\n",
    "- Earlier layers similar to AlexNet & LeNet.\n",
    "\n",
    "- A stack of a total of 9 inception blocks + global average pooling.\n",
    "\n",
    "- Maximum pooling between inception blocks reduces the dimensionality.\n",
    "\n",
    "- At the end, average pooling (avoids a stack of fully-connected layers) + 1 fully connected layer (to easily adapt the network to tasks with different number of classification labels).\n",
    "\n",
    "<img src='./images/fig_7.4.2.png' width='350'/>\n",
    "\n",
    "### GoogLeNet (original version)\n",
    "\n",
    "- GoogLeNet has 22 layers. Training a deep network back in 2015 can be difficult.\n",
    "\n",
    "- The original GoogLeNet model has some **side branches** (**auxiliary networks**) connected to the intermeidate layers to alliviate vanishing gradient problem and provide better regularization. \n",
    "\n",
    "- These side branches are ended with softmax activations in order to infer classification probabilities from intermediate features. During training, the loss from these side branches are added to the total loss of the network with some discount weights. This design helps the network to learn good intermediate features. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implement Inception block in pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "from torch.nn import functional as F\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rc('font', size=16)\n",
    "import time\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inception(nn.Module):\n",
    "    # `c1`--`c4` are the number of output channels for each path\n",
    "    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):\n",
    "        super(Inception, self).__init__(**kwargs)\n",
    "        # Path 1 is a single 1 x 1 convolutional layer\n",
    "        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)\n",
    "        # Path 2 is a 1 x 1 convolutional layer followed by a 3 x 3\n",
    "        # convolutional layer\n",
    "        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)\n",
    "        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)\n",
    "        # Path 3 is a 1 x 1 convolutional layer followed by a 5 x 5\n",
    "        # convolutional layer\n",
    "        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)\n",
    "        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)\n",
    "        # Path 4 is a 3 x 3 maximum pooling layer followed by a 1 x 1\n",
    "        # convolutional layer\n",
    "        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)\n",
    "        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        p1 = F.relu(self.p1_1(x))\n",
    "        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))\n",
    "        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))\n",
    "        p4 = F.relu(self.p4_2(self.p4_1(x)))\n",
    "        # Concatenate the outputs on the channel dimension\n",
    "        return torch.cat((p1, p2, p3, p4), dim=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GoogLeNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),\n",
    "                   nn.ReLU(),\n",
    "                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),\n",
    "                   nn.ReLU(),\n",
    "                   nn.Conv2d(64, 192, kernel_size=3, padding=1),\n",
    "                   nn.ReLU(),\n",
    "                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),\n",
    "                   Inception(256, 128, (128, 192), (32, 96), 64),\n",
    "                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),\n",
    "                   Inception(512, 160, (112, 224), (24, 64), 64),\n",
    "                   Inception(512, 128, (128, 256), (24, 64), 64),\n",
    "                   Inception(512, 112, (144, 288), (32, 64), 64),\n",
    "                   Inception(528, 256, (160, 320), (32, 128), 128),\n",
    "                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),\n",
    "                   Inception(832, 384, (192, 384), (48, 128), 128),\n",
    "                   nn.AdaptiveAvgPool2d((1,1)),\n",
    "                   nn.Flatten())\n",
    "\n",
    "net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential output shape:\t torch.Size([1, 64, 24, 24])\n",
      "Sequential output shape:\t torch.Size([1, 192, 12, 12])\n",
      "Sequential output shape:\t torch.Size([1, 480, 6, 6])\n",
      "Sequential output shape:\t torch.Size([1, 832, 3, 3])\n",
      "Sequential output shape:\t torch.Size([1, 1024])\n",
      "Linear output shape:\t torch.Size([1, 10])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
     ]
    }
   ],
   "source": [
    "X = torch.rand(size=(1, 1, 96, 96))\n",
    "for layer in net:\n",
    "    X = layer(X)\n",
    "    print(layer.__class__.__name__,'output shape:\\t', X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
       "    (1): ReLU()\n",
       "    (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (1): Sequential(\n",
       "    (0): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (3): ReLU()\n",
       "    (4): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (2): Sequential(\n",
       "    (0): Inception(\n",
       "      (p1_1): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(192, 16, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (1): Inception(\n",
       "      (p1_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(128, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(32, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (3): Sequential(\n",
       "    (0): Inception(\n",
       "      (p1_1): Conv2d(480, 192, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(480, 96, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(96, 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(480, 16, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(16, 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(480, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (1): Inception(\n",
       "      (p1_1): Conv2d(512, 160, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(112, 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (2): Inception(\n",
       "      (p1_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (3): Inception(\n",
       "      (p1_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(512, 144, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(144, 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (4): Inception(\n",
       "      (p1_1): Conv2d(528, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(528, 160, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(528, 32, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (5): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (4): Sequential(\n",
       "    (0): Inception(\n",
       "      (p1_1): Conv2d(832, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(832, 160, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(832, 32, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (1): Inception(\n",
       "      (p1_1): Conv2d(832, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_1): Conv2d(832, 192, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p2_2): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (p3_1): Conv2d(832, 48, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (p3_2): Conv2d(48, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "      (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (2): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "    (3): Flatten(start_dim=1, end_dim=-1)\n",
       "  )\n",
       "  (5): Linear(in_features=1024, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.to(device)\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total network parameters : 5977530\n"
     ]
    }
   ],
   "source": [
    "# count total network parameters\n",
    "print('Total network parameters :', sum(param.numel() for param in net.parameters() if param.requires_grad))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/torchvision/datasets/mnist.py:498: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  /pytorch/torch/csrc/utils/tensor_numpy.cpp:180.)\n",
      "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 1, 96, 96])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Load FashionMNIST dataset and apply data transform, make input dimension 28x28 -> 96x96\n",
    "\n",
    "transform = transforms.Compose([transforms.Resize([96, 96]),\n",
    "                                transforms.RandomHorizontalFlip(),\n",
    "                                transforms.ToTensor()])\n",
    "\n",
    "fmnist_train = datasets.FashionMNIST(\n",
    "    root=\"../../../data\", train=True, transform=transform, download=True)\n",
    "fmnist_test = datasets.FashionMNIST(\n",
    "    root=\"../../../data\", train=False, transform=transform, download=True)\n",
    "\n",
    "batch_size = 64\n",
    "\n",
    "train_loader = DataLoader(fmnist_train, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(fmnist_test, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "images, labels = next(iter(train_loader))\n",
    "images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Loss function\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Optimizer\n",
    "learning_rate = 0.001\n",
    "\n",
    "# optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate)\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate, betas=(0.9, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Training function\n",
    "\n",
    "def train_1_epoch(model, optimizer, train_loss, train_acc):\n",
    "    \n",
    "    model.train()             # set model to training mode\n",
    "\n",
    "    running_loss = 0.\n",
    "    running_corrects = 0\n",
    "    for i, (images, labels) in enumerate(train_loader):\n",
    "        images = images.to(device) \n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        # forward\n",
    "        outputs = model(images)\n",
    "        \n",
    "        # loss\n",
    "        loss = criterion(outputs, labels) # predicted outputs v.s. actual labels\n",
    "        \n",
    "        # backwards\n",
    "        optimizer.zero_grad()  # zero gradient\n",
    "        loss.backward()        # loss.backward would calculate dloss/dw_i  \n",
    "        optimizer.step()       # update network parameters (w_i)\n",
    "        \n",
    "        # compute statistics (avg. loss, accuracy)\n",
    "        running_loss += loss.item() * labels.size(0)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        running_corrects += torch.sum(predictions == labels.data)\n",
    "        \n",
    "        #if (i+1)%300 == 0: # every 300 steps, print something\n",
    "        #    print(f'epoch {epoch+1}/{num_epochs}, step {i+1}/{len(train_loader)}, loss={loss.item():.4f}')\n",
    "            \n",
    "    epoch_loss = running_loss / len(fmnist_train)            ; train_loss.append(epoch_loss)\n",
    "    epoch_acc  = running_corrects / len(fmnist_train) * 100. ; train_acc.append(epoch_acc)\n",
    "    print(f'>>> End epoch {epoch+1}, train accuracy = {epoch_acc:.2f}%, train avgLoss = {epoch_loss:.4f}')\n",
    "\n",
    "    \n",
    "    \n",
    "def validation(model, valid_loss, valid_acc):\n",
    "    \n",
    "    model.eval()              # set model to evaluation mode\n",
    "    \n",
    "    running_loss = 0.\n",
    "    running_corrects = 0\n",
    "    \n",
    "    for i, (images, labels) in enumerate(test_loader):\n",
    "        \n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(images)\n",
    "        \n",
    "        loss = criterion(outputs, labels)\n",
    "        \n",
    "        # compute statistics (avg. loss, accuracy)\n",
    "        running_loss += loss.item() * labels.size(0)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        running_corrects += torch.sum(predictions == labels.data)\n",
    "    \n",
    "    valid_loss.append(running_loss/len(test_loader.dataset))\n",
    "    valid_acc.append(running_corrects/len(test_loader.dataset) * 100.)\n",
    "    print(f'>>>              valid accuracy = {valid_acc[-1]:.2f}%, valid avgLoss = {valid_loss[-1]:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> End epoch 1, train accuracy = 64.22%, train avgLoss = 0.9023\n",
      ">>>              valid accuracy = 80.36%, valid avgLoss = 0.5305\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 2, train accuracy = 83.38%, train avgLoss = 0.4456\n",
      ">>>              valid accuracy = 84.76%, valid avgLoss = 0.4147\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 3, train accuracy = 86.32%, train avgLoss = 0.3687\n",
      ">>>              valid accuracy = 84.94%, valid avgLoss = 0.3950\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 4, train accuracy = 87.54%, train avgLoss = 0.3312\n",
      ">>>              valid accuracy = 88.40%, valid avgLoss = 0.3188\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 5, train accuracy = 88.65%, train avgLoss = 0.3047\n",
      ">>>              valid accuracy = 88.41%, valid avgLoss = 0.3155\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 6, train accuracy = 89.22%, train avgLoss = 0.2880\n",
      ">>>              valid accuracy = 89.15%, valid avgLoss = 0.3030\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 7, train accuracy = 90.05%, train avgLoss = 0.2674\n",
      ">>>              valid accuracy = 89.47%, valid avgLoss = 0.2839\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 8, train accuracy = 90.66%, train avgLoss = 0.2519\n",
      ">>>              valid accuracy = 88.85%, valid avgLoss = 0.3100\n",
      "\tTime: 0m 45s\n",
      ">>> End epoch 9, train accuracy = 90.89%, train avgLoss = 0.2427\n",
      ">>>              valid accuracy = 90.56%, valid avgLoss = 0.2674\n",
      "\tTime: 0m 46s\n",
      ">>> End epoch 10, train accuracy = 91.34%, train avgLoss = 0.2312\n",
      ">>>              valid accuracy = 90.39%, valid avgLoss = 0.2679\n",
      "\tTime: 0m 45s\n"
     ]
    }
   ],
   "source": [
    "train_loss = []\n",
    "train_acc = []\n",
    "valid_loss = []\n",
    "valid_acc = []\n",
    "\n",
    "num_epochs = 10\n",
    "for epoch in range(0, num_epochs):\n",
    "    since = time.time()\n",
    "    \n",
    "    train_1_epoch(net, optimizer, train_loss, train_acc)\n",
    "    validation(net, valid_loss, valid_acc)\n",
    "    \n",
    "    time_elapsed = time.time() - since\n",
    "    print(f'\\tTime: {time_elapsed//60:.0f}m {time_elapsed%60:.0f}s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 328,
       "width": 903
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n",
    "plt.rc('font', size=16)\n",
    "\n",
    "ax[0].plot(range(1,num_epochs+1)[::], train_loss[::], 'o--', label='train', color='b')\n",
    "ax[0].plot(range(1,num_epochs+1)[::], valid_loss[::], 'o--', label='valid', color='dodgerblue')\n",
    "ax[1].plot(range(1,num_epochs+1)[::], train_acc[::] , 'o--', label='train', color='b')\n",
    "ax[1].plot(range(1,num_epochs+1)[::], valid_acc[::], 'o--', label='valid', color='dodgerblue')\n",
    "\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[1].set_ylabel('accuracy')\n",
    "\n",
    "for i in range(2):\n",
    "    ax[i].set_xlabel('epoch')\n",
    "    ax[i].legend(loc='best')"
   ]
  },
  {
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}