notebooks/7.3_NiN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [7.3 Network in Network (NiN)](https://d2l.ai/chapter_convolutional-modern/nin.html)\n",
    "\n",
    "paper : [Network In Network (Lin et al. 2013)](https://arxiv.org/abs/1312.4400)\n",
    "\n",
    "#### Common design pattern of **LeNet**, **AlexNet**, and **VGG** : \n",
    "- A sequence of **convolution and pooling layers** (to extract spatial structure) + **fully-connected layers** (to post-process the representations from convolutions)\n",
    "\n",
    "\n",
    "- Most of parameters are contributed from the fully-connected layers at the end of the network. Dropout is then applied to aviod overfitting. \n",
    "\n",
    "\n",
    "### Network in Network (NiN) structure design \n",
    "\n",
    "- The original NiN network was proposed shortly after AlexNet. So NiN uses convolutional layers with kernel sizes of 11x11, 5x5, 3x3, and the corresponding numbers of output channels are the same as in AlexNet.\n",
    "\n",
    "\n",
    "#### 1x1 Convolution\n",
    "\n",
    "- A **fully connected layer** applied on the **channels** at **each pixel location**. \n",
    "\n",
    "\n",
    "- The **NiN** structure is basically a **1x1 convolution layer**. \n",
    "\n",
    "<img src='./images/fig_1x1_conv.png' width='400'/>\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;  <sub>* Image Credit : https://forum.perceptilabs.com/t/correct-way-to-specify-a-1x1-convolution/226/2 </sub>\n",
    "\n",
    "\n",
    "- **1x1 convolution** allows **complex and learnable interactions of cross channel information**, while the **spatial structure** of the intermediate hidden representations are preserved. \n",
    "\n",
    "\n",
    "#### Global Average Pooling\n",
    "\n",
    "\n",
    "- NiN avoids fully-connected layers an the end of the network. -> significantly reduces the number of required model parameters and reduces overfitting.\n",
    "\n",
    "\n",
    "- NiN uses an NiN block with a number of output channels equal to the number of label classes, followed by a global average pooling layer, yielding a vector of logits.\n",
    "\n",
    "\n",
    "- The idea is to enforce the network to generate one feature map per channel for each corresponding catagory of the classification task in the last layer. \n",
    "\n",
    "\n",
    "#### Architectures of VGG and NiN\n",
    "\n",
    "<img src='./images/fig_7.3.1.png' width='600'/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implement NiN 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",
    "\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": [
    "def nin_block(in_channels, out_channels, kernel_size, strides, padding):\n",
    "    return nn.Sequential(\n",
    "        nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),\n",
    "        nn.ReLU(),\n",
    "        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(),\n",
    "        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ``nn.AdaptiveAvgPool2d(output_size)`` ([doc](https://pytorch.org/docs/stable/generated/torch.nn.AdaptiveAvgPool2d.html)) v.s. ``nn.AvgPool2d(kernel_size, stride=None, padding=0)`` ([doc](https://pytorch.org/docs/stable/generated/torch.nn.AvgPool2d.html?highlight=avgpool2d#torch.nn.AvgPool2d))\n",
    "\n",
    "- In ``AvgPool2d``, we define a kernel and stride size for the pooling operation, and the function just performs that operation on all valid inputs.\n",
    "\n",
    "\n",
    "\n",
    "- In ``AdaptiveAvgPool2d``, we define the output size we require at the end of the pooling operation, and pytorch infers what pooling parameters to use to do that.\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp; <sub>* reference : https://discuss.pytorch.org/t/adaptive-avg-pool2d-vs-avg-pool2d/27011 <\\sub>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total network parameters : 1992166\n"
     ]
    }
   ],
   "source": [
    "net = nn.Sequential(\n",
    "    nin_block(1, 96, kernel_size=11, strides=4, padding=0),\n",
    "    nn.MaxPool2d(3, stride=2),\n",
    "    nin_block(96, 256, kernel_size=5, strides=1, padding=2),\n",
    "    nn.MaxPool2d(3, stride=2),\n",
    "    nin_block(256, 384, kernel_size=3, strides=1, padding=1),\n",
    "    nn.MaxPool2d(3, stride=2), \n",
    "    nn.Dropout(0.5),\n",
    "    # There are 10 label classes\n",
    "    nin_block(384, 10, kernel_size=3, strides=1, padding=1),\n",
    "    nn.AdaptiveAvgPool2d((1, 1)),\n",
    "    # Transform the four-dimensional output into two-dimensional output with a\n",
    "    # shape of (batch size, 10)\n",
    "    nn.Flatten())\n",
    "\n",
    "net.to(device)\n",
    "\n",
    "# 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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential output shape:\t torch.Size([1, 96, 54, 54])\n",
      "MaxPool2d output shape:\t torch.Size([1, 96, 26, 26])\n",
      "Sequential output shape:\t torch.Size([1, 256, 26, 26])\n",
      "MaxPool2d output shape:\t torch.Size([1, 256, 12, 12])\n",
      "Sequential output shape:\t torch.Size([1, 384, 12, 12])\n",
      "MaxPool2d output shape:\t torch.Size([1, 384, 5, 5])\n",
      "Dropout output shape:\t torch.Size([1, 384, 5, 5])\n",
      "Sequential output shape:\t torch.Size([1, 10, 5, 5])\n",
      "AdaptiveAvgPool2d output shape:\t torch.Size([1, 10, 1, 1])\n",
      "Flatten 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, 224, 224)).to(device)\n",
    "\n",
    "for layer in net:\n",
    "    X = layer(X)\n",
    "    print(layer.__class__.__name__,'output shape:\\t', X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(96, 96, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): ReLU()\n",
       "    (4): Conv2d(96, 96, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (5): ReLU()\n",
       "  )\n",
       "  (1): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (2): Sequential(\n",
       "    (0): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): ReLU()\n",
       "    (4): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (5): ReLU()\n",
       "  )\n",
       "  (3): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (4): Sequential(\n",
       "    (0): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): ReLU()\n",
       "    (4): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (5): ReLU()\n",
       "  )\n",
       "  (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (6): Dropout(p=0.5, inplace=False)\n",
       "  (7): Sequential(\n",
       "    (0): Conv2d(384, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(10, 10, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): ReLU()\n",
       "    (4): Conv2d(10, 10, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (5): ReLU()\n",
       "  )\n",
       "  (8): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (9): Flatten(start_dim=1, end_dim=-1)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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, 224, 224])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Load FashionMNIST dataset and apply data transform, make input dimension 28x28 -> 224x224\n",
    "\n",
    "transform = transforms.Compose([transforms.Resize([224, 224]),\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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Loss function\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Optimizer\n",
    "learning_rate = 0.0001\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": 9,
   "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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> End epoch 1, train accuracy = 38.68%, train avgLoss = 1.6603\n",
      ">>>              valid accuracy = 67.24%, valid avgLoss = 0.9370\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 2, train accuracy = 71.39%, train avgLoss = 0.7975\n",
      ">>>              valid accuracy = 74.09%, valid avgLoss = 0.7312\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 3, train accuracy = 75.21%, train avgLoss = 0.6777\n",
      ">>>              valid accuracy = 74.71%, valid avgLoss = 0.6797\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 4, train accuracy = 77.49%, train avgLoss = 0.6137\n",
      ">>>              valid accuracy = 78.16%, valid avgLoss = 0.5958\n",
      "\tTime: 0m 60s\n",
      ">>> End epoch 5, train accuracy = 79.43%, train avgLoss = 0.5659\n",
      ">>>              valid accuracy = 80.80%, valid avgLoss = 0.5400\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 6, train accuracy = 80.93%, train avgLoss = 0.5302\n",
      ">>>              valid accuracy = 80.87%, valid avgLoss = 0.5287\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 7, train accuracy = 81.91%, train avgLoss = 0.5052\n",
      ">>>              valid accuracy = 82.58%, valid avgLoss = 0.4900\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 8, train accuracy = 82.63%, train avgLoss = 0.4799\n",
      ">>>              valid accuracy = 82.77%, valid avgLoss = 0.4715\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 9, train accuracy = 83.30%, train avgLoss = 0.4633\n",
      ">>>              valid accuracy = 84.09%, valid avgLoss = 0.4582\n",
      "\tTime: 0m 59s\n",
      ">>> End epoch 10, train accuracy = 83.86%, train avgLoss = 0.4477\n",
      ">>>              valid accuracy = 84.28%, valid avgLoss = 0.4498\n",
      "\tTime: 0m 59s\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": 12,
   "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
}