notebooks/7.7_DenseNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [7.7 Densely Connected Networks (DenseNet)](https://d2l.ai/chapter_convolutional-modern/densenet.html)\n",
    "\n",
    "paper : [Densely Connected Convolutional Networks (Huang et al. 2017)](https://openaccess.thecvf.com/content_cvpr_2017/papers/Huang_Densely_Connected_Convolutional_CVPR_2017_paper.pdf)\n",
    "\n",
    "<img src='./images/slide_denseNet.png' width='800'/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation 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": "markdown",
   "metadata": {},
   "source": [
    "## Dense Block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_block(input_channels, num_channels):\n",
    "    '''\n",
    "        BN -> ReLU -> 3x3 Conv\n",
    "    '''\n",
    "    return nn.Sequential(\n",
    "        nn.BatchNorm2d(input_channels), nn.ReLU(),\n",
    "        nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DenseBlock(nn.Module):\n",
    "    def __init__(self, num_convs, input_channels, num_channels):\n",
    "        '''\n",
    "            i = 0\n",
    "                conv_block(input_channels, num_channels)\n",
    "                \n",
    "            i = 1 \n",
    "                conv_block(input_channels+num_channels, num_channels)\n",
    "            \n",
    "                # --- Note ---\n",
    "                  The effective input_channels of the i=1 layer (in a denseblock) is : input_channels+num_channels .\\\n",
    "                  Because the i=1 layer accepts inputs from the original input and the output of the i=0 layer.\n",
    "                # --- End ---\n",
    "    \n",
    "        '''\n",
    "        super(DenseBlock, self).__init__()\n",
    "        layer = []\n",
    "        for i in range(num_convs):\n",
    "            layer.append(conv_block(\n",
    "                num_channels * i + input_channels, num_channels))\n",
    "        self.net = nn.Sequential(*layer)\n",
    "\n",
    "    def forward(self, X):\n",
    "        for blk in self.net:\n",
    "            Y = blk(X)\n",
    "            # Concatenate the input and output of each block on the channel\n",
    "            # dimension\n",
    "            X = torch.cat((X, Y), dim=1)\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DenseBlock(\n",
       "  (net): Sequential(\n",
       "    (0): Sequential(\n",
       "      (0): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): ReLU()\n",
       "      (2): Conv2d(3, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    )\n",
       "    (1): Sequential(\n",
       "      (0): BatchNorm2d(13, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): ReLU()\n",
       "      (2): Conv2d(13, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blk = DenseBlock(num_convs=2, input_channels=3, num_channels=10)\n",
    "blk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check \n",
    "\n",
    "- Input X dimension : 3x8x8\n",
    "- After passing the 1st Conv of the DenseBlock : \n",
    "    Output dimension : (3+10)x8x8 = 13x8x8\n",
    "- After passing the 2st Conv of the DenseBlock : \n",
    "    Output dimension : (3+10+10)x8x8 = 23x8x8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 23, 8, 8])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = torch.randn(4, 3, 8, 8)\n",
    "Y = blk(X)\n",
    "Y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transition Layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transition_block(input_channels, num_channels):\n",
    "    return nn.Sequential(\n",
    "        nn.BatchNorm2d(input_channels), nn.ReLU(),\n",
    "        nn.Conv2d(input_channels, num_channels, kernel_size=1),\n",
    "        nn.AvgPool2d(kernel_size=2, stride=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 10, 4, 4])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blk = transition_block(23, 10)\n",
    "blk(Y).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DenseNet Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = nn.Sequential(\n",
    "    nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),\n",
    "    nn.BatchNorm2d(64), nn.ReLU(),\n",
    "    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# `num_channels`: the current number of channels\n",
    "num_channels, growth_rate = 64, 32\n",
    "num_convs_in_dense_blocks = [4, 4, 4, 4]\n",
    "blks = []\n",
    "for i, num_convs in enumerate(num_convs_in_dense_blocks):\n",
    "    blks.append(DenseBlock(num_convs, num_channels, growth_rate))\n",
    "    # This is the number of output channels in the previous dense block\n",
    "    num_channels += num_convs * growth_rate\n",
    "    # A transition layer that halves the number of channels is added between\n",
    "    # the dense blocks\n",
    "    if i != len(num_convs_in_dense_blocks) - 1:\n",
    "        blks.append(transition_block(num_channels, num_channels // 2))\n",
    "        num_channels = num_channels // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = nn.Sequential(\n",
    "    b1, *blks,\n",
    "    nn.BatchNorm2d(num_channels), nn.ReLU(),\n",
    "    nn.AdaptiveAvgPool2d((1, 1)),\n",
    "    nn.Flatten(),\n",
    "    nn.Linear(num_channels, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "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): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "    (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (1): DenseBlock(\n",
       "    (net): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(96, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (2): Sequential(\n",
       "        (0): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (3): Sequential(\n",
       "        (0): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(160, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (2): Sequential(\n",
       "    (0): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
       "  )\n",
       "  (3): DenseBlock(\n",
       "    (net): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(96, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (2): Sequential(\n",
       "        (0): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(160, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (3): Sequential(\n",
       "        (0): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(192, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (4): Sequential(\n",
       "    (0): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(224, 112, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
       "  )\n",
       "  (5): DenseBlock(\n",
       "    (net): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(112, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(144, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (2): Sequential(\n",
       "        (0): BatchNorm2d(176, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(176, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (3): Sequential(\n",
       "        (0): BatchNorm2d(208, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(208, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (6): Sequential(\n",
       "    (0): BatchNorm2d(240, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(240, 120, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
       "  )\n",
       "  (7): DenseBlock(\n",
       "    (net): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(120, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): BatchNorm2d(152, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(152, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (2): Sequential(\n",
       "        (0): BatchNorm2d(184, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(184, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "      (3): Sequential(\n",
       "        (0): BatchNorm2d(216, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (1): ReLU()\n",
       "        (2): Conv2d(216, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (8): BatchNorm2d(248, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (9): ReLU()\n",
       "  (10): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (11): Flatten(start_dim=1, end_dim=-1)\n",
       "  (12): Linear(in_features=248, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.to(device)\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential output shape:\t torch.Size([1, 64, 56, 56])\n",
      "DenseBlock output shape:\t torch.Size([1, 192, 56, 56])\n",
      "Sequential output shape:\t torch.Size([1, 96, 28, 28])\n",
      "DenseBlock output shape:\t torch.Size([1, 224, 28, 28])\n",
      "Sequential output shape:\t torch.Size([1, 112, 14, 14])\n",
      "DenseBlock output shape:\t torch.Size([1, 240, 14, 14])\n",
      "Sequential output shape:\t torch.Size([1, 120, 7, 7])\n",
      "DenseBlock output shape:\t torch.Size([1, 248, 7, 7])\n",
      "BatchNorm2d output shape:\t torch.Size([1, 248, 7, 7])\n",
      "ReLU output shape:\t torch.Size([1, 248, 7, 7])\n",
      "AdaptiveAvgPool2d output shape:\t torch.Size([1, 248, 1, 1])\n",
      "Flatten output shape:\t torch.Size([1, 248])\n",
      "Linear output shape:\t torch.Size([1, 10])\n"
     ]
    }
   ],
   "source": [
    "X = torch.rand(size=(1, 1, 224, 224)).to(device)\n",
    "for layer in net:\n",
    "    X = layer(X)\n",
    "    print(layer.__class__.__name__,'output shape:\\t', X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total network parameters : 758226\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": 12,
   "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": 12,
     "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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Loss function\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> End epoch 1, train accuracy = 84.18%, train avgLoss = 0.4368\n",
      ">>>              valid accuracy = 85.72%, valid avgLoss = 0.4009\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 2, train accuracy = 89.50%, train avgLoss = 0.2852\n",
      ">>>              valid accuracy = 89.59%, valid avgLoss = 0.2778\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 3, train accuracy = 91.05%, train avgLoss = 0.2448\n",
      ">>>              valid accuracy = 90.07%, valid avgLoss = 0.2759\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 4, train accuracy = 91.82%, train avgLoss = 0.2192\n",
      ">>>              valid accuracy = 91.06%, valid avgLoss = 0.2450\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 5, train accuracy = 92.43%, train avgLoss = 0.2038\n",
      ">>>              valid accuracy = 90.90%, valid avgLoss = 0.2441\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 6, train accuracy = 93.05%, train avgLoss = 0.1891\n",
      ">>>              valid accuracy = 92.53%, valid avgLoss = 0.2033\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 7, train accuracy = 93.41%, train avgLoss = 0.1784\n",
      ">>>              valid accuracy = 92.42%, valid avgLoss = 0.2018\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 8, train accuracy = 93.79%, train avgLoss = 0.1666\n",
      ">>>              valid accuracy = 91.71%, valid avgLoss = 0.2194\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 9, train accuracy = 94.17%, train avgLoss = 0.1581\n",
      ">>>              valid accuracy = 91.93%, valid avgLoss = 0.2258\n",
      "\tTime: 0m 32s\n",
      ">>> End epoch 10, train accuracy = 94.42%, train avgLoss = 0.1483\n",
      ">>>              valid accuracy = 93.07%, valid avgLoss = 0.1911\n",
      "\tTime: 0m 32s\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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 333,
       "width": 913
      },
      "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
}