U4.02 - [TALLER] - Implementing convolutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LAB: Implementing convolutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget --no-cache -O init.py -q https://raw.githubusercontent.com/rramosp/2020.deeplearning/master/init.py\n",
    "from init import init; init(force_download=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.0'"
      ]
     },
     "execution_count": 560,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "if 'google.colab' in sys.modules:\n",
    "    print (\"setting tensorflow version in colab\")\n",
    "    %tensorflow_version 2.x\n",
    "    %load_ext tensorboard\n",
    "import tensorflow as tf\n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from time import time\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from local.lib import mlutils\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## observe how we create a `tf.keras.Conv2D` layers and assign it some weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'conv2d_22',\n",
       " 'trainable': True,\n",
       " 'dtype': 'float64',\n",
       " 'filters': 2,\n",
       " 'kernel_size': (3, 3),\n",
       " 'strides': (1, 1),\n",
       " 'padding': 'valid',\n",
       " 'data_format': 'channels_last',\n",
       " 'dilation_rate': (1, 1),\n",
       " 'activation': 'sigmoid',\n",
       " 'use_bias': True,\n",
       " 'kernel_initializer': {'class_name': 'GlorotUniform',\n",
       "  'config': {'seed': None}},\n",
       " 'bias_initializer': {'class_name': 'Zeros', 'config': {}},\n",
       " 'kernel_regularizer': None,\n",
       " 'bias_regularizer': None,\n",
       " 'activity_regularizer': None,\n",
       " 'kernel_constraint': None,\n",
       " 'bias_constraint': None}"
      ]
     },
     "execution_count": 561,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = tf.keras.layers.Conv2D(filters=2, kernel_size=(3,3), activation=\"sigmoid\", dtype=tf.float64)\n",
    "c.get_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 562,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i.shape for i in c.weights]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "initialize its weights (filters) by forcing an evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[TensorShape([3, 3, 1, 2]), TensorShape([2])]"
      ]
     },
     "execution_count": 563,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c(np.random.randint(10, size=(1,7,7,1)).astype(float))\n",
    "[i.shape for i in c.weights]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### let's set by hand some filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.  1. -1.]\n",
      " [-1.  1. -1.]\n",
      " [-1.  1. -1.]]\n",
      "[[-1. -1. -1.]\n",
      " [ 1.  1.  1.]\n",
      " [-1. -1. -1.]]\n"
     ]
    }
   ],
   "source": [
    "f1 = np.r_[[[-1, 1,-1],[-1, 1,-1], [-1, 1,-1]]]\n",
    "f2 = np.r_[[[-1,-1,-1],[ 1, 1, 1], [-1,-1,-1]]]\n",
    "\n",
    "f = np.zeros(c.weights[0].shape)\n",
    "f[:,:,0,0] = f1\n",
    "f[:,:,0,1] = f2\n",
    "print (f[:,:,0,0])\n",
    "print (f[:,:,0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.set_weights([f,np.r_[0,0]]) # keep bias as [0,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check they are set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_22/kernel:0' shape=(3, 3, 1, 2) dtype=float64, numpy=\n",
       " array([[[[-1., -1.]],\n",
       " \n",
       "         [[ 1., -1.]],\n",
       " \n",
       "         [[-1., -1.]]],\n",
       " \n",
       " \n",
       "        [[[-1.,  1.]],\n",
       " \n",
       "         [[ 1.,  1.]],\n",
       " \n",
       "         [[-1.,  1.]]],\n",
       " \n",
       " \n",
       "        [[[-1., -1.]],\n",
       " \n",
       "         [[ 1., -1.]],\n",
       " \n",
       "         [[-1., -1.]]]])>,\n",
       " <tf.Variable 'conv2d_22/bias:0' shape=(2,) dtype=float64, numpy=array([0., 0.])>]"
      ]
     },
     "execution_count": 566,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## and apply the layer to some image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 567,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from skimage import io\n",
    "img = io.imread(\"local/imgs/sample_img.png\")\n",
    "img = img.reshape(1,*img.shape, 1)\n",
    "img = (img-np.min(img))/(np.max(img)-np.min(img))\n",
    "plt.imshow(img[0,:,:,0], cmap=plt.cm.Greys_r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we are using **valid** padding so activations are smaller than original image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 568,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([1, 30, 30, 2])"
      ]
     },
     "execution_count": 568,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "activations = c(img)\n",
    "activations.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 569,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fcb31799f90>"
      ]
     },
     "execution_count": 569,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(activations[0,:,:,0], cmap=plt.cm.Greys_r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fcb316f7990>"
      ]
     },
     "execution_count": 570,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(activations[0,:,:,1], cmap=plt.cm.Greys_r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## observe how activations pixels are computed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(5, 5), dtype=float64, numpy=\n",
       "array([[0.04987202, 0.04863436, 0.04742587, 0.04702942, 0.04644065],\n",
       "       [0.11690962, 0.11199884, 0.10726928, 0.1039408 , 0.09487553],\n",
       "       [0.08045926, 0.0854857 , 0.08899314, 0.08971003, 0.09525451],\n",
       "       [0.14110197, 0.12975986, 0.12106548, 0.12013108, 0.11287809],\n",
       "       [0.19837595, 0.20048595, 0.19978076, 0.19558867, 0.18942595]])>"
      ]
     },
     "execution_count": 571,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "activations[0,:5,:5,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "three first pixels in the first row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.04987202016028013\n",
      "0.04863435579977209\n",
      "0.04742587317756678\n"
     ]
    }
   ],
   "source": [
    "sigmoid = lambda x: 1/(1+np.exp(-x))\n",
    "linear  = lambda x: x\n",
    "print (sigmoid((img[0,:3,:3,:]  * f[:,:,:,1]).sum()))\n",
    "print (sigmoid((img[0,:3,1:4,:] * f[:,:,:,1]).sum()))\n",
    "print (sigmoid((img[0,:3,2:5,:] * f[:,:,:,1]).sum()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observe the shapes of filters and activations to make sense of the indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 32, 32, 1), (3, 3, 1, 2), TensorShape([1, 30, 30, 2]))"
      ]
     },
     "execution_count": 573,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape, f.shape, activations.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TASK 1: Do the convolution by hand in a set of for loops\n",
    "\n",
    "complete the following function. its parameters:\n",
    "\n",
    "- `img`: the images, an array of size [1,y,x,k], where:\n",
    "    - `1`: you will be receiving only one image\n",
    "    - `x`, `y`: the size of the image\n",
    "    - `k` : the number of channels\n",
    "    \n",
    "- `f`: the filters, an array of size [fy,fx,k,n], where:\n",
    "    - `fx`, `fy`: the size of the filters\n",
    "    - `k` : the number of channels (**must be the same as in images**)\n",
    "    - `n`: the number of filters\n",
    "- `activation`: the activation function to use (such as `sigmoid` or `linear` above)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convolution_byhand(img, f, activation=sigmoid):\n",
    "    assert f.shape[2]==img.shape[3]\n",
    "    fy = f.shape[0]\n",
    "    fx = f.shape[1]\n",
    "    r = np.zeros( (1, img.shape[1]-fy+1, img.shape[2]-fx+1, f.shape[3] ))\n",
    "    ... # YOUR CODE HERE\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = convolution_byhand(img, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check your answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(7,3))\n",
    "plt.subplot(121); plt.imshow(r[0,:,:,0], cmap=plt.cm.Greys_r); plt.title(\"your convolution\")\n",
    "plt.subplot(122); plt.imshow(activations[0,:,:,0], cmap=plt.cm.Greys_r); plt.title(\"keras convolution\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(7,3))\n",
    "plt.subplot(121); plt.imshow(r[0,:,:,1], cmap=plt.cm.Greys_r); plt.title(\"your convolution\")\n",
    "plt.subplot(122); plt.imshow(activations[0,:,:,1], cmap=plt.cm.Greys_r); plt.title(\"keras convolution\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2: Do the convolution by hand in 'one shot'\n",
    "\n",
    "We will prepare images to do the convolution with one dot product operation for each filter and each image. This will use more memory but will increase performance.\n",
    "\n",
    "For instance, assume we have the following 1x8x6x1 images (only one image, one channel) and 2x3x1x2 filters (one channel, two filters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = np.r_[[9, 4, 9, 6, 7, 1, 2, 2, 8, 0, 8, 6, 8, 6, 5, 5, 1, 4, 3, 4, 4, 4,\n",
    "             3, 6, 5, 1, 7, 9, 1, 4, 0, 3, 1, 4, 3, 5, 1, 5, 5, 4, 9, 6, 3, 2,\n",
    "             8, 9, 0, 6]].reshape(1,8,6,1)\n",
    "f = np.r_[[6, 7, 8, 5, 2, 9, 6, 4, 9, 7, 9, 7]].reshape(2,3,1,2)\n",
    "print (\"images\", img.shape)\n",
    "print (img[0,:,:,0])\n",
    "print (\"--\")\n",
    "print (\"filters\", f.shape)\n",
    "print (f[:,:,0,0])\n",
    "print (f[:,:,0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### step 1: complete the following function to prepare the images\n",
    "\n",
    "where:\n",
    "\n",
    "- `img` is the images array (assume we only have one image)\n",
    "- `fy` and `fx` are the filter dimensions (2,3 in the example just above)\n",
    "\n",
    "if called with `img` and `f` above you shoud get the following output\n",
    "\n",
    "    > pimg = prepare_img(img, *f.shape[:2])\n",
    "    > pimg\n",
    "    \n",
    "    array([[[[9., 4., 9., 2., 2., 8.],\n",
    "             [4., 9., 6., 2., 8., 0.],\n",
    "             [9., 6., 7., 8., 0., 8.],\n",
    "             [6., 7., 1., 0., 8., 6.]],\n",
    "\n",
    "            [[2., 2., 8., 8., 6., 5.],\n",
    "             [2., 8., 0., 6., 5., 5.],\n",
    "             [8., 0., 8., 5., 5., 1.],\n",
    "             [0., 8., 6., 5., 1., 4.]],\n",
    "\n",
    "            [[8., 6., 5., 3., 4., 4.],\n",
    "             [6., 5., 5., 4., 4., 4.],\n",
    "             [5., 5., 1., 4., 4., 3.],\n",
    "             [5., 1., 4., 4., 3., 6.]],\n",
    "\n",
    "            [[3., 4., 4., 5., 1., 7.],\n",
    "             [4., 4., 4., 1., 7., 9.],\n",
    "             [4., 4., 3., 7., 9., 1.],\n",
    "             [4., 3., 6., 9., 1., 4.]],\n",
    "\n",
    "            [[5., 1., 7., 0., 3., 1.],\n",
    "             [1., 7., 9., 3., 1., 4.],\n",
    "             [7., 9., 1., 1., 4., 3.],\n",
    "             [9., 1., 4., 4., 3., 5.]],\n",
    "\n",
    "            [[0., 3., 1., 1., 5., 5.],\n",
    "             [3., 1., 4., 5., 5., 4.],\n",
    "             [1., 4., 3., 5., 4., 9.],\n",
    "             [4., 3., 5., 4., 9., 6.]],\n",
    "\n",
    "            [[1., 5., 5., 3., 2., 8.],\n",
    "             [5., 5., 4., 2., 8., 9.],\n",
    "             [5., 4., 9., 8., 9., 0.],\n",
    "             [4., 9., 6., 9., 0., 6.]]]])\n",
    "             \n",
    "    > pimg.shape\n",
    "    \n",
    "    (1, 7, 4, 6)\n",
    "    \n",
    "    \n",
    "observe that:\n",
    "\n",
    "- resulting images after convolution with any filter will have size 7x4\n",
    "- the resulting structure `img` has at each pixel (in the 7x4 grid) a vector of six elements associated with it.\n",
    "- this vector is the flattened contents of 2x3x1 image fragment located at that pixel that would by multiplied element by element by any filter located at that pixel during the convolution.\n",
    "- the first row in `pimg` corresponds to the flattened 2x3 fragment located at the top left corner of `img`\n",
    "- the second row contains the 2x3 fragment after shifting one pixel to the right.\n",
    "- the [`np.flatten`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flatten.html) operation will surely be useful for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_img(img, fy, fx):\n",
    "    r = np.zeros( (1, img.shape[1]-fy+1, img.shape[2]-fx+1, fy*fx*img.shape[3] ))\n",
    "    ... # YOUR CODE HERE\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pimg = prepare_img(img, *f.shape[:2])\n",
    "print (pimg.shape)\n",
    "pimg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### step 2: use the prepared images to do the convolution  in a single `.dot` operation\n",
    "\n",
    "\n",
    "complete the following function so that:\n",
    "\n",
    "- you do the convolution of one image (`i`) and one filter (`j`) with one `.dot` operation in **one single line of code**.\n",
    "- you apply the corresponding activation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def oneshot_convolution(pimg, f, activation=sigmoid):\n",
    "    r = np.zeros((*pimg.shape[:-1], f.shape[3]))\n",
    "    for i in range(pimg.shape[0]):\n",
    "        for j in range(f.shape[3]):\n",
    "            r[i,:,:,j] = ... # YOUR CODE HERE\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check your solution against your previous implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k1 = oneshot_convolution(pimg, f, activation=sigmoid)\n",
    "k2 = convolution_byhand(img, f, activation=sigmoid)\n",
    "np.allclose(k1, k2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k1 = oneshot_convolution(pimg, f, activation=linear)\n",
    "k2 = convolution_byhand(img, f, activation=linear)\n",
    "np.allclose(k1, k2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check your solution against keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = tf.keras.layers.Conv2D(filters=f.shape[3], \n",
    "                           kernel_size=f.shape[:2], \n",
    "                           activation=\"linear\", dtype=tf.float64)\n",
    "c(img.astype(float))\n",
    "c.set_weights((f, np.r_[0,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.alltrue(c(img.astype(float)).numpy()==k2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "p37",
   "language": "python",
   "name": "p37"
  },
  "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}