computer-vision/implementing-2d-max-pooling-from-scratch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Implementing 2-D Max-Pooling from Scratch",
      "provenance": [],
      "authorship_tag": "ABX9TyPLvDiR/5MTog6j73A8J/vR"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1h9udIWQpNSd"
      },
      "source": [
        "# Implementing 2-D Max-Pooling from Scratch\n",
        "*By Carlos Santiago Bañón*\n",
        "\n",
        "**Year:** 2020\n",
        "\n",
        "**Technologies:** Python, NumPy\n",
        "\n",
        "**Discipline(s):** Computer Vision\n",
        "\n",
        "**Keywords:** `computer-vision`, `matrices`, `max-pooling`, `2d-max-pooling`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hptJEYs7Tmwk"
      },
      "source": [
        "This notebook presents an implementation of the 2-D max-pooling operation developed from scratch using NumPy.\n",
        "\n",
        "For the purposes of this notebook, the variables `input_mat` and `output_mat` are square matrices and `s` is an integer. The maxpooling operation is computed on `input_mat` using a window of shape $s \\times s$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8AQyTd0BdRP7"
      },
      "source": [
        "## 1. Import Statements\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vZl5mj7XV6XD"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FAQzrnaLUFos"
      },
      "source": [
        "## 2. 2-D Maxpooling Implementation\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nxK6aGSXUIBF"
      },
      "source": [
        "First, the `maxpooling2d()` function is implemented. It takes as input an input matrix `input_mat` and a window size `s`, and outputs `output_mat`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpOEUXT3UQ2X"
      },
      "source": [
        "def maxpooling2d(input_mat, s):\n",
        "  \"\"\"\n",
        "  Perform the 2-D max-pooling operation.\n",
        "\n",
        "  :input_mat: the input matrix.\n",
        "  :s: the window size.\n",
        "  \"\"\"\n",
        "\n",
        "  # Ensure the input is not empty.\n",
        "  if input_mat.size == 0:\n",
        "    raise Exception(\"Error! Empty matrices found.\")\n",
        "\n",
        "  # Ensure the input is a square matrix.\n",
        "  if input_mat.shape[0] != input_mat.shape[1]:\n",
        "    raise Exception(\"Error! The input is not a square matrix.\")\n",
        "\n",
        "  # Ensure the window size is valid.\n",
        "  if s <= 0:\n",
        "    raise Exception(\"Error! The window size is invalid.\")\n",
        "\n",
        "  # Get the size of the input matrix.\n",
        "  input_size = input_mat.shape[0]\n",
        "\n",
        "  # Ensure the kernel is not larger than the input matrix.\n",
        "  if input_size < s:\n",
        "    raise Exception(\"Error! The window is larger than the input.\")\n",
        "\n",
        "  # Set up the output matrix.\n",
        "  output_size = int((input_size - s)/s + 1)\n",
        "  output_mat = np.zeros(shape = (output_size, output_size), dtype=int)\n",
        "\n",
        "  row_offset = 0\n",
        "\n",
        "  for output_row in range(output_size):\n",
        "    col_offset = 0\n",
        "\n",
        "    for output_col in range(output_size):\n",
        "      for row in range(row_offset, row_offset + s):\n",
        "        for col in range(col_offset, col_offset + s):\n",
        "          \n",
        "          # Perform the max-pooling operation.\n",
        "          output_mat[output_row, output_col] = np.amax(input_mat[row_offset:row_offset + s, col_offset:col_offset + s])\n",
        "\n",
        "      col_offset += s\n",
        "    \n",
        "    row_offset += s\n",
        "\n",
        "  return output_mat"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DOk7W2SZVbhE"
      },
      "source": [
        "## 3. Test Cases\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DooOuLjsVcBB"
      },
      "source": [
        "Now, the `maxpooling2d()` function is tested using some given test cases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PQf1umKhVk-S"
      },
      "source": [
        "### 3.1. Test Case #1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Msd09lNZVmND"
      },
      "source": [
        "# Define the input matrix.\n",
        "input_mat = np.array([[1, 2, 1, 2],\n",
        "                      [2, 4, 2, 1],\n",
        "                      [1, 2, 4, 2],\n",
        "                      [2, 1, 2, 1]])\n",
        "\n",
        "# Define the window size.\n",
        "window_size = 2"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YEQsHLOZVoob",
        "outputId": "fc4c11fe-829f-4365-fc98-533db1a04491",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "output_mat = maxpooling2d(input_mat, window_size)\n",
        "print(output_mat)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[4 2]\n",
            " [2 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cRBW8UdaV9N9"
      },
      "source": [
        "### 3.2. Test Case #2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "12ChenuxV-YI"
      },
      "source": [
        "# Define the input matrix.\n",
        "input_mat = np.array([[1, 2, 1, 2, 4, 5],\n",
        "                      [2, 4, 2, 1, 0, 3],\n",
        "                      [1, 2, 4, 2, 4, 5],\n",
        "                      [2, 1, 2, 1, 2, 1],\n",
        "                      [1, 1, 2, 3, 1, 2],\n",
        "                      [1, 1, 2, 3, 1, 2]])\n",
        "\n",
        "# Define the window size.\n",
        "window_size = 2"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EdUajzB3WAZa",
        "outputId": "d045491c-4674-4f6a-f9f6-c5ed08598b8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "output_mat = maxpooling2d(input_mat, window_size)\n",
        "print(output_mat)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[4 2 5]\n",
            " [2 4 5]\n",
            " [1 3 2]]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}