GoogleNet_InceptionNet_implementation_from_Scratch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#Imports"
      ],
      "metadata": {
        "id": "kQ0VWTq0AUo_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VcgRTiP-JrFx"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Generic Convolution Block"
      ],
      "metadata": {
        "id": "g9VrSOxOAk0V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class conv_block(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, **kwargs):\n",
        "    super(conv_block, self).__init__()\n",
        "    self.relu = nn.ReLU()\n",
        "    self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
        "    self.batchnorm = nn.BatchNorm2d(out_channels)\n",
        "  \n",
        "  def forward(self, x):\n",
        "    return self.relu(self.batchnorm(self.conv(x)))\n"
      ],
      "metadata": {
        "id": "VysQ2dbrJ-Dd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Defining Generic Inception Block"
      ],
      "metadata": {
        "id": "2ZIJqw62ArhD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Inception_block(nn.Module):\n",
        "  def __init__(self, in_channels, out_1x1, red_3x3, out_3x3, red_5x5, out_5x5, out_1x1pool):\n",
        "    super(Inception_block, self).__init__()\n",
        "    \n",
        "    self.branch1 = conv_block(in_channels, out_1x1, kernel_size=1)\n",
        "\n",
        "    self.branch2 = nn.Sequential(\n",
        "        conv_block(in_channels, red_3x3, kernel_size=1),\n",
        "        conv_block(red_3x3, out_3x3, kernel_size=3, padding = 1),\n",
        "    )\n",
        "\n",
        "    self.branch3 = nn.Sequential(\n",
        "        conv_block(in_channels, red_5x5, kernel_size = 1),\n",
        "        conv_block(red_5x5, out_5x5, kernel_size = 5, padding = 2)\n",
        "    )\n",
        "\n",
        "    self.branch4 = nn.Sequential(\n",
        "        nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
        "        conv_block(in_channels, out_1x1pool, kernel_size=1)\n",
        "    )\n",
        "\n",
        "  def forward(self, x):\n",
        "    return torch.cat(\n",
        "        [self.branch1(x), self.branch2(x), self.branch3(x), self.branch4(x)],1\n",
        "    )"
      ],
      "metadata": {
        "id": "cpAL2So1LrTd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Auxiliary Inception Block for Auxiliary Prediction"
      ],
      "metadata": {
        "id": "-icD6mNdA0vu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class InceptionAux(nn.Module):\n",
        "  def __init__(self, in_channels, num_classes):\n",
        "    super(InceptionAux, self).__init__()\n",
        "\n",
        "    self.relu = nn.ReLU()\n",
        "    self.dropout = nn.Dropout(p=0.7)\n",
        "    self.pool = nn.AvgPool2d(kernel_size=5, stride=3)\n",
        "    self.conv = conv_block(in_channels, 128, kernel_size=1)\n",
        "    self.fc1 = nn.Linear(2048, 1024)\n",
        "    self.fc2 = nn.Linear(1024, num_classes)\n",
        "  \n",
        "  def forward(self, x):\n",
        "    x = self.pool(x)\n",
        "    x = self.conv(x)\n",
        "    x = x.reshape(x.shape[0], -1)\n",
        "    x = self.relu(self.fc1(x))\n",
        "    x = self.dropout(x)\n",
        "    x = self.fc2(x)\n",
        "    return x"
      ],
      "metadata": {
        "id": "oiiUWx92O2SY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#The InceptionNet Architecture"
      ],
      "metadata": {
        "id": "viI36wnZA8hC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class InceptionNet(nn.Module):\n",
        "  def __init__(self, aux_logits=True, num_classes=1000):\n",
        "    super(InceptionNet, self).__init__()\n",
        "    self.aux_logits = aux_logits\n",
        "\n",
        "    self.conv1 = conv_block(\n",
        "            in_channels=3,\n",
        "            out_channels=64,\n",
        "            kernel_size=7,\n",
        "            stride=2,\n",
        "            padding=3,\n",
        "        )\n",
        "    \n",
        "    self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "    self.conv2 = conv_block(64, 192, kernel_size=3, stride=1, padding=1)\n",
        "    self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "\n",
        "    self.inception3a = Inception_block(192, 64, 96, 128, 16, 32, 32)\n",
        "    self.inception3b = Inception_block(256, 128, 128, 192, 32, 96, 64)\n",
        "    self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "\n",
        "    self.inception4a = Inception_block(480, 192, 96, 208, 16, 48, 64)\n",
        "    self.inception4b = Inception_block(512, 160, 112, 224, 24, 64, 64)\n",
        "    self.inception4c = Inception_block(512, 128, 128, 256, 24, 64, 64)\n",
        "    self.inception4d = Inception_block(512, 112, 144, 288, 32, 64, 64)\n",
        "    self.inception4e = Inception_block(528, 256, 160, 320, 32, 128, 128)\n",
        "    self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "\n",
        "    self.inception5a = Inception_block(832, 256, 160, 320, 32, 128, 128)\n",
        "    self.inception5b = Inception_block(832, 384, 192, 384, 48, 128, 128)\n",
        "\n",
        "    self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)\n",
        "    self.dropout = nn.Dropout(p=0.4)\n",
        "    self.fc1 = nn.Linear(1024, num_classes)\n",
        "\n",
        "    if self.aux_logits:\n",
        "        self.aux1 = InceptionAux(512, num_classes)\n",
        "        self.aux2 = InceptionAux(528, num_classes)\n",
        "    else:\n",
        "        self.aux1 = self.aux2 = None\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.conv1(x)\n",
        "    x = self.maxpool1(x)\n",
        "    x = self.conv2(x)\n",
        "    x = self.maxpool2(x)\n",
        "\n",
        "    x = self.inception3a(x)\n",
        "    x = self.inception3b(x)\n",
        "    x = self.maxpool3(x)\n",
        "\n",
        "    x = self.inception4a(x)\n",
        "\n",
        "    # Auxiliary Softmax classifier 1\n",
        "    if self.aux_logits and self.training:\n",
        "        aux1 = self.aux1(x)\n",
        "\n",
        "    x = self.inception4b(x)\n",
        "    x = self.inception4c(x)\n",
        "    x = self.inception4d(x)\n",
        "\n",
        "    # Auxiliary Softmax classifier 2\n",
        "    if self.aux_logits and self.training:\n",
        "        aux2 = self.aux2(x)\n",
        "\n",
        "    x = self.inception4e(x)\n",
        "    x = self.maxpool4(x)\n",
        "    x = self.inception5a(x)\n",
        "    x = self.inception5b(x)\n",
        "    x = self.avgpool(x)\n",
        "    x = x.reshape(x.shape[0], -1)\n",
        "    x = self.dropout(x)\n",
        "    x = self.fc1(x)\n",
        "\n",
        "    if self.aux_logits and self.training:\n",
        "        return aux1, aux2, x\n",
        "    else:\n",
        "        return x\n",
        "  "
      ],
      "metadata": {
        "id": "ASzYfJUUPrAE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Testing the Architecture"
      ],
      "metadata": {
        "id": "U1JWetRrBFKK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "BATCH_SIZE = 5\n",
        "x = torch.randn(BATCH_SIZE, 3, 224, 224)\n",
        "model = InceptionNet(aux_logits=True, num_classes=1000)\n",
        "print(model(x)[2].shape)\n",
        "assert model(x)[2].shape == torch.Size([BATCH_SIZE, 1000])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qh5Q5WXgReKX",
        "outputId": "8c8c8695-8cfb-41cb-f97f-7ce9dff3fc5a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([5, 1000])\n"
          ]
        }
      ]
    }
  ]
}