code/models/cnn/xception-architecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** <amirhosseinheydari78@gmail.com> - 📍 **Origin:** [mr-pylin/pytorch-workshop](https://github.com/mr-pylin/pytorch-workshop)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Dependencies](#toc1_)    \n",
    "- [Xception](#toc2_)    \n",
    "  - [Custom Xception](#toc2_1_)    \n",
    "    - [Initialize the Model](#toc2_1_1_)    \n",
    "    - [Model Summary](#toc2_1_2_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Dependencies](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch import nn\n",
    "from torchinfo import summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc2_'></a>[Xception](#toc0_)\n",
    "\n",
    "- Xception, short for **Extreme Inception**, was introduced by [*François Chollet*](https://scholar.google.com/citations?user=VfYhf2wAAAAJ&hl=en) from [*Google Research*](https://research.google/) in 2017.\n",
    "- It is based on the paper [Xception: Deep Learning with Depthwise Separable Convolutions](https://openaccess.thecvf.com/content_cvpr_2017/html/Chollet_Xception_Deep_Learning_CVPR_2017_paper.html)\n",
    "- It was trained on the [ImageNet](https://www.image-net.org/) dataset (typically preprocessed with resizing and cropping to 299x299 for Xception) [[ImageNet viewer](https://navigu.net/#imagenet)]\n",
    "- Known for its use of **depthwise separable convolutions** to enhance efficiency and performance\n",
    "- The architecture replaces the **traditional Inception modules** with **depthwise separable convolution** layers used in **Inception-v3**\n",
    "- Designed to optimize the feature extraction process while reducing computational complexity\n",
    "- Used as a baseline for many applications, including image classification and feature extraction tasks\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"../../../assets/images/original/cnn/architectures/xception.svg\" alt=\"xception-architecture.svg\" style=\"width: 100%;\">\n",
    "  <figcaption>Xception Module (Depthwise Separable Convolution)</figcaption>\n",
    "</figure>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc2_1_'></a>[Custom Xception](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SeparableConv2d(nn.Module):\n",
    "    \"\"\"Depthwise Separable Convolution\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_channels: int,\n",
    "        out_channels: int,\n",
    "        kernel_size: int = 3,\n",
    "        stride: int = 1,\n",
    "        padding: int = 1,\n",
    "        bias: bool = False,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, groups=in_channels, bias=bias)\n",
    "        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.depthwise(x)\n",
    "        x = self.pointwise(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class XceptionBlock(nn.Module):\n",
    "    \"\"\"Xception Block with Depthwise Separable Convolutions\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_channels: int,\n",
    "        out_channels: int,\n",
    "        reps: int,\n",
    "        strides: int = 1,\n",
    "        start_with_relu: bool = True,\n",
    "        grow_first: bool = True,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        if out_channels != in_channels or strides != 1:\n",
    "            self.skip = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=strides, bias=False)\n",
    "            self.skip_bn = nn.BatchNorm2d(out_channels)\n",
    "        else:\n",
    "            self.skip = None\n",
    "\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        rep = []\n",
    "        filters = in_channels\n",
    "        if grow_first:\n",
    "            rep.append(self.relu)\n",
    "            rep.append(SeparableConv2d(in_channels, out_channels, 3, stride=1, padding=1))\n",
    "            rep.append(nn.BatchNorm2d(out_channels))\n",
    "            filters = out_channels\n",
    "\n",
    "        for _ in range(reps - 1):\n",
    "            rep.append(self.relu)\n",
    "            rep.append(SeparableConv2d(filters, filters, 3, stride=1, padding=1))\n",
    "            rep.append(nn.BatchNorm2d(filters))\n",
    "\n",
    "        if not grow_first:\n",
    "            rep.append(self.relu)\n",
    "            rep.append(SeparableConv2d(in_channels, out_channels, 3, stride=1, padding=1))\n",
    "            rep.append(nn.BatchNorm2d(out_channels))\n",
    "\n",
    "        if strides != 1:\n",
    "            rep.append(nn.MaxPool2d(3, strides, 1))\n",
    "\n",
    "        self.rep = nn.Sequential(*rep)\n",
    "\n",
    "    def forward(self, x):\n",
    "        skip = x\n",
    "        if self.skip is not None:\n",
    "            skip = self.skip(skip)\n",
    "            skip = self.skip_bn(skip)\n",
    "\n",
    "        x = self.rep(x)\n",
    "        x += skip\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Xception(nn.Module):\n",
    "    \"\"\"Xception Architecture\"\"\"\n",
    "\n",
    "    def __init__(self, num_classes: int = 1000):\n",
    "        super().__init__()\n",
    "        self.entry_flow = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, 3, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "            XceptionBlock(64, 128, reps=2, strides=2, start_with_relu=False, grow_first=True),\n",
    "            XceptionBlock(128, 256, reps=2, strides=2, start_with_relu=True, grow_first=True),\n",
    "            XceptionBlock(256, 728, reps=2, strides=2, start_with_relu=True, grow_first=True),\n",
    "        )\n",
    "\n",
    "        self.middle_flow = nn.Sequential(*[XceptionBlock(728, 728, reps=3, strides=1, start_with_relu=True, grow_first=True) for _ in range(8)])\n",
    "\n",
    "        self.exit_flow = nn.Sequential(\n",
    "            XceptionBlock(728, 1024, reps=2, strides=2, start_with_relu=True, grow_first=False),\n",
    "            SeparableConv2d(1024, 1536, 3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(1536),\n",
    "            nn.ReLU(inplace=True),\n",
    "            SeparableConv2d(1536, 2048, 3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(2048),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.fc = nn.Linear(2048, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.entry_flow(x)\n",
    "        x = self.middle_flow(x)\n",
    "        x = self.exit_flow(x)\n",
    "        x = F.adaptive_avg_pool2d(x, (1, 1))\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc2_1_1_'></a>[Initialize the Model](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Xception()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc2_1_2_'></a>[Model Summary](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summary(model, (1, 3, 299, 299), device=\"cpu\")"
   ]
  }
 ],
 "metadata": {
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "author_name": "Amirhossein Heydari",
  "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.12.3"
  },
  "origin_repo": "https://github.com/mr-pylin/pytorch-workshop"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}