MobileNetV2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "peaceful-index",
   "metadata": {},
   "source": [
    "# MobileNetV2\n",
    "\n",
    "- Implementation, comparisong and benchmarking of: Convolutions, Blocks, Model\n",
    "- Implementation: Simple, clean OOP implementations with minimal parametrisations\n",
    "- Comparisons: Parameters, runtime, accuracy\n",
    "- Benchmarking: Comparison to VGG and ResNets on CIFAR100\n",
    "\n",
    "1. Convolutions\n",
    "- Normal, Depthwise\n",
    "- Comparison: Parameter and Activation Shapes\n",
    "\n",
    "2. Blocks\n",
    "- Standard (VGG), Depthwise Separable (MobileNetV1), Residual Bottleneck (ResNets), Interted Residual Bottleneck (MobileNetV2)\n",
    "- Comparison: Blocks as simple classifiers on MNIST, instantiated to have similar number of params for fair comparison\n",
    "\n",
    "3. Model\n",
    "- MobileNetV2 Implementation\n",
    "- Benchmarking against VGG16, ResNet50 by also using multiple width multipliers to have similar number of params as the baselines\n",
    "- Comparison: Params, MACs, runtime, Accuracy on CIFAR100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "undefined-morgan",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torchvision import transforms \n",
    "from torchvision.datasets import MNIST, CIFAR100\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "import joblib\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import OrderedDict, defaultdict\n",
    "\n",
    "%config Completer.use_jedi = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sorted-coffee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def named_shape(names, tensor):\n",
    "    return {k: v for k, v in zip(names, tensor.shape)} "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "canadian-settlement",
   "metadata": {},
   "source": [
    "# 1. Convolutions\n",
    "- Comparision of the weights and activations of the two convolution options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "casual-findings",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 2      # Nr or data points (input images)\n",
    "C = 4      # Nr Channels of input image\n",
    "H = 10     # Height of the input image\n",
    "W = 10     # Width of the input image\n",
    "F = 5      # Nr of Filters in Conv (Out size, out channels)\n",
    "K = (3, 3) # Kernel Size\n",
    "\n",
    "X = torch.randn(N, C, H, W)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "center-score",
   "metadata": {},
   "source": [
    "## 1.1 Normal Conv\n",
    "- A filter of shape [C, K, K] convolves the information of all input channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "satisfactory-local",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape: {'N': 2, 'C': 4, 'H': 10, 'W': 10}\n",
      "Kernel shape: {'F': 5, 'C': 4, 'K_h': 3, 'K_w': 3}\n",
      "Output shape: {'N': 2, 'C*': 5, 'H*': 8, 'W*': 8}\n"
     ]
    }
   ],
   "source": [
    "std_conv = nn.Conv2d(in_channels=C, out_channels=F, kernel_size=K)\n",
    "\n",
    "print(\"Input shape:\", named_shape([\"N\", \"C\", \"H\", \"W\"], X))\n",
    "print(\"Kernel shape:\", named_shape([\"F\", \"C\", \"K_h\", \"K_w\"], std_conv.weight))\n",
    "print(\"Output shape:\", named_shape([\"N\", \"C*\", \"H*\", \"W*\"], std_conv(X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chinese-coating",
   "metadata": {},
   "source": [
    "## 1.2 Depthwise Conv\n",
    "- A filter of shape [1, K, K] convlves the information of a single input channel\n",
    "- Note that because each input channel has it's own filter, the layer cannot change the number of channels of it's input. That's where the 1x1 layer comes in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "flexible-characterization",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape: {'N': 2, 'C': 4, 'H': 10, 'W': 10}\n",
      "Kernel shape: {'F': 4, 'C': 1, 'K_h': 3, 'K_w': 3}\n",
      "Output shape: {'N': 2, 'C*': 4, 'H*': 8, 'W*': 8}\n"
     ]
    }
   ],
   "source": [
    "depth_conv = nn.Conv2d(in_channels=C, out_channels=C, kernel_size=K, groups=C)\n",
    "\n",
    "print(\"Input shape:\", named_shape([\"N\", \"C\", \"H\", \"W\"], X))\n",
    "print(\"Kernel shape:\", named_shape([\"F\", \"C\", \"K_h\", \"K_w\"], depth_conv.weight))\n",
    "print(\"Output shape:\", named_shape([\"N\", \"C*\", \"H*\", \"W*\"], depth_conv(X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "universal-admission",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape: {'N': 2, 'C': 4, 'H': 8, 'W': 8}\n",
      "Kernel shape: {'F': 5, 'C': 4, 'K_h': 1, 'K_w': 1}\n",
      "Output shape: {'N': 2, 'C*': 5, 'H*': 8, 'W*': 8}\n"
     ]
    }
   ],
   "source": [
    "point_conv = nn.Conv2d(in_channels=C, out_channels=F, kernel_size=1)\n",
    "\n",
    "print(\"Input shape:\", named_shape([\"N\", \"C\", \"H\", \"W\"], depth_conv(X)))\n",
    "print(\"Kernel shape:\", named_shape([\"F\", \"C\", \"K_h\", \"K_w\"], point_conv.weight))\n",
    "print(\"Output shape:\", named_shape([\"N\", \"C*\", \"H*\", \"W*\"], point_conv(depth_conv(X))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proof-injury",
   "metadata": {},
   "source": [
    "# 2. Blocks\n",
    "- Implementing, comparing and benchmarking different Block architectures\n",
    "\n",
    "## 2.1 Block Architectures\n",
    "- Standard: Conv-BN-ReLU\n",
    "- Residual Bottleneck: [Conv1x1-BN-ReLU - Conv3x3BN-ReLU - Conv1x1-BN-ReLU]\n",
    "- MobilenetV1 Block: [dwConv3x3-BN-ReLU, Conv1x1-BN-ReLU]\n",
    "- MobilenetV2 Block: [Conv1x1-BN-ReLU - dwConv3x3BN-ReLU - Conv1x1-BN-ReLU]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "conditional-theme",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBNReLU(nn.Sequential):\n",
    "    \"\"\"\n",
    "    Generic Conv-Bn-ReLU Layer.\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, depthwise=False, relu=True, relu_cls=nn.ReLU):\n",
    "        groups = 1\n",
    "        if depthwise:\n",
    "            assert out_channels == in_channels\n",
    "            groups = in_channels\n",
    "        padding = (kernel_size - 1) // 2\n",
    "        \n",
    "        layers = [\n",
    "            (\"conv\", nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, groups=groups, bias=False)),\n",
    "            (\"bn\", nn.BatchNorm2d(out_channels))\n",
    "        ]\n",
    "        if relu:\n",
    "            layers.append((\"relu\", relu_cls(inplace=True)))\n",
    "        \n",
    "        super(ConvBNReLU, self).__init__(OrderedDict(layers))\n",
    "        \n",
    "        \n",
    "class ResidualBottleneck(nn.Module):\n",
    "    \"\"\"\n",
    "    Regular hidden Layer in Resnets V1 (not preactivation).\n",
    "    Bottleneck layer is the middle 3x3 conv layer, should reduce channel dimensionality.\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.residual = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, hidden_channels, kernel_size=1),\n",
    "            ConvBNReLU(hidden_channels, hidden_channels, kernel_size=3),\n",
    "            ConvBNReLU(hidden_channels, out_channels, kernel_size=1, relu=False),\n",
    "        )\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "    \n",
    "    def forward(self, X):\n",
    "        return self.relu(self.residual(X) + X)\n",
    "    \n",
    "    \n",
    "class DepthSeparableBlock(nn.Sequential):\n",
    "    \"\"\"\n",
    "    MobileNetV1 Block: dw conv 3x3 - pw conv 1x1\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        layers = [\n",
    "            (\"dw\", ConvBNReLU(in_channels, in_channels, kernel_size=3, depthwise=True)),\n",
    "            (\"pw\", ConvBNReLU(in_channels, out_channels, kernel_size=1, depthwise=False))\n",
    "        ]\n",
    "        super().__init__(OrderedDict(layers))\n",
    "        \n",
    "        \n",
    "class InvertedResidualBlock(nn.Module):\n",
    "    \"\"\"\n",
    "    MobileNetV2 Block: Middle conv layer should expand channel dimesnionality, is efficient due to being depthwise separable.\n",
    "    Last pw layer is the bottleneck and has no nonlinearity.\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.residual = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, hidden_channels, kernel_size=1, depthwise=False, relu_cls=nn.ReLU6),\n",
    "            ConvBNReLU(hidden_channels, hidden_channels, kernel_size=3, depthwise=True, relu_cls=nn.ReLU6),\n",
    "            ConvBNReLU(hidden_channels, out_channels, kernel_size=1, depthwise=False, relu=False),\n",
    "        )\n",
    "    \n",
    "    def forward(self, X):\n",
    "        out = self.residual(X)\n",
    "        out = out + X\n",
    "        return out\n",
    "    \n",
    "    \n",
    "count_params = lambda m: sum(p.numel() for p in m.parameters())\n",
    "\n",
    "count_layers = lambda m: len([l for l in m.modules() if isinstance(l, nn.Conv2d)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prospective-pricing",
   "metadata": {},
   "source": [
    "## 2.2 Benchmarking Blocks as Classifiers\n",
    "- Comparing shallow models using a single block type and evaluating on MNIST\n",
    "- Trying to make things as comparable as possible, keeping the same nr of input/output channels and as few blocks as possible\n",
    "- The reference block is a single conv-bn-relu block, which has the most parameters from the options\n",
    "- Bottlneck or Expansion layers are designed to have their hidden channels as multiples of the backbone, so in order to keep the reference parameter count I had to add multiple blocks\n",
    "- Classifier starts with a conv block for intial channel expansion and has some maxpools to reduce size of classification layer\n",
    "- Given the simplicity of MNIST all options perform well\n",
    "- The ConvBNRelu Block model, given it's reduced number of layers, converges the quickest however ends in the worst performance\n",
    "- Residual and DepthSeparable Block Models require the most ramp-up time but also manage to outperform the baseline\n",
    "- The InvertedResidual Block Model ramps up quickly and also achieves the highest score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "instructional-methodology",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_block_classifier(block_cls, backbone_size=16, hidden_channels=4, n_blocks=1):\n",
    "    if block_cls in [ResidualBottleneck, InvertedResidualBlock]:\n",
    "        blocks = [block_cls(in_channels=backbone_size, hidden_channels=hidden_channels, out_channels=backbone_size) for _ in range(n_blocks)]\n",
    "    else:\n",
    "        blocks = [block_cls(in_channels=backbone_size, out_channels=backbone_size) for _ in range(n_blocks)]\n",
    "    \n",
    "    return nn.Sequential(\n",
    "        ConvBNReLU(in_channels=1, out_channels=backbone_size),\n",
    "        nn.MaxPool2d(2, 2),\n",
    "        *blocks,\n",
    "        nn.MaxPool2d(2, 2),\n",
    "        nn.Flatten(),\n",
    "        nn.Linear(784, 10)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "id": "particular-tomorrow",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\n",
    "ds_path = \"/data/datasets/MNIST\"\n",
    "train_ds = MNIST(root=ds_path, train=True, transform=t)\n",
    "test_ds = MNIST(root=ds_path, train=False, transform=t)\n",
    "\n",
    "train_loader = DataLoader(train_ds, batch_size=1000)\n",
    "test_loader = DataLoader(test_ds, batch_size=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "sixth-semiconductor",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_acc(model, loader):\n",
    "    device = next(iter(model.parameters())).device\n",
    "    \n",
    "    correct = 0\n",
    "    n_obs = 0\n",
    "\n",
    "    model.eval()\n",
    "    for X, y in loader:\n",
    "        X, y = X.to(device), y.to(device)\n",
    "        with torch.no_grad():\n",
    "            out = model(X)\n",
    "            correct += (out.argmax(dim=1) == y).float().sum().item()\n",
    "        n_obs += len(X)\n",
    "    model.train()\n",
    "\n",
    "    acc = correct / n_obs\n",
    "    return acc\n",
    "\n",
    "\n",
    "def train(model, n_epochs):\n",
    "    model = model.cuda()\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimiser = torch.optim.Adam(model.parameters(), lr=5e-4)\n",
    "    logs = defaultdict(list)\n",
    "    \n",
    "    for epoch in range(n_epochs):\n",
    "        for X, y in train_loader:\n",
    "            X, y = X.cuda(), y.cuda()\n",
    "            out = model(X)\n",
    "            loss = criterion(out, y)\n",
    "            \n",
    "            optimiser.zero_grad()\n",
    "            loss.backward()\n",
    "            optimiser.step()\n",
    "    \n",
    "        logs[\"test_acc\"].append(get_acc(model, test_loader))    \n",
    "    return logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "global-street",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layers & Parameters\n",
      "ConvBNReLU Model: 2 10362\n",
      "DepthSeparableBlock Model: 7 9418\n",
      "ResidualBottleneck Model: 7 9818\n",
      "InvertedResidualBlock Model: 7 10970\n"
     ]
    }
   ],
   "source": [
    "backbone_size = 16\n",
    "model_conv_bn_relu = get_block_classifier(ConvBNReLU, backbone_size=backbone_size, n_blocks=1)\n",
    "model_depth_separable = get_block_classifier(DepthSeparableBlock, backbone_size=backbone_size, n_blocks=3)\n",
    "model_residual_bottleneck = get_block_classifier(ResidualBottleneck, backbone_size=backbone_size, hidden_channels=backbone_size//2, n_blocks=2)\n",
    "model_intervted_residual_block = get_block_classifier(InvertedResidualBlock, backbone_size=backbone_size, hidden_channels=backbone_size*2, n_blocks=2)\n",
    "\n",
    "print(\"Layers & Parameters\")\n",
    "print(\"ConvBNReLU Model:\", count_layers(model_conv_bn_relu), count_params(model_conv_bn_relu))\n",
    "print(\"DepthSeparableBlock Model:\", count_layers(model_depth_separable), count_params(model_depth_separable))\n",
    "print(\"ResidualBottleneck Model:\", count_layers(model_residual_bottleneck), count_params(model_residual_bottleneck))\n",
    "print(\"InvertedResidualBlock Model:\", count_layers(model_intervted_residual_block), count_params(model_intervted_residual_block))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "id": "confused-spirituality",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_epochs = 20\n",
    "logs_conv_bn_relu = train(model_conv_bn_relu, n_epochs)\n",
    "logs_depth_separable = train(model_depth_separable, n_epochs)\n",
    "logs_residual_bottleneck = train(model_residual_bottleneck, n_epochs)\n",
    "logs_intervted_residual_block = train(model_intervted_residual_block, n_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "id": "coordinate-chassis",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f680f8e3f10>"
      ]
     },
     "execution_count": 373,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 7))\n",
    "\n",
    "plt.plot(logs_conv_bn_relu[\"test_acc\"], label=\"ConvBNReLu\")\n",
    "plt.plot(logs_depth_separable[\"test_acc\"], label=\"Depth Separable [x4]\")\n",
    "plt.plot(logs_residual_bottleneck[\"test_acc\"], label=\"Residual Bottleneck\")\n",
    "plt.plot(logs_intervted_residual_block[\"test_acc\"], label=\"Inverted Residual\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "secure-broadcasting",
   "metadata": {},
   "source": [
    "# 3. Model\n",
    "- Simple model implementation\n",
    "- Parameters: width multiplier and round n_filters to a multiple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "effective-tuesday",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBNReLU6(nn.Sequential):\n",
    "    \"\"\"\n",
    "    Generic Conv-Bn-ReLU6 Layer.\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, depthwise=False, relu=True):\n",
    "        groups = 1\n",
    "        if depthwise:\n",
    "            assert out_channels == in_channels\n",
    "            groups = in_channels\n",
    "        padding = (kernel_size - 1) // 2\n",
    "        \n",
    "        layers = [\n",
    "            (\"conv\", nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, groups=groups, bias=False)),\n",
    "            (\"bn\", nn.BatchNorm2d(out_channels))\n",
    "        ]\n",
    "        if relu:\n",
    "            layers.append((\"relu\", nn.ReLU6(inplace=True)))\n",
    "        \n",
    "        super(ConvBNReLU6, self).__init__(OrderedDict(layers))\n",
    "        \n",
    "\n",
    "class InvertedResidualBlock(nn.Module):\n",
    "    \"\"\"\n",
    "    MobileNetV2 Block: Middle conv layer should expand channel dimesnionality, is efficient due to being depthwise separable.\n",
    "    Last pw layer is the bottleneck and has no nonlinearity.\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels, stride=1):\n",
    "        super().__init__()\n",
    "        self.use_skip = stride == 1 and in_channels == out_channels\n",
    "        \n",
    "        # Pytorch/Keras implementations removes the first pw in the first inverted block - this is not mentioned in the paper.\n",
    "        # This happens at t=1 since the nr of hidden channels is the same as the input channel nr, so no 1x1 adjustment necessary\n",
    "        # I will omit this for simplicity\n",
    "        \n",
    "        self.residual = nn.Sequential(\n",
    "            ConvBNReLU6(in_channels, hidden_channels, kernel_size=1, depthwise=False),\n",
    "            ConvBNReLU6(hidden_channels, hidden_channels, kernel_size=3, depthwise=True, stride=stride),\n",
    "            ConvBNReLU6(hidden_channels, out_channels, kernel_size=1, depthwise=False, relu=False),\n",
    "        )\n",
    "    \n",
    "    def forward(self, X):\n",
    "        out = self.residual(X)\n",
    "        if self.use_skip:\n",
    "            out = out + X\n",
    "        return out\n",
    "        \n",
    "\n",
    "def _make_divisible(v, divisor, min_value=None):\n",
    "    \"\"\"\n",
    "    This function is taken from the original tf repo.\n",
    "    It ensures that all layers have a channel number that is divisible by 8\n",
    "    It can be seen here:\n",
    "    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py\n",
    "    :param v:\n",
    "    :param divisor:\n",
    "    :param min_value:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    if min_value is None:\n",
    "        min_value = divisor\n",
    "    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)\n",
    "    # Make sure that round down does not go down by more than 10%.\n",
    "    if new_v < 0.9 * v:\n",
    "        new_v += divisor\n",
    "    return new_v\n",
    "\n",
    "\n",
    "class MobileNetV2(nn.Sequential):\n",
    "    \"\"\"\n",
    "    For CIFAR\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, n_classes=100, width_mult=1., round_nearest=8):\n",
    "        \"\"\"\n",
    "        :param width_mult: multiplier for nr of filters in conv layers\n",
    "        :param round_nearest: ensure width (nr filters) is a multiple of this\n",
    "        \"\"\"\n",
    "        \n",
    "        setting = [\n",
    "            #t, c,  n, s\n",
    "            [1, 16,  1, 1],\n",
    "            [6, 24,  2, 1],\n",
    "            [6, 32,  3, 1],\n",
    "            [6, 64,  4, 2],\n",
    "            [6, 96,  3, 1],\n",
    "            [6, 160, 3, 2],\n",
    "            [6, 320, 1, 1],\n",
    "        ]\n",
    "        \n",
    "        layers = []\n",
    "        \n",
    "        # First Layers\n",
    "        in_channels = _make_divisible(32 * width_mult, round_nearest)\n",
    "        layers.extend([\n",
    "            ConvBNReLU6(in_channels=3, out_channels=in_channels)\n",
    "        ])\n",
    "        \n",
    "        # Inverted Residual Bottleneck Layers\n",
    "        for t, c, n, s in setting:\n",
    "            out_channels = _make_divisible(c * width_mult, round_nearest)\n",
    "            for i in range(n):\n",
    "                stride = s if i == 0 else 1\n",
    "                hidden_channels = int(round(in_channels * t))\n",
    "                layers.extend([\n",
    "                    InvertedResidualBlock(in_channels, hidden_channels, out_channels, stride=stride)\n",
    "                ])\n",
    "                in_channels = out_channels\n",
    "\n",
    "        # Last Layers\n",
    "        # As per paper, do not apply width multiplier less than 1 for last conv layer.\n",
    "        last_channels = _make_divisible(1280 * max(1.0, width_mult), round_nearest)\n",
    "        layers.extend([\n",
    "            ConvBNReLU6(in_channels, last_channels, kernel_size=1),\n",
    "            nn.AdaptiveAvgPool2d(output_size=1),\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(last_channels, n_classes),\n",
    "        ])\n",
    "        \n",
    "        super().__init__(*layers)\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out')\n",
    "                if m.bias is not None:\n",
    "                    nn.init.zeros_(m.bias)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                nn.init.ones_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.zeros_(m.bias)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vietnamese-shareware",
   "metadata": {},
   "source": [
    "# 3.1 Benchmarking MobileNetV2\n",
    "- Comparing to VGG16, ResNet50\n",
    "- Using MobileNetV2s at different widths to get similar param sizes as the baselines\n",
    "- Note on VGG: Replaced the two fc layers for one - so a lot less params\n",
    "- Results on CIFAR100: ResNet50 and VGG16 get better results than MN(width=1)\n",
    "- Resnets converge slower, but get higher results\n",
    "- Higher width multiplier leads to higher perf."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "expanded-hardwood",
   "metadata": {},
   "outputs": [],
   "source": [
    "from my_utils import set_torch_seed\n",
    "\n",
    "\n",
    "def get_loaders(batch_size=128):\n",
    "    normalise = transforms.Normalize([0.5071, 0.4867, 0.4408], [0.2675, 0.2565, 0.2761])\n",
    "    transform_train = transforms.Compose([\n",
    "        transforms.RandomCrop(32, padding=4),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        normalise,\n",
    "    ])\n",
    "\n",
    "    transform_test = transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        normalise,\n",
    "    ])\n",
    "    ds_path = \"/data/datasets/CIFAR100\"\n",
    "    train_ds = CIFAR100(root=ds_path, train=True, transform=transform_train)\n",
    "    test_ds = CIFAR100(root=ds_path, train=False, transform=transform_test)\n",
    "\n",
    "    train_loader = DataLoader(train_ds, batch_size=batch_size)\n",
    "    test_loader = DataLoader(test_ds, batch_size=batch_size)\n",
    "    return train_loader, test_loader\n",
    "\n",
    "\n",
    "def train(model, n_epochs=200, batch_size=128, seed=0, device=\"cuda:0\"):\n",
    "    start_time = datetime.now()\n",
    "    \n",
    "    model = model.to(device)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimiser = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)\n",
    "    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimiser, T_max=n_epochs)\n",
    "    amp_scaler = torch.cuda.amp.GradScaler()\n",
    "    logs = defaultdict(list)\n",
    "    train_loader, test_loader = get_loaders(batch_size=batch_size)\n",
    "    \n",
    "    set_torch_seed(seed)\n",
    "    for epoch in range(n_epochs):\n",
    "        for batch_X, batch_y in train_loader:\n",
    "            batch_X, batch_y = batch_X.to(device), batch_y.to(device) \n",
    "            with torch.cuda.amp.autocast():\n",
    "                out = model(batch_X)\n",
    "                loss = criterion(out, batch_y)\n",
    "\n",
    "            optimiser.zero_grad()     \n",
    "            amp_scaler.scale(loss).backward()\n",
    "            amp_scaler.step(optimiser)\n",
    "            amp_scaler.update()\n",
    "            \n",
    "        scheduler.step()\n",
    "        logs[\"test_acc\"].append(get_acc(model, test_loader))\n",
    "    logs[\"duration\"] = datetime.now() - start_time\n",
    "    return logs    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "exposed-saturn",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.models import vgg16_bn, resnet50\n",
    "\n",
    "def get_vgg16(n_classes=100):\n",
    "    model = vgg16_bn(pretrained=False)\n",
    "    model.features = model.features[:-1]  # dropping the last maxpool\n",
    "    model.avgpool = nn.AvgPool2d(kernel_size=2)\n",
    "    model.classifier = nn.Sequential(nn.Linear(512, n_classes))\n",
    "    return model\n",
    "\n",
    "def get_resnet50(n_classes=100):\n",
    "    model = resnet50(pretrained=False)\n",
    "    model.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1, bias=False)\n",
    "    model.maxpool = nn.Sequential()\n",
    "    model.fc = nn.Sequential(nn.Linear(2048, n_classes))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "coordinated-limit",
   "metadata": {},
   "outputs": [],
   "source": [
    "models = {\n",
    "    \"MN0p5\": MobileNetV2(width_mult=0.5),\n",
    "    \"MN1\": MobileNetV2(width_mult=1),\n",
    "    \"VGG16\": get_vgg16(),\n",
    "    \"MN2p6\": MobileNetV2(width_mult=2.6),\n",
    "    \"ResNet50\": get_resnet50(),\n",
    "    \"MN3p3\": MobileNetV2(width_mult=3.3),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cloudy-comedy",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from thop import profile\n",
    "\n",
    "model_stats = {\n",
    "    model_name: {\n",
    "        k: v for k, v in zip(\n",
    "            [\"MACs\", \"Params\"], \n",
    "            profile(model.eval(), inputs=(torch.randn(1, 3, 32, 32),))\n",
    "        )\n",
    "    }\n",
    "    for model_name, model in models.items()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "guilty-initial",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axarr = plt.subplots(ncols=2, figsize=(20, 5))\n",
    "plt.suptitle(\"Model Profiling\")\n",
    "\n",
    "axarr[0].set_title(\"# Params per Model\")\n",
    "axarr[0].bar(model_stats.keys(), [s[\"Params\"] for s in model_stats.values()])\n",
    "\n",
    "\n",
    "axarr[1].set_title(\"MACs per Model\")\n",
    "axarr[1].bar(model_stats.keys(), [s[\"MACs\"] for s in model_stats.values()])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "declared-fever",
   "metadata": {},
   "outputs": [],
   "source": [
    "jobs = [\n",
    "    {\"model\": model, \"n_epochs\": 200, \"device\": device} \n",
    "    for model, device in zip(models.values(), [f\"cuda:{i}\" for i in range(len(models))])]\n",
    "\n",
    "res = joblib.Parallel(n_jobs=-1)(joblib.delayed(train)(**job) for job in jobs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "recorded-sperm",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axarr = plt.subplots(ncols=2, figsize=(20, 5))\n",
    "plt.suptitle(\"Model Performance\")\n",
    "\n",
    "axarr[0].set_title(\"Final Accuracy\")\n",
    "axarr[0].bar(models.keys(), [log[\"test_acc\"][-1] for log in res])\n",
    "\n",
    "\n",
    "axarr[1].set_title(\"Training Time\")\n",
    "axarr[1].bar(models.keys(), [log[\"duration\"].seconds / 60**2 for log in res])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "featured-panama",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 7))\n",
    "plt.title(\"Test Acc\")\n",
    "\n",
    "for model_name, logs in zip(models.keys(), res):\n",
    "    plt.plot(logs[\"test_acc\"], label=f\"{model_name}: {round(logs['test_acc'][-1] * 100, 2)}%\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:dev]",
   "language": "python",
   "name": "conda-env-dev-py"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}