2_Adapting_Grad-CAM_to_work_with_functional_Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grad-CAM for Models with mixed layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tensorboard.notebook extension is already loaded. To reload it, use:\n",
      "  %reload_ext tensorboard.notebook\n"
     ]
    }
   ],
   "source": [
    "%load_ext tensorboard.notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making the images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_zero_template = np.zeros((32,32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_zero_template = np.array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13a66b9b0>"
      ]
     },
     "execution_count": 94,
     "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(class_zero_template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_one_template = np.array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 1., 1., 0., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
    "                                [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13b32dd68>"
      ]
     },
     "execution_count": 96,
     "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(class_one_template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 16)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_one_template.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we introduce some 'random noise', essentially switching a fixed number of pixels within our 16x16 map to 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13b7b0320>"
      ]
     },
     "execution_count": 98,
     "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": [
    "def generate_noise(input_img, num_of_pixels):\n",
    "    idx1_arr = np.random.randint((input_img.shape[0]-1), size=num_of_pixels)\n",
    "    idx2_arr = np.random.randint((input_img.shape[1]-1), size=num_of_pixels)\n",
    "    out_img = np.copy(input_img)\n",
    "    for i, j in zip(idx1_arr, idx2_arr):\n",
    "        out_img[i][j] = 1\n",
    "    return out_img\n",
    "\n",
    "def image_generator(input_img, pixel_noise):\n",
    "    while True:\n",
    "        yield generate_noise(input_img, pixel_noise)\n",
    "\n",
    "plt.imshow(generate_noise(class_one_template, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating data for the training and validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_zero_generator = image_generator(class_zero_template, 3)\n",
    "class_one_generator = image_generator(class_one_template, 3)\n",
    "\n",
    "# initialize those as None to make conditionals work in the loops\n",
    "class_zero_train = None\n",
    "class_zero_test = None\n",
    "class_one_train = None\n",
    "class_one_test = None\n",
    "\n",
    "# roughly 80/20 split\n",
    "train_size = 64\n",
    "test_size = 13\n",
    "for i in range(train_size):\n",
    "    if class_zero_train is not None:\n",
    "        class_zero_train = np.append(class_zero_train, np.expand_dims(next(class_zero_generator), axis=0), axis=0)\n",
    "    else:\n",
    "        class_zero_train = np.expand_dims(next(class_zero_generator), axis=0)\n",
    "    if class_one_train is not None:\n",
    "        class_one_train = np.append(class_one_train, np.expand_dims(next(class_one_generator), axis=0), axis=0)\n",
    "    else: \n",
    "        class_one_train = np.expand_dims(next(class_one_generator), axis=0)\n",
    "\n",
    "class_zero_labels = np.zeros(train_size)\n",
    "class_one_labels = np.ones(train_size)\n",
    "\n",
    "x_train = np.append(class_zero_train, class_one_train, axis=0)\n",
    "y_train = np.append(class_zero_labels, class_one_labels)\n",
    "    \n",
    "for i in range(test_size):\n",
    "    if class_zero_test is not None:\n",
    "        class_zero_test = np.append(class_zero_test, np.expand_dims(next(class_zero_generator), axis=0), axis=0)\n",
    "    else:\n",
    "        class_zero_test = np.expand_dims(next(class_zero_generator), axis=0)\n",
    "    if class_one_test is not None:\n",
    "        class_one_test = np.append(class_one_test, np.expand_dims(next(class_one_generator), axis=0), axis=0)\n",
    "    else:\n",
    "        class_one_test = np.expand_dims(next(class_one_generator), axis=0)\n",
    "    \n",
    "class_zero_labels = np.zeros(test_size)\n",
    "class_one_labels = np.ones(test_size)\n",
    "\n",
    "x_test = np.append(class_zero_test, class_one_test, axis=0)\n",
    "y_test = np.append(class_zero_labels, class_one_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 16, 16)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128,)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26, 16, 16)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26,)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unison_shuffled_copies(a, b):\n",
    "    assert len(a) == len(b)\n",
    "    p = np.random.permutation(len(a))\n",
    "    return a[p], b[p]\n",
    "\n",
    "# taken from: https://stackoverflow.com/questions/4601373/better-way-to-shuffle-two-numpy-arrays-in-unison  mrtw's answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train = unison_shuffled_copies(x_train, y_train)\n",
    "x_test, y_test = unison_shuffled_copies(x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's try to visualize a few examples from the training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 16, 16)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_something(dataset, labels, index):\n",
    "    plt.imshow(x_train[index,:,:])\n",
    "    print(\"label for this image is: {}\".format(labels[index]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label for this image is: 0.0\n"
     ]
    },
    {
     "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": [
    "show_something(x_train, y_train, np.random.randint(len(y_train)-1))  # this shows a random image from the training dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we expand dimensions to stay consistent with NWHC, so we need to expand axis -1 (last one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 16, 16, 1)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.expand_dims(x_train, axis=-1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = np.expand_dims(x_train, axis=-1)\n",
    "y_train = np.expand_dims(y_train, axis=-1)\n",
    "\n",
    "x_test = np.expand_dims(x_test, axis=-1)\n",
    "y_test = np.expand_dims(y_test, axis=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a model in which we will redirect output to two different conv layers and concatenate output right before feeding it into dense layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.keras.layers.Input(shape=(16,16,1))\n",
    "x1 = tf.keras.layers.Conv2D(64, (3, 3), input_shape=(16, 16, 1), activation='relu')(x)\n",
    "x1 = tf.keras.layers.MaxPool2D(pool_size=(2,2), padding='same')(x1)\n",
    "x2 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x)\n",
    "x2 = tf.keras.layers.MaxPool2D(pool_size=(2,2), padding='same')(x2)\n",
    "x1 = tf.keras.layers.Flatten()(x1)\n",
    "x2 = tf.keras.layers.Flatten()(x2)\n",
    "y = tf.keras.layers.Concatenate()([x1, x2])\n",
    "y = tf.keras.layers.Dense(16, activation='relu')(y)\n",
    "y = tf.keras.layers.Dense(1, activation='sigmoid')(y)\n",
    "model = tf.keras.models.Model(inputs=x, outputs=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_4\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_8 (InputLayer)            [(None, 16, 16, 1)]  0                                            \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_13 (Conv2D)              (None, 14, 14, 64)   640         input_8[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_14 (Conv2D)              (None, 14, 14, 64)   640         input_8[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling2d_12 (MaxPooling2D) (None, 7, 7, 64)     0           conv2d_13[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling2d_13 (MaxPooling2D) (None, 7, 7, 64)     0           conv2d_14[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "flatten_12 (Flatten)            (None, 3136)         0           max_pooling2d_12[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "flatten_13 (Flatten)            (None, 3136)         0           max_pooling2d_13[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_2 (Concatenate)     (None, 6272)         0           flatten_12[0][0]                 \n",
      "                                                                 flatten_13[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "dense_5 (Dense)                 (None, 16)           100368      concatenate_2[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "dense_6 (Dense)                 (None, 1)            17          dense_5[0][0]                    \n",
      "==================================================================================================\n",
      "Total params: 101,665\n",
      "Trainable params: 101,665\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'concatenate_2'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.layers[7].name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x11189e908>, <tensorflow.python.keras.engine.base_layer.Node object at 0x13b2d8c88>]\n",
      "0\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b8a7da0>]\n",
      "1\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b6e0630>]\n",
      "2\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b96e048>]\n",
      "3\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b6f66d8>]\n",
      "4\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b6f67b8>]\n",
      "5\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b6f67b8>]\n",
      "6\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b8a7470>]\n",
      "7\n",
      "[<tensorflow.python.keras.engine.base_layer.Node object at 0x13b5c8710>]\n",
      "8\n",
      "[]\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(model.layers)):\n",
    "    print(model.get_layer(model.layers[i].name).outbound_nodes)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'outbound_layer': 'input_8',\n",
       " 'inbound_layers': [],\n",
       " 'node_indices': [],\n",
       " 'tensor_indices': []}"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_layer(model.layers[0].name).inbound_nodes[0].get_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.001, momentum=0.1), loss='binary_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 128 samples, validate on 26 samples\n",
      "Epoch 1/20\n",
      "128/128 [==============================] - 0s 4ms/sample - loss: 0.6858 - accuracy: 0.5078 - val_loss: 0.6874 - val_accuracy: 0.5000\n",
      "Epoch 2/20\n",
      "128/128 [==============================] - 0s 375us/sample - loss: 0.6830 - accuracy: 0.5078 - val_loss: 0.6845 - val_accuracy: 0.5000\n",
      "Epoch 3/20\n",
      "128/128 [==============================] - 0s 541us/sample - loss: 0.6800 - accuracy: 0.5156 - val_loss: 0.6814 - val_accuracy: 0.5000\n",
      "Epoch 4/20\n",
      "128/128 [==============================] - 0s 388us/sample - loss: 0.6767 - accuracy: 0.5469 - val_loss: 0.6782 - val_accuracy: 0.5000\n",
      "Epoch 5/20\n",
      "128/128 [==============================] - 0s 369us/sample - loss: 0.6735 - accuracy: 0.5625 - val_loss: 0.6751 - val_accuracy: 0.5000\n",
      "Epoch 6/20\n",
      "128/128 [==============================] - 0s 454us/sample - loss: 0.6704 - accuracy: 0.6016 - val_loss: 0.6722 - val_accuracy: 0.5385\n",
      "Epoch 7/20\n",
      "128/128 [==============================] - 0s 420us/sample - loss: 0.6675 - accuracy: 0.6328 - val_loss: 0.6695 - val_accuracy: 0.5769\n",
      "Epoch 8/20\n",
      "128/128 [==============================] - 0s 446us/sample - loss: 0.6649 - accuracy: 0.6641 - val_loss: 0.6669 - val_accuracy: 0.6154\n",
      "Epoch 9/20\n",
      "128/128 [==============================] - 0s 421us/sample - loss: 0.6623 - accuracy: 0.6953 - val_loss: 0.6644 - val_accuracy: 0.7692\n",
      "Epoch 10/20\n",
      "128/128 [==============================] - 0s 443us/sample - loss: 0.6599 - accuracy: 0.7969 - val_loss: 0.6620 - val_accuracy: 0.8077\n",
      "Epoch 11/20\n",
      "128/128 [==============================] - 0s 621us/sample - loss: 0.6576 - accuracy: 0.8281 - val_loss: 0.6597 - val_accuracy: 0.9615\n",
      "Epoch 12/20\n",
      "128/128 [==============================] - 0s 770us/sample - loss: 0.6554 - accuracy: 0.8750 - val_loss: 0.6575 - val_accuracy: 0.9615\n",
      "Epoch 13/20\n",
      "128/128 [==============================] - 0s 705us/sample - loss: 0.6533 - accuracy: 0.9297 - val_loss: 0.6554 - val_accuracy: 0.9615\n",
      "Epoch 14/20\n",
      "128/128 [==============================] - 0s 607us/sample - loss: 0.6513 - accuracy: 0.9453 - val_loss: 0.6533 - val_accuracy: 0.9615\n",
      "Epoch 15/20\n",
      "128/128 [==============================] - 0s 765us/sample - loss: 0.6492 - accuracy: 0.9609 - val_loss: 0.6512 - val_accuracy: 0.9615\n",
      "Epoch 16/20\n",
      "128/128 [==============================] - 0s 604us/sample - loss: 0.6473 - accuracy: 0.9688 - val_loss: 0.6492 - val_accuracy: 0.9615\n",
      "Epoch 17/20\n",
      "128/128 [==============================] - 0s 537us/sample - loss: 0.6452 - accuracy: 0.9766 - val_loss: 0.6472 - val_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "128/128 [==============================] - 0s 395us/sample - loss: 0.6433 - accuracy: 0.9922 - val_loss: 0.6452 - val_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "128/128 [==============================] - 0s 715us/sample - loss: 0.6413 - accuracy: 0.9922 - val_loss: 0.6431 - val_accuracy: 1.0000\n",
      "Epoch 20/20\n",
      "128/128 [==============================] - 0s 757us/sample - loss: 0.6392 - accuracy: 0.9922 - val_loss: 0.6411 - val_accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x13b985978>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x=x_train,\n",
    "          y=y_train, \n",
    "          epochs=20, \n",
    "          validation_data=(x_test, y_test), \n",
    "          callbacks=[tensorboard_callback])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's start tracing back the gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First we need a sample image to make predictions on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = next(image_generator(class_zero_template, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13c6e96d8>"
      ]
     },
     "execution_count": 233,
     "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(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 16, 16, 1)"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im.reshape(1, *im.shape, 1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.45783487]], dtype=float32)"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(im.reshape(1, *im.shape, 1))  # prediction value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: id=9113, shape=(1, 1), dtype=float32, numpy=array([[0.45783487]], dtype=float32)>"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(tf.cast(im.reshape(1, *im.shape, 1), tf.float32))  # also a prediction value but using `call` instead of `predict`\n",
    "# this returns a tf.Tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We can use GradientTape to trace gradient values\n",
    "Let's calculate the MSE for this particular predition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.GradientTape() as tape:\n",
    "    error = model(tf.cast(im.reshape(1, *im.shape, 1), tf.float32)) - 0 # NOT model.predict(x) - y\n",
    "    loss_value = tf.reduce_mean(tf.square(error))\n",
    "gradients = tape.gradient(loss_value, model.variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`model.variables` is where kernels and biases live"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['conv2d_13/kernel:0', 'conv2d_13/bias:0', 'conv2d_14/kernel:0', 'conv2d_14/bias:0', 'dense_5/kernel:0', 'dense_5/bias:0', 'dense_6/kernel:0', 'dense_6/bias:0']\n"
     ]
    }
   ],
   "source": [
    "print([i.name for i in model.variables])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create thus a list of all kernels and biases associated with any **convolutional layers** we have in our model and put it in a list (`A_k`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two outbound nodes of the input layer point to two different convolutional layers,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'outbound_layer': 'conv2d_13',\n",
       " 'inbound_layers': 'input_8',\n",
       " 'node_indices': 0,\n",
       " 'tensor_indices': 0}"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_layer(model.layers[0].name).outbound_nodes[0].get_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'outbound_layer': 'conv2d_14',\n",
       " 'inbound_layers': 'input_8',\n",
       " 'node_indices': 0,\n",
       " 'tensor_indices': 0}"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_layer(model.layers[0].name).outbound_nodes[1].get_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [],
   "source": [
    "class tuple_dict(dict):\n",
    "    def __init__(self, *args):\n",
    "        dict.__init__(self, args)\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        if type(i) == tuple:\n",
    "            lst = []\n",
    "            for n in i:\n",
    "                lst.append(dict.__getitem__(self, n))\n",
    "            return lst\n",
    "        elif type(i) == str:\n",
    "            return dict.__getitem__(self, i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_test = tuple_dict()\n",
    "d_test['a']=1\n",
    "d_test['b']=2\n",
    "d_test['c']=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_test[('a', 'b')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_outputs_at_each_layer(model, input_image, layer_type):\n",
    "    \"\"\"\n",
    "    make it robust to weird connections between layers\n",
    "    \"\"\"\n",
    "    with tf.GradientTape() as tape:\n",
    "        outputs = tuple_dict()\n",
    "        current_output = model.get_layer(model.layers[0].name)(input_image)\n",
    "        outputs[model.layers[0].name] = current_output\n",
    "        restricted_outputs = []\n",
    "        for i in model.layers[:]:\n",
    "    #         out = model.get_layer(i.name)(out)\n",
    "    # input points to two outbound nodes: two different conv layers\n",
    "    # inbound_node in config gets the input node\n",
    "    # outbound_node in config points to the operation\n",
    "    # so in our case inbound: input layer, outbound: conv layer\n",
    "    # and the other node is: input layer, second conv layer\n",
    "    # try using node objects as dict keys where you record outputs\n",
    "    # change outputs list into a dict\n",
    "            outbound_nodes = model.get_layer(i.name).outbound_nodes\n",
    "            inbound_nodes = model.get_layer(i.name).inbound_nodes\n",
    "            for n in outbound_nodes:\n",
    "                config = n.get_config()\n",
    "#                 outputs[config['outbound_layer']] = model.get_layer(config['outbound_layer'])(model.get_layer(config['inbound_layers']))\n",
    "                #(outputs[config['inbound_layers']]))\n",
    "#                 print(config['inbound_layers'])\n",
    "#                 print(config['outbound_layer'])\n",
    "#                 if type(config['outbound_layer']) == list:\n",
    "#                     for m in config['outbound_layer']:\n",
    "#                         outputs[m] = model.get_layer(m)(outputs[config['inbound_layers']])\n",
    "#                 elif type(config['inbound_layers']) == list:\n",
    "#                     for m in config['inbound_layers']:\n",
    "#                         outputs[config['outbound_layer']] = model.get_layer(config['outbound_layer'])(outputs[m])\n",
    "#                 else:\n",
    "                \n",
    "#                 def inner(outputs, ibl, obl):\n",
    "#                     if type(ibl) == tuple:\n",
    "#                     if type(obl) == tuple:\n",
    "#                         for i in outputs[ibl]\n",
    "#                         outputs[obl] = model.get_layer(obl)(outputs[ibl])\n",
    "#                     else:\n",
    "#                         outputs[obl] = model.get_layer(obl)(outputs[ibl])\n",
    "#                     else:\n",
    "#                         outputs[obl] = model.get_layer(obl)(outputs[ibl])\n",
    "#                     return outputs\n",
    "                if type(config['outbound_layer']) == list:\n",
    "                    obl = tuple(config['outbound_layer'])\n",
    "                else:\n",
    "                    obl = config['outbound_layer']\n",
    "                if type(config['inbound_layers']) == list:\n",
    "                    ibl = tuple(config['inbound_layers'])\n",
    "                else:\n",
    "                    ibl = config['inbound_layers']\n",
    "                out = model.get_layer(obl)(outputs[ibl])\n",
    "                outputs[obl] = out\n",
    "                if layer_type in i.name:\n",
    "                    restricted_outputs.append(outputs[obl])\n",
    "    gradients = tape.gradient(out, restricted_outputs)\n",
    "    return restricted_outputs, gradients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_k, dy_dA_k = get_outputs_at_each_layer(model, tf.cast(im.reshape(1, *im.shape, 1), tf.float32), 'conv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 7, 64)\n",
      "(1, 7, 7, 64)\n"
     ]
    }
   ],
   "source": [
    "for i in dy_dA_k:\n",
    "    print(i.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 7, 64)\n",
      "(1, 7, 7, 64)\n"
     ]
    }
   ],
   "source": [
    "for i in A_k:\n",
    "    print(i.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A_k = [i for i in model.variables if (('conv' in i.name) and ('kernel' in i.name))]\n",
    "# print([i.name for i in A_k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with tf.GradientTape() as g:\n",
    "#     error = model(tf.cast(im.reshape(1, *im.shape, 1), tf.float32)) - 0 # NOT model.predict(x) - y\n",
    "#     loss_value = tf.reduce_mean(tf.square(error))\n",
    "# dy_dA_k = g.gradient(loss_value, A_k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with tf.GradientTape() as tape:\n",
    "#     error = model(tf.cast(im.reshape(1, *im.shape, 1), tf.float32)) - 0 # NOT model.predict(x) - y\n",
    "#     loss_value = tf.reduce_mean(tf.square(error))\n",
    "# gradients = tape.gradient(loss_value, model.variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with tf.GradientTape() as g:\n",
    "#     error = model(tf.cast(im.reshape(1, *im.shape, 1), tf.float32)) # NOT model.predict(x) - y\n",
    "#     feature_maps = get_outputs_at_each_layer(model, tf.cast(im.reshape(1, *im.shape, 1), tf.float32), 'conv')\n",
    "    \n",
    "# dy_dA_k = g.gradient(loss_value, A_k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 7, 64)\n"
     ]
    }
   ],
   "source": [
    "print(dy_dA_k[0].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grad-CAM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having the derivative of loss function with respect to each conv kernel, we can now try to implement Grad-CAM from scratch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The process is as follows**:\n",
    "\n",
    "1. Compute gradient of scores for class `c` with respect to collected feature maps of a convolutional layer.\n",
    "    \n",
    "    $\\large \\frac{(\\delta y^c)}{(\\delta A^k)}$\n",
    "    \n",
    "2. Run Global Average Pooling on that gradient to obtain importance weights of each feature map.\n",
    "\n",
    "    $\\large \\alpha^c_k = \\frac{1}{Z} \\Sigma_{i} \\Sigma_{j} \\frac{(\\delta y^c)}{(\\delta A^k)}$\n",
    "    \n",
    "3. Compute Grad-CAM $L^c$ function\n",
    "\n",
    "    $\\large L^c = ReLU(\\Sigma_{k} \\alpha^c_k A^k)$\n",
    "    \n",
    "    Here we use the ReLU to look only at pixels whose value actually contribute to the increase of $y^c$ scores\n",
    "    \n",
    "4. We upsample $L^c$ using bilinear interpolation method...\n",
    "\n",
    "5. ... and finally perform pixel-wise multiplication with the guided backpropagation results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1, 64)"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gap = [tf.keras.layers.GlobalAveragePooling2D()(i) for i in dy_dA_k]\n",
    "np.array(gap).shape  # thus each alpha_k is an element of the 'gap' list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 7, 64)\n"
     ]
    }
   ],
   "source": [
    "print(dy_dA_k[0].shape)\n",
    "# print(dy_dA_k[1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we have two gradient tensors, first corresponding to the first layer which had `3x3` kernel size and the second corresponding to the `1x1` kernel. The last dimension is the actual number of feature maps within the tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 7, 64)\n"
     ]
    }
   ],
   "source": [
    "print(A_k[0].shape)\n",
    "# print(A_k[1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shapes of the A_k elements are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([1, 7, 7, 64])"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.math.multiply(dy_dA_k[0], A_k[0]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_c_0 = tf.keras.layers.ReLU()(tf.math.reduce_sum(tf.math.multiply(dy_dA_k[0], A_k[0]), axis=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([1, 7, 7])"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_c_0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13c6b8828>"
      ]
     },
     "execution_count": 259,
     "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(L_c_0[0, :, :], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def unpack_maps(A_k, layer_idx):\n",
    "#     new_shape = list(A_k[layer_idx].shape)\n",
    "#     new_shape = [new_shape[-1]] + new_shape[:-1]\n",
    "#     yield tf.reshape(A_k[layer_idx], new_shape).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.imshow(test[1, 1, :, :], cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We pick one of three saliency maps and scale it down to original image size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = L_c_0.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 7, 7)"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upsample_array(arr, final_shape):\n",
    "    integer_div= []\n",
    "    modulo = []\n",
    "    out = np.copy(arr)\n",
    "    assert len(final_shape) == len(arr.shape), \"Output shape has to have same number of dims!\"\n",
    "    for i in range(len(arr.shape)):\n",
    "        integer_div.append(final_shape[i]//arr.shape[i])\n",
    "        modulo.append(final_shape[i]%arr.shape[i])\n",
    "    if len(modulo) != 0:\n",
    "        integer_div = [i+1 for i in integer_div]\n",
    "    for idx, i in enumerate(integer_div):\n",
    "        out = out.repeat(i, axis=idx)\n",
    "    if out.shape != final_shape:\n",
    "        start = [None for i in range(len(final_shape))]\n",
    "        end = final_shape\n",
    "        zipped = tuple(zip(start, final_shape))\n",
    "        slices = tuple([slice(i[0], i[1]) for i in zipped])\n",
    "        out = out[slices]\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 16)"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upsample_array(test[0, :, :], (16, 16)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 7, 7)"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 16)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_test = upsample_array(test[0, :, :], (16, 16))\n",
    "test_test = Image.fromarray(test_test)\n",
    "np.array(test_test).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13c8646a0>"
      ]
     },
     "execution_count": 268,
     "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(test_test, cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13cae2fd0>"
      ]
     },
     "execution_count": 269,
     "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(im*test_test, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we can make a heatmap of features that have been detected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "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": [
    "plt_im1 = plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\n",
    "\n",
    "plt_im2 = plt.imshow(test_test*im, cmap=plt.cm.hot, alpha=.9, interpolation='bilinear')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}