python/notebooks/machine-learning/deep-learning/neural-networks/CNN/Experiments/experiment-with-pooling-and-filters.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Experiment With Pooling & Filters\r\n",
    "\r\n",
    "---\r\n",
    "\r\n",
    "## Built with Python\r\n",
    "\r\n",
    "Created By: Xavier De Carvalho     \r\n",
    "Created On: 04/10/2021 21:09PM     \r\n",
    "Upated By: N/A     \r\n",
    "Updated On: N/A     \r\n",
    "Version: EXPPF0.0.01     \r\n",
    "Reference: https://www.coursera.org/learn/introduction-tensorflow\r\n",
    "\r\n",
    "### Requirements\r\n",
    "\r\n",
    "---\r\n",
    "\r\n",
    "**Packages:**\r\n",
    "1. CV2     \r\n",
    "2. Matplotlib     \r\n",
    "3. NumPy     \r\n",
    "4. SciPy     "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Import packages\r\n",
    "import cv2\r\n",
    "import numpy as np\r\n",
    "from scipy import misc\r\n",
    "i = misc.ascent()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Use PyPlot to draw images\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "\r\n",
    "plt.grid(False)\r\n",
    "plt.gray()\r\n",
    "plt.axis('off')\r\n",
    "plt.imshow(i)\r\n",
    "plt.show()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Get image dimensions to loop over later\r\n",
    "i_transformed = np.copy(i)\r\n",
    "size_x = i_transformed.shape[0]\r\n",
    "size_y = i_transformed.shape[1]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Create 3x3 filter as an array\r\n",
    "'''\r\n",
    "This filter detects edges nicely.\r\n",
    "It creates a convolution that only passes through sharp edges \r\n",
    "and straight lines.\r\n",
    "'''\r\n",
    "\r\n",
    "# Experiment with different values for fun effects\r\n",
    "filter = [[0,1,0], [1,-4,1], [0,1,0]]\r\n",
    "\r\n",
    "# A few more memory filters for fun\r\n",
    "filter = [[-1, -2, -1], [0, 0, 0], [1, 2, 1]]\r\n",
    "# filter = [[-1,0,1],[-2,0,2],[-1,0,1]]\r\n",
    "\r\n",
    "'''\r\n",
    "If all the digits in the filter don't add up to 0 or 1, you\r\n",
    "should probably do a weight to get it to do so.\r\n",
    "For example, if your weights are [1,1,1] [1,2,1] [1,1,1]\r\n",
    "they add up to 10, so you would set a weight of .1 if you want\r\n",
    "to normalize them.\r\n",
    "'''\r\n",
    "weight = 1"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Create a convolution\r\n",
    "'''\r\n",
    "We'll iterate over the image, leaving a 1 pixel margin,\r\n",
    "and multiply out each of the neighbours of the current\r\n",
    "pixel by the value defined in the filter.\r\n",
    "'''\r\n",
    "for x in range(1, size_x-1):\r\n",
    "  for y in range(1, size_y-1):\r\n",
    "    convolution = 0.0\r\n",
    "    convolution += (i[x-1, y-1] * filter[0][0])\r\n",
    "    convolution += (i[x-1, y] * filter[0][1])\r\n",
    "    convolution += (i[x-1, y+1] * filter[0][2])\r\n",
    "    convolution += (i[x, y-1] * filter[1][0])\r\n",
    "    convolution += (i[x, y] * filter[1][1])\r\n",
    "    convolution += (i[x, y+1] * filter[1][2])\r\n",
    "    convolution += (i[x+1, y-1] * filter[2][0])\r\n",
    "    convolution += (i[x+1, y] * filter[2][1])\r\n",
    "    convolution += (i[x+1, y+1] * filter[2][2])\r\n",
    "    convolution *= weight\r\n",
    "    # Manual Relu?\r\n",
    "    if(convolution<0):\r\n",
    "      convolution = 0\r\n",
    "    if(convolution>255):\r\n",
    "      convolution = 255\r\n",
    "    i_transformed[x,y] = convolution"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Plot the image to see the effect\r\n",
    "plt.gray()\r\n",
    "plt.grid(False)\r\n",
    "plt.imshow(i_transformed)\r\n",
    "plt.show()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Use (Max?) pooling\r\n",
    "'''\r\n",
    "This code shows a (2,2) pooling.\r\n",
    "\r\n",
    "It iterates over the image and looks at the pixel and it's immediate\r\n",
    "neighbours to the right, beneath, and right-beneath.\r\n",
    "\r\n",
    "It then takes the largest of them and loads it into the new image.\r\n",
    "\r\n",
    "The new image will then be 1/4 of the size of the original - with\r\n",
    "dimensions on X and Y being halved by this process.\r\n",
    "\r\n",
    "The features are still maintained despite this process.\r\n",
    "'''\r\n",
    "new_x = int(size_x/2)\r\n",
    "new_y = int(size_y/2)\r\n",
    "newImage = np.zeros((new_x, new_y))\r\n",
    "for x in range(0, size_x, 2):\r\n",
    "  for y in range(0, size_y, 2):\r\n",
    "    pixels = []\r\n",
    "    pixels.append(i_transformed[x,y])\r\n",
    "    pixels.append(i_transformed[x+1,y])\r\n",
    "    pixels.append(i_transformed[x,y+1])\r\n",
    "    pixels.append(i_transformed[x+1,y+1])\r\n",
    "    newImage[int(x/2), int(y/2)] = max(pixels)\r\n",
    "\r\n",
    "# Plot the image\r\n",
    "plt.gray()\r\n",
    "plt.grid(False)\r\n",
    "plt.imshow(newImage)\r\n",
    "plt.show()"
   ],
   "outputs": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}