├── CAM_MNIST.ipynb
├── GradCAM_MNIST.ipynb
├── GuidedBackprop_MNIST.ipynb
├── README.md
├── cam_max.png
├── gradcam.png
├── guided_backprop_practice
    ├── Guided_Backpropagation.ipynb
    ├── Guidedbackprop.png
    └── guided_backprop.jpg
├── hook_practice
    ├── .ipynb_checkpoints
    │   └── Module_Hook_Practice-checkpoint.ipynb
    ├── Module_Hook_Practice.ipynb
    ├── Variable_Hook_Practice.ipynb
    └── asset
    │   └── hook.jpeg
└── 최건호_GoogleColab_GradCAM.pdf


/CAM_MNIST.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# CAM_MNIST\n",
  8 |     "\n",
  9 |     "- How to register a hook at targeted layer of network\n",
 10 |     "- http://pytorch.org/docs/0.3.1/autograd.html?highlight=register_hook#torch.autograd.Variable.register_hook\n",
 11 |     "\n",
 12 |     "## 1) Import required Libraries"
 13 |    ]
 14 |   },
 15 |   {
 16 |    "cell_type": "code",
 17 |    "execution_count": 1,
 18 |    "metadata": {
 19 |     "collapsed": true
 20 |    },
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os\n",
 24 |     "\n",
 25 |     "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
 26 |     "\n",
 27 |     "import numpy as np\n",
 28 |     "import torch\n",
 29 |     "import torch.nn as nn\n",
 30 |     "import torch.optim as optim\n",
 31 |     "import torch.nn.init as init\n",
 32 |     "import torchvision.datasets as dset\n",
 33 |     "import torchvision.transforms as transforms\n",
 34 |     "from torch.utils.data import DataLoader\n",
 35 |     "from torch.autograd import Variable\n",
 36 |     "\n",
 37 |     "import torch.nn.functional as F\n",
 38 |     "from skimage.transform import resize\n",
 39 |     "import matplotlib.pyplot as plt\n",
 40 |     "%matplotlib inline  \n",
 41 |     "\n",
 42 |     "import random"
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "markdown",
 47 |    "metadata": {},
 48 |    "source": [
 49 |     "## 2) Hyperparameters"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 2,
 55 |    "metadata": {
 56 |     "collapsed": true
 57 |    },
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "batch_size = 256\n",
 61 |     "learning_rate = 0.0001\n",
 62 |     "num_epoch = 10"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": 3,
 68 |    "metadata": {
 69 |     "collapsed": true
 70 |    },
 71 |    "outputs": [],
 72 |    "source": [
 73 |     "def one_sided_padding(x):\n",
 74 |     "    rand1 = random.randrange(0,15,3)\n",
 75 |     "    rand2 = random.randrange(0,15,3)\n",
 76 |     "\n",
 77 |     "    zero = np.zeros(shape=[28,28,1])\n",
 78 |     "    zero[rand1:rand1+12,rand2:rand2+12,:]=np.asarray(x).reshape(12,12,1)\n",
 79 |     "    return zero"
 80 |    ]
 81 |   },
 82 |   {
 83 |    "cell_type": "markdown",
 84 |    "metadata": {},
 85 |    "source": [
 86 |     "## 3) Dataloader"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "code",
 91 |    "execution_count": 4,
 92 |    "metadata": {
 93 |     "collapsed": true
 94 |    },
 95 |    "outputs": [],
 96 |    "source": [
 97 |     "mnist_train = dset.MNIST(\"./\", train=True, \n",
 98 |     "                         transform=transforms.Compose([\n",
 99 |     "                            transforms.RandomCrop(22),\n",
100 |     "                            transforms.Resize(12),\n",
101 |     "                            transforms.Lambda(one_sided_padding),\n",
102 |     "                            transforms.ToTensor(),\n",
103 |     "                         ]), \n",
104 |     "                         target_transform=None, \n",
105 |     "                         download=True)\n",
106 |     "\n",
107 |     "mnist_test = dset.MNIST(\"./\", train=False,\n",
108 |     "                        transform=transforms.Compose([\n",
109 |     "                            transforms.RandomCrop(22),\n",
110 |     "                            transforms.Resize(12),\n",
111 |     "                            transforms.Lambda(one_sided_padding),\n",
112 |     "                            transforms.ToTensor(),\n",
113 |     "                        ]),\n",
114 |     "                        target_transform=None, \n",
115 |     "                        download=True)\n",
116 |     "\n",
117 |     "train_loader = torch.utils.data.DataLoader(mnist_train,batch_size=batch_size, shuffle=True,num_workers=2,drop_last=True)\n",
118 |     "test_loader = torch.utils.data.DataLoader(mnist_test,batch_size=batch_size, shuffle=True,num_workers=2,drop_last=True)"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "markdown",
123 |    "metadata": {},
124 |    "source": [
125 |     "## 4) Classification Model"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 5,
131 |    "metadata": {
132 |     "collapsed": true
133 |    },
134 |    "outputs": [],
135 |    "source": [
136 |     "class CNN(nn.Module):\n",
137 |     "    def __init__(self,num_feature=32):\n",
138 |     "        super(CNN,self).__init__()\n",
139 |     "        self.num_feature=num_feature\n",
140 |     "        \n",
141 |     "        self.layer = nn.Sequential(\n",
142 |     "            nn.Conv2d(1,self.num_feature,3,1,1),\n",
143 |     "            nn.BatchNorm2d(self.num_feature),\n",
144 |     "            nn.ReLU(),\n",
145 |     "            nn.Conv2d(self.num_feature,self.num_feature*2,3,1,1),\n",
146 |     "            nn.BatchNorm2d(self.num_feature*2),\n",
147 |     "            nn.ReLU(),\n",
148 |     "            nn.AvgPool2d(2,2),\n",
149 |     "            \n",
150 |     "            nn.Conv2d(self.num_feature*2,self.num_feature*4,3,1,1),\n",
151 |     "            nn.BatchNorm2d(self.num_feature*4),\n",
152 |     "            nn.ReLU(),\n",
153 |     "            nn.AvgPool2d(2,2),\n",
154 |     "            \n",
155 |     "            nn.Conv2d(self.num_feature*4,self.num_feature*8,3,1,1),\n",
156 |     "            nn.BatchNorm2d(self.num_feature*8),\n",
157 |     "            nn.ReLU(),\n",
158 |     "        )\n",
159 |     "        self.fc_layer = nn.Sequential(\n",
160 |     "            nn.Linear(self.num_feature*8*7*7,1000),\n",
161 |     "            nn.ReLU(),\n",
162 |     "            nn.Linear(1000,10)\n",
163 |     "        )       \n",
164 |     "        \n",
165 |     "        for m in self.modules():\n",
166 |     "            if isinstance(m, nn.Conv2d):\n",
167 |     "                \n",
168 |     "                # Kaming Initialization\n",
169 |     "                init.kaiming_normal(m.weight.data)\n",
170 |     "                m.bias.data.fill_(0)\n",
171 |     "                \n",
172 |     "            elif isinstance(m, nn.Linear):\n",
173 |     "\n",
174 |     "                # Kaming Initialization\n",
175 |     "                init.kaiming_normal(m.weight.data)\n",
176 |     "                m.bias.data.fill_(0)\n",
177 |     "        \n",
178 |     "        \n",
179 |     "    def forward(self,x):\n",
180 |     "        out = self.layer(x)\n",
181 |     "        out = out.view(x.size()[0],-1)\n",
182 |     "        out = self.fc_layer(out)\n",
183 |     "\n",
184 |     "        return out\n",
185 |     "\n",
186 |     "model = nn.DataParallel(CNN().cuda())"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "markdown",
191 |    "metadata": {},
192 |    "source": [
193 |     "## 5) Loss & Optimizer"
194 |    ]
195 |   },
196 |   {
197 |    "cell_type": "code",
198 |    "execution_count": 6,
199 |    "metadata": {
200 |     "collapsed": true
201 |    },
202 |    "outputs": [],
203 |    "source": [
204 |     "loss_func = nn.CrossEntropyLoss()\n",
205 |     "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
206 |    ]
207 |   },
208 |   {
209 |    "cell_type": "markdown",
210 |    "metadata": {},
211 |    "source": [
212 |     "## 6) Train"
213 |    ]
214 |   },
215 |   {
216 |    "cell_type": "code",
217 |    "execution_count": 7,
218 |    "metadata": {
219 |     "scrolled": true
220 |    },
221 |    "outputs": [
222 |     {
223 |      "name": "stdout",
224 |      "output_type": "stream",
225 |      "text": [
226 |       "Test Data Accuracy: [91.81691]%\n",
227 |       "Test Data Accuracy: [94.80168]%\n",
228 |       "Test Data Accuracy: [96.04367]%\n",
229 |       "Test Data Accuracy: [97.04527]%\n",
230 |       "Test Data Accuracy: [96.6246]%\n",
231 |       "Test Data Accuracy: [97.53606]%\n",
232 |       "Test Data Accuracy: [96.55449]%\n",
233 |       "Test Data Accuracy: [97.82652]%\n",
234 |       "Test Data Accuracy: [97.15545]%\n",
235 |       "Test Data Accuracy: [95.99359]%\n"
236 |      ]
237 |     }
238 |    ],
239 |    "source": [
240 |     "for i in range(num_epoch):\n",
241 |     "    model.train()\n",
242 |     "    for j,[image,label] in enumerate(train_loader):\n",
243 |     "        x = Variable(image).cuda()\n",
244 |     "        y_= Variable(label).cuda()\n",
245 |     "        \n",
246 |     "        optimizer.zero_grad()\n",
247 |     "        output = model.forward(x)\n",
248 |     "        loss = loss_func(output,y_)\n",
249 |     "        loss.backward()\n",
250 |     "        optimizer.step()\n",
251 |     "        \n",
252 |     "         \n",
253 |     "    top_1_count = torch.FloatTensor([0])\n",
254 |     "    total = torch.FloatTensor([0])\n",
255 |     "    model.eval() \n",
256 |     "    for image,label in test_loader:\n",
257 |     "        x = Variable(image,volatile=True).cuda()\n",
258 |     "        y_= Variable(label).cuda()\n",
259 |     "\n",
260 |     "        output = model.forward(x)\n",
261 |     "        \n",
262 |     "        values,idx = output.max(dim=1)\n",
263 |     "        top_1_count += torch.sum(y_==idx).float().cpu().data\n",
264 |     "\n",
265 |     "        total += label.size(0)\n",
266 |     "\n",
267 |     "    print(\"Test Data Accuracy: {}%\".format(100*(top_1_count/total).numpy()))\n",
268 |     "    if (top_1_count/total).numpy() > 0.98:\n",
269 |     "        break\n"
270 |    ]
271 |   },
272 |   {
273 |    "cell_type": "markdown",
274 |    "metadata": {},
275 |    "source": [
276 |     "## 7) CAM "
277 |    ]
278 |   },
279 |   {
280 |    "cell_type": "code",
281 |    "execution_count": 8,
282 |    "metadata": {
283 |     "collapsed": true
284 |    },
285 |    "outputs": [],
286 |    "source": [
287 |     "class CAM():\n",
288 |     "    def __init__(self,model):\n",
289 |     "        self.gradient = []\n",
290 |     "        self.h = model.module.layer[-1].register_backward_hook(self.save_gradient)\n",
291 |     "        \n",
292 |     "    def save_gradient(self,*args):\n",
293 |     "        grad_input = args[1]\n",
294 |     "        grad_output= args[2]\n",
295 |     "        self.gradient.append(grad_output[0])\n",
296 |     "      \n",
297 |     "    def get_gradient(self,idx):\n",
298 |     "        return self.gradient[idx]\n",
299 |     "    \n",
300 |     "    def remove_hook(self):\n",
301 |     "        self.h.remove()\n",
302 |     "            \n",
303 |     "    def normalize_cam(self,x):\n",
304 |     "        x = 2*(x-torch.min(x))/(torch.max(x)-torch.min(x)+1e-8)-1\n",
305 |     "        x[x<torch.max(x)]=-1\n",
306 |     "        return x\n",
307 |     "    \n",
308 |     "    def visualize(self,cam_img,img_var):\n",
309 |     "        cam_img = resize(cam_img.cpu().data.numpy(),output_shape=(28,28))\n",
310 |     "        x = img_var[0,:,:].cpu().data.numpy()\n",
311 |     "\n",
312 |     "        plt.subplot(1,3,1)\n",
313 |     "        plt.imshow(cam_img)\n",
314 |     "\n",
315 |     "        plt.subplot(1,3,2)\n",
316 |     "        plt.imshow(x,cmap=\"gray\")\n",
317 |     "\n",
318 |     "        plt.subplot(1,3,3)\n",
319 |     "        plt.imshow(x+cam_img)\n",
320 |     "        plt.show()\n",
321 |     "    \n",
322 |     "    def get_cam(self,idx):\n",
323 |     "        grad = self.get_gradient(idx)\n",
324 |     "        alpha = torch.sum(grad,dim=3,keepdim=True)\n",
325 |     "        alpha = torch.sum(alpha,dim=2,keepdim=True)\n",
326 |     "        \n",
327 |     "        cam = alpha[j]*grad[j]\n",
328 |     "        cam = torch.sum(cam,dim=0)\n",
329 |     "        cam = self.normalize_cam(cam)\n",
330 |     "        \n",
331 |     "        self.remove_hook()\n",
332 |     "        return cam\n",
333 |     "   "
334 |    ]
335 |   },
336 |   {
337 |    "cell_type": "markdown",
338 |    "metadata": {},
339 |    "source": [
340 |     "## 8) Calculate & Visualize"
341 |    ]
342 |   },
343 |   {
344 |    "cell_type": "code",
345 |    "execution_count": 9,
346 |    "metadata": {
347 |     "scrolled": false
348 |    },
349 |    "outputs": [
350 |     {
351 |      "name": "stderr",
352 |      "output_type": "stream",
353 |      "text": [
354 |       "/home/ubuntu/anaconda3/envs/pytorch/lib/python3.6/site-packages/skimage/transform/_warps.py:84: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
355 |       "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n"
356 |      ]
357 |     },
358 |     {
359 |      "data": {
360 |       "image/png": "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\n",
361 |       "text/plain": [
362 |        "<matplotlib.figure.Figure at 0x7f61877fbc18>"
363 |       ]
364 |      },
365 |      "metadata": {},
366 |      "output_type": "display_data"
367 |     },
368 |     {
369 |      "data": {
370 |       "image/png": "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\n",
371 |       "text/plain": [
372 |        "<matplotlib.figure.Figure at 0x7f6254c6d048>"
373 |       ]
374 |      },
375 |      "metadata": {},
376 |      "output_type": "display_data"
377 |     },
378 |     {
379 |      "data": {
380 |       "image/png": "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\n",
381 |       "text/plain": [
382 |        "<matplotlib.figure.Figure at 0x7f6232a33748>"
383 |       ]
384 |      },
385 |      "metadata": {},
386 |      "output_type": "display_data"
387 |     },
388 |     {
389 |      "data": {
390 |       "image/png": "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\n",
391 |       "text/plain": [
392 |        "<matplotlib.figure.Figure at 0x7f622b1a4b70>"
393 |       ]
394 |      },
395 |      "metadata": {},
396 |      "output_type": "display_data"
397 |     },
398 |     {
399 |      "data": {
400 |       "image/png": "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\n",
401 |       "text/plain": [
402 |        "<matplotlib.figure.Figure at 0x7f620697e550>"
403 |       ]
404 |      },
405 |      "metadata": {},
406 |      "output_type": "display_data"
407 |     },
408 |     {
409 |      "data": {
410 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAACFCAYAAABL2gNbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADcJJREFUeJzt3W2MXNV9x/Hff59s764fdm3H68eAK1MwlRDIahIFVa0ihIkqyJtKARf8AokKBRHUVOBQXiKEVIkXqOUFUhAuSt1WiiVoFRSoZSmtihK7Fq4NxjG2E2e9fsDYrJ/tnZ1/X3h67z2zO7uzOzN3ds58P5I158yZufev+c/9++6Z+2DuLgBA6+todgAAgPqgoANAJCjoABAJCjoARIKCDgCRoKADQCQo6AAQiZoKupltNrPDZva5mW2rV1BoLvIaL3IbN5vtiUVm1inpN5IekDQsaY+kR9390/qFh7yR13iR2/h11fDeP5b0ubsfkyQz+2dJj0iq+OXo6u3z7sWDSb/jZjpmRc5YrTfvsKRd7EmfHxs9r8LVKzbJW6RZ5NXMSN4c4e6V8irNMLfd8/u8py+zvRbSNNs4Ka8378xsr11hGq+eHz7n7sunW0YtBX21pN9n+sOSvjHVG7oXD2r91r9O+n0jxaTdc6k42VtQg5sL0xm1K6vS9rHtr031thnnFS1jRrnt6RvUH21+Lukv+LKQtLsujzUgvPZW6O9O2teWhqX51//0N7+rZhm1FPTJ9gQm/LdtZk9JekqSuhcN1LA65GTGeUXLmDa32bz29LK9tppafhQdlrQ2018jaaT8Re7+prtvcvdNnb19NawOOZlxXnOLDLWaNrfZvHbNZ3ttNbXsoe+RtMHMbpd0UtL3JT021Rs6bobTLEs+u5y0O09fqCEUTGZ8KLuH1Z+0sr9dTGLGeUXLmFFuOwoeTLPMP34+Hbww2rAg21XXwOJMb7Di66ZcxmxX7u4FM3tG0i8kdUp6y90/me3yMDeQ13iR2/jVsocud/+5pJ/XKRbMEeQ1XuQ2bjUV9JmyogdHs2SnWQrDJ/MMpS1kk9uzujdpc4goqmHjHh7NkplmGT/3ZRMiiltnpt21fOGslsGp/wAQCQo6AESCgg4AkaCgA0AkKOgAEAkKOgBEgoIOAJGgoANAJCjoABAJCjoARIKCDgCRoKADQCQo6AAQiVyvttjubN68pN2xaFE4uDi9AYX3L6i8jMvXwidG05uEFC9erC1AAAnrSstjR3949yZbkG6j3jfF9nol3F79WtovXr5Sa4gTsIcOAJGgoANAJCjoABAJ5tBzlJ03H7tzTTA2un5+0r68ziouo//E4qC/+Nj1pN392XCtIQIoyc6b+5qVwdi11elvXleGuisuo+/0WNCffzL9zatj+FStIU7AHjoARIKCDgCRYMolT5lDE7NTLJJ07r70xs0b7/ltxUV8uv/rZc+ky1l2qj8cun5zxiFiep2dnUF/7dq1SXvJkiXB2Pz5aX6uXr0ajB04cCBpu3Pj7qazsqnO1UNJ8/x9A8HQhTvT9vi668GYn+9J2jc/7wnGBpRuo71fhoc7+lg4PTMb7KEDQCQo6AAQCQo6AESCOfQcZU/pLz80MTtv/u93vF9xGX+uh4L+sXO3J+2l+8M5OWMOvW7WrEkPM92yZUsw9vTTTyftoaGhYGx0dDRp7969u+L7Lly4UJc4MTOdA+nc+I171wdjxzan89/3fOtIMPZ3q/8jaf9J+HOY/vK3f5q0/9vvDMZ6RtNDHBccLbtkwFfMoQMASqYt6Gb2lpmdNbODmecGzexDMztSehyYahmYe8hrvMht+6pmyuVtSX8v6R8zz22TtMvdXzWzbaX+C/UPDw30tshrRR0d4b7O448/nrRfeeWVYOz48eNJe/v27cHYjh07kvaePXuCsfLDGOvobZHbqty4L51mGbl/XjiYOZT0f47cFgz91en0+3DPqpPB2NVCeKhinqbdQ3f3X0o6X/b0I5L+/5u7XdL36hwXGoy8xovctq/ZzqGvcPdTklR6/FqlF5rZU2a218z2Fm7U//q/qKtZ5TW36FCLqnKbzetYge211TT8R1F3f9PdN7n7pq55fdO/AS0hm9dmx4L6yea1u4vttdXM9rDFM2a20t1PmdlKSWfrGVSssncbKr9qYvaU/vJDEyu9TpKWnUjn+SbczWjmyGvJHXfcEfQfe+yxpP3RRx8FY88880zSPnToUDB2/Xp6WniTT+8nt5K6hlYE/bN3pfPmvafD/Czfl14Z8dqK8BDD0fULk/av/yD8rmQtOhruM/edTg8lnnA3o4pLqd5s99Dfk7S11N4q6d06xILmI6/xIrdtoJrDFndI+kjSH5rZsJk9KelVSQ+Y2RFJD5T6aCHkNV7ktn1NO+Xi7o9WGPpOnWOJX+aGztkbU9ySnm6WPfuzXHaKZcJyMsuXJM2rfPgUeZ3ahg0bgv7Chemf2M8++2wwtn///qQ9Pj7e2MCqQG4rKy4LD78fz2wiKz/8Inzx2S+TZu+1cKqmYyy9amL27M9y2SkWKbzBRfaG0ZKkrtpP3OdMUQCIBAUdACJBQQeASHC1xRwVL15M2uU3dM7ebaj8qolZEw5NzMybZ5cvSZ3Ll80mTEg6ceJE0N+3b1/SvnHjRjBWfoXFrLHMXWi++CKco+UuRfnr+OpS0O89m95hysYKwZhn5rQ7LoUnWS04nuZ1wdFixfVNODQxM29evBwus2NJeCjzbLCHDgCRoKADQCSYcsmRZ/5UHy/781vlfTRV+Rmf2bND33jjjWDs0qVLk7alcMrlnXfeCcZ27tyZtIvFyn+2o34KI6eDft9IOl028tCqYKxjLJ0S6yy7V4xljk4dPDAajBU//rTGKGePPXQAiAQFHQAiQUEHgEgwhw5M4ubNcNL09ddfT9rvv1/5Jt5Lly4N+i+//HLSfumll4KxDz74IGlfLDvkFA1SDC/N0P3L9LINqw5XvPy/vDe8E/SZP0svBXD620uCsaHP0tcWr5df4qOx2EMHgEhQ0AEgEhR0AIgEc+hAFbJz6iMjI8HYgw8+mLRfeOGFYGzdunVJ+8UXXwzGLl8uu9wxcueF9HT/4oWvwrGN65P2mW8sCsbG0qspa9V/Xg3G8p43z2IPHQAiQUEHgEgw5QJU4e67707azz//fDD28MMPJ+3ySwZs2bIlae/evTsY43T/5utanZ7uf+H+dcHY6Pp0f3f++fDKmOv+7XzSLh4+Gow18xqa7KEDQCQo6AAQCQo6AESCOXSgCgcPHkzaTzzxRBMjQT0VTqaHoC78l/Bw1IXlL84Yn2KsmdhDB4BIUNABIBIUdACIBAUdACIxbUE3s7VmttvMDpnZJ2b2w9Lzg2b2oZkdKT0OND5c1At5jRN5bW/V7KEXJP3I3e+S9E1JPzCzjZK2Sdrl7hsk7Sr10TrIa5zIaxubtqC7+yl331dqX5J0SNJqSY9I2l562XZJ32tUkKg/8hon8treZjSHbma3SbpX0q8krXD3U9KtL5GkSe/fZGZPmdleM9tbuHGltmjRELXmNa84MTO15nWswPbaaqou6GbWL+lnkp5z96pvgOjub7r7Jnff1DWvbzYxooHqkdfGRYfZqkdeu7vYXltNVQXdzLp168vxU3ffWXr6jJmtLI2vlHS2MSGiUchrnMhr+6rmKBeT9BNJh9z9tczQe5K2ltpbJb1b//DQKOQ1TuS1vVVzLZdvS3pc0gEz+7j03IuSXpX0r2b2pKQTkv6iMSGiQchrnMhrG5u2oLv7f0myCsPfqW84yAt5jRN5bW+cKQoAkaCgA0AkKOgAEAkKOgBEgoIOAJGgoANAJCjoABAJCjoARIKCDgCRoKADQCQo6AAQCQo6AESCgg4AkaCgA0Akqrkeet14h+nmwvT/kPGhgeYE0iayn2/2c/eOSldXBVLeaSr0dyf9roHFSbuzGQHFLvP5Zj/3mWAPHQAiQUEHgEjkOtNR7JGurMr+H9KftHpW9+YZSlvITrNkP/diTzOiQaspdpmuLc2WiMGk1bV8Yf4BRS47zRJ+7tVjDx0AIkFBB4BIUNABIBLm7vmtzOwLSb+TtEzSudxWPLV2jOXr7r68Xgsjr9Mir/XTrrFUldtcC3qyUrO97r4p9xVPgljqZy7FTyz1M5fiJ5apMeUCAJGgoANAJJpV0N9s0nonQyz1M5fiJ5b6mUvxE8sUmjKHDgCoP6ZcACASuRZ0M9tsZofN7HMz25bnukvrf8vMzprZwcxzg2b2oZkdKT0OTLWMOsWx1sx2m9khM/vEzH7YrFjqgbwGsUSTW/IaxNISec2toJtZp6R/kPSQpI2SHjWzjXmtv+RtSZvLntsmaZe7b5C0q9RvtIKkH7n7XZK+KekHpc+iGbHUhLxOEEVuyesErZFXd8/ln6RvSfpFpv9jST/Oa/2Z9d4m6WCmf1jSylJ7paTDTYjpXUkPzIVYyCu5Ja+tm9c8p1xWS/p9pj9ceq7ZVrj7KUkqPX4tz5Wb2W2S7pX0q2bHMkvktYIWzy15rWAu5zXPgj7ZbXLa+hAbM+uX9DNJz7n7xWbHM0vkdRIR5Ja8TmKu5zXPgj4saW2mv0bSSI7rr+SMma2UpNLj2TxWambduvXF+Km772xmLDUir2UiyS15LdMKec2zoO+RtMHMbjezHknfl/Rejuuv5D1JW0vtrbo1N9ZQZmaSfiLpkLu/1sxY6oC8ZkSUW/Ka0TJ5zfmHhO9K+o2ko5L+tgk/ZOyQdErSmG7tgTwpaalu/Tp9pPQ4mEMc9+vWn6//K+nj0r/vNiMW8kpuyWs8eeVMUQCIBGeKAkAkKOgAEAkKOgBEgoIOAJGgoANAJCjoABAJCjoARIKCDgCR+D/Np+OeURfcNgAAAABJRU5ErkJggg==\n",
411 |       "text/plain": [
412 |        "<matplotlib.figure.Figure at 0x7f6178021908>"
413 |       ]
414 |      },
415 |      "metadata": {},
416 |      "output_type": "display_data"
417 |     },
418 |     {
419 |      "data": {
420 |       "image/png": "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\n",
421 |       "text/plain": [
422 |        "<matplotlib.figure.Figure at 0x7f6232a61a90>"
423 |       ]
424 |      },
425 |      "metadata": {},
426 |      "output_type": "display_data"
427 |     },
428 |     {
429 |      "data": {
430 |       "image/png": "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\n",
431 |       "text/plain": [
432 |        "<matplotlib.figure.Figure at 0x7f62329a65c0>"
433 |       ]
434 |      },
435 |      "metadata": {},
436 |      "output_type": "display_data"
437 |     },
438 |     {
439 |      "data": {
440 |       "image/png": "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\n",
441 |       "text/plain": [
442 |        "<matplotlib.figure.Figure at 0x7f62069a3748>"
443 |       ]
444 |      },
445 |      "metadata": {},
446 |      "output_type": "display_data"
447 |     },
448 |     {
449 |      "data": {
450 |       "image/png": "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\n",
451 |       "text/plain": [
452 |        "<matplotlib.figure.Figure at 0x7f610c3b5b38>"
453 |       ]
454 |      },
455 |      "metadata": {},
456 |      "output_type": "display_data"
457 |     },
458 |     {
459 |      "data": {
460 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAACFCAYAAABL2gNbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADUlJREFUeJzt3W+MXNV5x/Hfs3+xd/F6F4zZtV1MIhdspBBaq3GhEkgBSqIK/KZqKK1siWJepFKiBIHTije8QFRIVIL2jYUtu8J1W8lIUOQ2AitKixQiWxUkgAP+o0LWNpitje21Ye3dffrCo3vvGXZ25++dmTPfj2TtuXNm5j7aZ8/jO2fOvdfcXQCA9tfV7AAAAPVBQQeASFDQASASFHQAiAQFHQAiQUEHgEhQ0AEgEjUVdDO7z8w+MLMjZra1XkGhuchrvMht3KzaE4vMrFvSh5LukTQu6YCkB939/fqFh7yR13iR2/j11PDaP5B0xN2PSZKZ/YukBySV/OPoWTzgvUMjyXbXpbTPZjljtd68y5L2bF/6+OWzpzV98YLN8RKpiryaGclrEe5eKq9ShbllvOar1HiVpC8/GZ9w92ULvUctBX2FpN9mtsclfWu+F/QOjehrm36UbA+cmE3afedn53oJanDp6nRG7cJY2j6267n5XlZxXtE2Ksot4zVfpcarJL3/dz/6qJz3qGUOfa4jga/8t21mW8zsoJkdnLl4oYbdIScV5zWHmFAfC+aW8dreaino45JWZbZXSjpR/CR33+bu6919fffigRp2h5xUnNfcIkOtFswt47W91TLlckDSGjO7UdJxSd+T9OfzvaDrUvixbelvJpN29ydnaggFc5m5fjizNZi0snOhc6g4r2gbFeWW8ZqvUuO1ElUXdHefNrO/lvRTSd2Sdrj7e9W+H1oDeY0XuY1fLUfocvd9kvbVKRa0CPIaL3Ibt5oKeqVs1oNvx7Mf26bHj+cZSkfIJrdvxeKkzZIzlIPxmq9S47USnPoPAJGgoANAJCjoABCJXOfQgfmsWpUukX7++eeDvosXLybtLVu2BH0XLnACTCvrWTGWtI9uWR30ZZfQ3vD3bwd9s5mcozwcoQNAJCjoABAJplzQNEuWLAm2N2/enLTXrl0b9D322GNJ+yIfxVta19VXB9un/viGpD01ejno+/o/zyRtplhqxxE6AESCgg4AkaCgA0AkmENHroaH0yvKPfXUU0Hfxo0bk/a2bduCvjfeeCNpV3vbRDRO99KhpH188y1B3/nbvkza1/68P+jr+cWvkjZZrR1H6AAQCQo6AESCKRc01MBAeNebJ554Imk/9NBDQd8LL7yQtIunXPr60rvmdnd3B32cKZq/rsXh1QA/eXBd0v7iW2E+Rvanz13270eCPs/k1YryyjLGynGEDgCRoKADQCQo6AAQCebQUXdmlrTvv//+oO/RRx9N2m+99VbQNzOTngb+7LPPBn2jo6NJ++jRo0Hf448/nrTPnTtXRcQoSyavX9wZLk2cvDMzb34s/N7E0pse6aO/WhP0XRpKFysu+syCvhXbfp20Z8+frzjcTsQROgBEgoIOAJFgygV119+fng149913B31DQ+kZhbfcEn5sv/3220u+Z3b5Y/FSyJ4e/ozz4P29SXviG71B38CidErk7FjYd+7r4RUWsxb1p30X+oeCPuvmeLNS/MYAIBIUdACIBAUdACLB5CNqZmbq7U3nTbPz5vfee2/J1xXPhb/55ptJe2JiIui76667kvaePXuCvs8//7yieFEmM832pEsJP//95Un74rovg6dmZ797+qfD9zmS5rlnMlyaOHnTVNK+PlzFqpmzLEGtFEfoABCJBQu6me0ws1Nm9m7msREze93MDhd+Ds/3Hmg95DVe5LZzlTPlslPSP0j6p8xjWyXtd/dnzGxrYfuJOV7bcNYfXjC/K3vj4aHBoM8HF5V+n8kv0o2zk0HfbObsQ5+aUiR2qk55HRwc1IYNG5Ltp59+OmmvXLkyeO6JEyeS9vbt24O+sbGxpH3HHXcEfXv37k3aL730UtA3OzsrBHaqDrmdvko6fXN6BcTZW9OliUP94VLEs2fTKyqO/Hc4JqeG02mWyZsvBX2LjqTPXfLh2aDPbg1vFB70dd54LcuCR+ju/l+SThc9/ICkXYX2LkkbhbZCXuNFbjtXtXPoy939pCQVfl5X6olmtsXMDprZwekprlvd4qrK6+XLpU8cQcsoK7fZvM5wnfm20/AvRd19m7uvd/f1Pf0DC78AbSGb1+wKF7S3bF67Bxiv7abaZYufmtmou580s1FJp+oZVCWCOXNJl29O52zPfu2qoG/yd8IlU1mDH6cLr4aOhUuyen8znrRnPvusqjjbRFV5Xb16tV588cVke+nSpUm7eH57ZGQkaT/yyCNB31VXpfnauXNn0Jedlz9z5kw5YSFUcW6vGT6vv/iz/cn2/lM3Je2JybDYLxpI56rP3Bne7rm7J72K5qJ3w++1lr2dLnE8/Y1wLDNeK1ftEfqrkjYV2pskvVKfcNBk5DVe5LYDlLNscY+kX0i6yczGzexhSc9IusfMDku6p7CNNkJe40VuO9eCUy7u/mCJrm/XOZbqFC1NzE6zTPxe+NFv3a3/W/Jt3n/nhsxWOFVz7cnMPiL5CFfPvJ4+fVq7d+9Otg8cOJC0N2/eHDx3+fL0bMPim1Hs2LEjae/bty/o48YV5atXbie+GND2d9IrYC77z3SJ4dRN4XTI5SXpWOv+Muwb+3k6rbLoRDhd9n/fTKfnGK+140xRAIgEBR0AIkFBB4BItP3VFotP588udSqeg3vtd/+j5Pv8ib6TtI9N3Bj0XfNO6UsGQDp+/LiefPLJZDu7VPG1114Lnpu9gXSx7AlK7l7yechH75kujb3cl2wvOZguB1z6r5+U/T4+nbn64jfXBX2M1/riCB0AIkFBB4BItP2UC1rDzMzMnI9znZd25rLZzNRXZhosmEZBy+AIHQAiQUEHgEhQ0AEgEm0/hx7cuUThVdjC04PDpU7Fss+99uNwyVzxPgBUh/HaWByhA0AkKOgAEAkKOgBEou3n0Ivv+B3evSS8rGbxKcJZ2Xm44jugFO8DQJUYrw3FEToARIKCDgCRaPspl9miO9lkbxAb3LlE81+FLVjqVPSRrXgfAKrDeG0sjtABIBIUdACIBAUdACLR9nPoPjUVbM9k7/LdYXf8Blod47WxOEIHgEhQ0AEgEhR0AIgEBR0AIrFgQTezVWb2MzM7ZGbvmdkPCo+PmNnrZna48HO48eGiXshrnMhrZyvnCH1a0o/dfa2kDZK+b2brJG2VtN/d10jaX9hG+yCvcSKvHWzBgu7uJ939fwrt85IOSVoh6QFJuwpP2yVpY6OCRP2R1ziR185W0Ry6ma2WdJukX0pa7u4npSt/RJKuK/GaLWZ20MwOTk9dqC1aNEStec0rTlSG8dp5yi7oZjYoaa+kH7p72Ve/cfdt7r7e3df39A9UEyMaqB55bVx0qBbjtTOVVdDNrFdX/jh2u/vLhYc/NbPRQv+opFONCRGNQl7jRF47VzmrXEzSdkmH3P25TNerkjYV2pskvVL/8NAo5DVO5LWzlXMtlzsk/aWkX5vZ24XH/kbSM5L+zcwelvSxpD9tTIhoEPIaJ/LawRYs6O7+piQr0f3t+oaDvJDXOJHXzsaZogAQCQo6AESCgg4AkaCgA0AkKOgAEAkKOgBEgoIOAJGgoANAJCjoABAJCjoARIKCDgCRoKADQCQo6AAQCQo6AESinOuh1413mS5dnf4fMnP9cHMC6RDZ32/29+5dpa6uCqQYr/kqNV4rwRE6AESCgg4Akcj1k9Nsn3RhLPt/yGDS6luxOM9QOkL2Y1v29z7b14xo0G4Yr/kqNV4rwRE6AESCgg4AkaCgA0AkzN3z25nZZ5I+knStpIncdjy/TozlBndfVq83I68LIq/106mxlJXbXAt6slOzg+6+Pvcdz4FY6qeV4ieW+mml+Illfky5AEAkKOgAEIlmFfRtTdrvXIilflopfmKpn1aKn1jm0ZQ5dABA/THlAgCRyLWgm9l9ZvaBmR0xs6157ruw/x1mdsrM3s08NmJmr5vZ4cLP4fneo05xrDKzn5nZITN7z8x+0KxY6oG8BrFEk1vyGsTSFnnNraCbWbekf5T0HUnrJD1oZuvy2n/BTkn3FT22VdJ+d18jaX9hu9GmJf3Y3ddK2iDp+4XfRTNiqQl5/Yoocktev6I98uruufyT9IeSfprZ/omkn+S1/8x+V0t6N7P9gaTRQntU0gdNiOkVSfe0QizkldyS1/bNa55TLisk/TazPV54rNmWu/tJSSr8vC7PnZvZakm3Sfpls2OpEnktoc1zS15LaOW85lnQ57pNTkcvsTGzQUl7Jf3Q3c81O54qkdc5RJBb8jqHVs9rngV9XNKqzPZKSSdy3H8pn5rZqCQVfp7KY6dm1qsrfxi73f3lZsZSI/JaJJLcktci7ZDXPAv6AUlrzOxGM+uT9D1Jr+a4/1JelbSp0N6kK3NjDWVmJmm7pEPu/lwzY6kD8poRUW7Ja0bb5DXnLxK+K+lDSUcl/W0TvsjYI+mkpMu6cgTysKRrdOXb6cOFnyM5xPFHuvLx9VeS3i78+24zYiGv5Ja8xpNXzhQFgEhwpigARIKCDgCRoKADQCQo6AAQCQo6AESCgg4AkaCgA0AkKOgAEIn/B3wgG4674zWnAAAAAElFTkSuQmCC\n",
461 |       "text/plain": [
462 |        "<matplotlib.figure.Figure at 0x7f610c607208>"
463 |       ]
464 |      },
465 |      "metadata": {},
466 |      "output_type": "display_data"
467 |     },
468 |     {
469 |      "data": {
470 |       "image/png": "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\n",
471 |       "text/plain": [
472 |        "<matplotlib.figure.Figure at 0x7f6254c4c160>"
473 |       ]
474 |      },
475 |      "metadata": {},
476 |      "output_type": "display_data"
477 |     },
478 |     {
479 |      "data": {
480 |       "image/png": "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\n",
481 |       "text/plain": [
482 |        "<matplotlib.figure.Figure at 0x7f610c421898>"
483 |       ]
484 |      },
485 |      "metadata": {},
486 |      "output_type": "display_data"
487 |     },
488 |     {
489 |      "data": {
490 |       "image/png": "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\n",
491 |       "text/plain": [
492 |        "<matplotlib.figure.Figure at 0x7f610c492978>"
493 |       ]
494 |      },
495 |      "metadata": {},
496 |      "output_type": "display_data"
497 |     },
498 |     {
499 |      "data": {
500 |       "image/png": "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\n",
501 |       "text/plain": [
502 |        "<matplotlib.figure.Figure at 0x7f610c411e80>"
503 |       ]
504 |      },
505 |      "metadata": {},
506 |      "output_type": "display_data"
507 |     },
508 |     {
509 |      "data": {
510 |       "image/png": "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\n",
511 |       "text/plain": [
512 |        "<matplotlib.figure.Figure at 0x7f622b1a7048>"
513 |       ]
514 |      },
515 |      "metadata": {},
516 |      "output_type": "display_data"
517 |     },
518 |     {
519 |      "data": {
520 |       "image/png": "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\n",
521 |       "text/plain": [
522 |        "<matplotlib.figure.Figure at 0x7f610c4ca9b0>"
523 |       ]
524 |      },
525 |      "metadata": {},
526 |      "output_type": "display_data"
527 |     },
528 |     {
529 |      "data": {
530 |       "image/png": "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\n",
531 |       "text/plain": [
532 |        "<matplotlib.figure.Figure at 0x7f610c38e128>"
533 |       ]
534 |      },
535 |      "metadata": {},
536 |      "output_type": "display_data"
537 |     },
538 |     {
539 |      "data": {
540 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAACFCAYAAABL2gNbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADDhJREFUeJzt3d+PVPUZx/HPs79QWKAgsiy/VAyiXGhsNlbSXtWQiKnRxDTBmoYLEhulCUYviu0/YG+8aOCGRIVGY9MECIRIjCEmbRNr2Ri1yIJQLLCy8rOCLLDL7j692MmZc4ad3flx5szOd96vZDPf75wz5zzZZ77PnvnuOWfM3QUAaHwt9Q4AAJAOCjoABIKCDgCBoKADQCAo6AAQCAo6AASCgg4AgaiqoJvZk2Z2zMxOmNmWtIJCfZHXcJHbsFmlFxaZWaukryWtldQv6ZCk5939SHrhIWvkNVzkNnxtVbz2MUkn3P2kJJnZXyQ9I6nom6Nt5ixvnzs/6rcM55fZGFesps1bLGqPdeSfv3XlskauD9oEL5EqyKuZkbxpwt2L5VUqM7eM12wVG6+SdPO7/ovufvdU26imoC+RdCbW75f0k8le0D53vlZseDXqzzo7FrU7fhib6CWowvDs/Iza4OJ8++TONyd7Wdl5RcMoK7eM12wVG6+SdOSPr54qZRvVzKFPdCRw259tM3vRzHrNrHf0+mAVu0NGys5rBjEhHVPmlvHa2Kop6P2SlsX6SyWdLVzJ3be7e4+797TOnFXF7pCRsvOaWWSo1pS5Zbw2tmqmXA5JWmlm90n6VtJ6Sb+a7AUtw8mPbT86ei1qt373vypCwURGF82L9TqjVnwudAJl5xUNo6zcMl6zVWy8lqPigu7uI2b2W0kfSmqV9La7f1Xp9jA9kNdwkdvwVXOELnf/QNIHKcWCaYK8hovchq2qgl4uG/PEf8fjH9tG+r/NMpSmEE9ux5KZUTvtU87MTB0d+fOslixZErWvX79e9HWdncmPlV1dXVF74cKFRV/X19eX6B89erTkWFE6c6ntxsTvFb9xo/jr7rwzue7cfJ5H5txR9HXtZy8n+iOnzhRZM0zFxms5uPQfAAJBQQeAQFDQASAQmc6hI0zt7e3q7u6O+u+8807UnjNnTmLda9fyp761tSXffkNDQ1E7PicvSWvWrInau3fvTix77rnnKogaU/EWaWhO/pjvu/X5ufD2Hx5MrBs/FdYLDhNbRosvu758JGrPPbIssazrT801h54GjtABIBAUdAAIBFMuqNrw8LDOnMl/PN60aVPULrw985UrV6L2zZs3E8sGB/P3Drn//vsTy/bv3x+19+zZU13AKImNSnd8nz/NeMWe/JRY+7fJUwx9MHYa463kpchjN/J5bl28KLHs+G8WR+0FXybfDygfR+gAEAgKOgAEgoIOAIFgDh2pGB3Nn5t2+PDhirYRP1Xx6aefTiw7ezZ/l9cDBw5UtH2UyxO3iWg/dSFql3OrDoudnnr10eQcevvV/C3aOz47kVg2KpSLI3QACAQFHQACwZQLpo2HH344am/cuDGxbPv27VH70qVLmcWE6rWsuCdqn+tJHkMu+lf+StHRq1cziylUHKEDQCAo6AAQCAo6AASCOXTUTUtL8nhi/fr1RdfdtWtXrcNBWswS3cuP3V101dmH+qP2SNG1UCqO0AEgEBR0AAgEUy6om+XLlyf669ati9rbtm1LLPvmm28yiQnVa+tKfsH39w/kp2C6P0le/zlydiCTmJoFR+gAEAgKOgAEgoIOAIFgDh2ZstgpbS+//HJiWWtra9Teu3dvYtnY2JjQGC49cV+iH/9i6M7e04llIwXfaIXqcIQOAIGYsqCb2dtmdt7MDseem29mH5nZ8dzjvNqGibSR13CR2+ZVypTLDklbJf059twWSQfd/Q0z25Lr/y798KYfmzEj0W+ZMye5wtzOqOmddxbfzrUbySeuXIuaYwV3nfOhIdXADtUhr6tWrYraL7zwQmLZ1q1bo3Z/f79QsR3KOLdty5ZG7UuPJK8UXfTP/HTZ6IWLae2yJAGN15JMeYTu7n+TdLng6Wck7cy1d0p6NuW4UGPkNVzktnlVOofe5e4DkpR7XFhsRTN70cx6zax3ZGiwwt0hIxXlNbPoUI2Scst4bWw1/6eou2939x5372mbMavWu0NG4nmtdyxID+O1sVV62uI5M+t29wEz65Z0Ps2gprPCObhbDy5N9K+suCNqX1uenEuM6zw9N9Gfe/Jm1G4/mpw/Hr1wQRlJPa9WcOe9l156KWoPDCQv+3733Xej9vDwcLW7RlJNx+yFny+L2m3Xkjmf/feTUXt0JNt7KgY+Xm9T6RH6Pkkbcu0NkvZOsi4aB3kNF7ltAqWctvi+pE8krTKzfjPbKOkNSWvN7Liktbk+Ggh5DRe5bV5TTrm4+/NFFj2RciyNIXaak5T8yCZJF3+cv/Jt9SP/LbqZI1/cU/BMfjsLBpL7UA0+wmWVVy+4EnDz5s1pbh4TqMeYnbfzk3y7YNmo6iiQ8VoqrhQFgEBQ0AEgEBR0AAgEd1ssU+HlwYWnOsXn4fY/cKDodn6hdYn+yYv5O9Td9UXxS5ABlK7ZxitH6AAQCAo6AASCgg4AgaCgA0AgKOgAEAgKOgAEgtMWy1T4zSWFd2GLXyJceKpTsfUkacHp/CXIt307CoCKNNt45QgdAAJBQQeAQFDQASAQzKGXK/Zt31Lym0vG5W+rGb88uFB8Du627RTsA0CFmmy8coQOAIGgoANAIJhyKdPY1auJfuEXxMa/vWSyu7DddqpT7GNb4T4AVKbZxitH6AAQCAo6AASCgg4AgWAOvUw+NJTojxZ+w3cdv/EbQFKzjVeO0AEgEBR0AAgEBR0AAkFBB4BATFnQzWyZmX1sZn1m9pWZbc49P9/MPjKz47nHebUPF2khr2Eir82tlCP0EUmvuftDkh6XtMnMVkvaIumgu6+UdDDXR+Mgr2Eir01syoLu7gPu/lmu/YOkPklLJD0jaWdutZ2Snq1VkEgfeQ0TeW1uZc2hm9m9kh6V9KmkLncfkMbfRJIWFnnNi2bWa2a9I0OD1UWLmqg2r1nFifIwXptPyQXdzDol7ZL0iruXfDcad9/u7j3u3tM2Y1YlMaKG0shr7aJDpRivzamkgm5m7Rp/c7zn7rtzT58zs+7c8m5J52sTImqFvIaJvDavUs5yMUlvSepz9zdji/ZJ2pBrb5C0N/3wUCvkNUzktbmVci+Xn0r6taR/m9nnued+L+kNSX81s42STkv6ZW1CRI2Q1zCR1yY2ZUF3939IsiKLn0g3HGSFvIaJvDY3rhQFgEBQ0AEgEBR0AAgEBR0AAkFBB4BAUNABIBAUdAAIBAUdAAJBQQeAQFDQASAQFHQACAQFHQACQUEHgEBQ0AEgEKXcDz013mIanp3/GzK6aF59AmkS8d9v/PfuLcXurgrkMV6zVWy8loMjdAAIBAUdAAKR6SensQ5pcHH8b0hn1OpYMjPLUJpC/GNb/Pc+1lGPaNBoGK/ZKjZey8EROgAEgoIOAIGgoANAIMzds9uZ2QVJpyQtkHQxsx1Prhljucfd705rY+R1SuQ1Pc0aS0m5zbSgRzs163X3nsx3PAFiSc90ip9Y0jOd4ieWyTHlAgCBoKADQCDqVdC312m/EyGW9Eyn+IklPdMpfmKZRF3m0AEA6WPKBQACkWlBN7MnzeyYmZ0wsy1Z7ju3/7fN7LyZHY49N9/MPjKz47nHeZNtI6U4lpnZx2bWZ2ZfmdnmesWSBvKaiCWY3JLXRCwNkdfMCrqZtUraJmmdpNWSnjez1VntP2eHpCcLntsi6aC7r5R0MNevtRFJr7n7Q5Iel7Qp97uoRyxVIa+3CSK35PU2jZFXd8/kR9IaSR/G+q9Lej2r/cf2e6+kw7H+MUnduXa3pGN1iGmvpLXTIRbySm7Ja+PmNcsplyWSzsT6/bnn6q3L3QckKfe4MMudm9m9kh6V9Gm9Y6kQeS2iwXNLXouYznnNsqBP9DU5TX2KjZl1Stol6RV3v1rveCpEXicQQG7J6wSme16zLOj9kpbF+kslnc1w/8WcM7NuSco9ns9ip2bWrvE3xnvuvruesVSJvBYIJLfktUAj5DXLgn5I0kozu8/MOiStl7Qvw/0Xs0/Shlx7g8bnxmrKzEzSW5L63P3NesaSAvIaE1BuyWtMw+Q1438kPCXpa0n/kfSHOvwj431JA5JuafwIZKOkuzT+3+njucf5GcTxM41/fP1S0ue5n6fqEQt5JbfkNZy8cqUoAASCK0UBIBAUdAAIBAUdAAJBQQeAQFDQASAQFHQACAQFHQACQUEHgED8H55z0O0Yw5ioAAAAAElFTkSuQmCC\n",
541 |       "text/plain": [
542 |        "<matplotlib.figure.Figure at 0x7f610bfb86a0>"
543 |       ]
544 |      },
545 |      "metadata": {},
546 |      "output_type": "display_data"
547 |     },
548 |     {
549 |      "data": {
550 |       "image/png": "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\n",
551 |       "text/plain": [
552 |        "<matplotlib.figure.Figure at 0x7f610bddc860>"
553 |       ]
554 |      },
555 |      "metadata": {},
556 |      "output_type": "display_data"
557 |     }
558 |    ],
559 |    "source": [
560 |     "cam = CAM(model)\n",
561 |     "\n",
562 |     "for i,[image,label] in enumerate(test_loader):\n",
563 |     "    x = Variable(image).cuda()\n",
564 |     "    y_= Variable(label).cuda()\n",
565 |     "        \n",
566 |     "    output = model.forward(x)    \n",
567 |     "    \n",
568 |     "    for j in range(20):\n",
569 |     "        model.zero_grad()\n",
570 |     "        lab = y_[j].cpu().data[0]\n",
571 |     "        output[j,lab].backward(retain_graph=True)\n",
572 |     "\n",
573 |     "        out = cam.get_cam(j)\n",
574 |     "        cam.visualize(out,x[j])\n",
575 |     "\n",
576 |     "    break"
577 |    ]
578 |   },
579 |   {
580 |    "cell_type": "code",
581 |    "execution_count": null,
582 |    "metadata": {
583 |     "collapsed": true
584 |    },
585 |    "outputs": [],
586 |    "source": []
587 |   }
588 |  ],
589 |  "metadata": {
590 |   "kernelspec": {
591 |    "display_name": "Python 3",
592 |    "language": "python",
593 |    "name": "python3"
594 |   },
595 |   "language_info": {
596 |    "codemirror_mode": {
597 |     "name": "ipython",
598 |     "version": 3
599 |    },
600 |    "file_extension": ".py",
601 |    "mimetype": "text/x-python",
602 |    "name": "python",
603 |    "nbconvert_exporter": "python",
604 |    "pygments_lexer": "ipython3",
605 |    "version": "3.6.3"
606 |   }
607 |  },
608 |  "nbformat": 4,
609 |  "nbformat_minor": 2
610 | }
611 | 


--------------------------------------------------------------------------------
/GuidedBackprop_MNIST.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# GuidedBackprop_MNIST\n",
  8 |     "\n",
  9 |     "- Visualizing with Guided Backpropagation\n",
 10 |     "\n",
 11 |     "## 1) Import required Libraries"
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "code",
 16 |    "execution_count": 1,
 17 |    "metadata": {
 18 |     "collapsed": true
 19 |    },
 20 |    "outputs": [],
 21 |    "source": [
 22 |     "import os\n",
 23 |     "\n",
 24 |     "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
 25 |     "\n",
 26 |     "import numpy as np\n",
 27 |     "import torch\n",
 28 |     "import torch.nn as nn\n",
 29 |     "import torch.optim as optim\n",
 30 |     "import torch.nn.init as init\n",
 31 |     "import torchvision.datasets as dset\n",
 32 |     "import torchvision.transforms as transforms\n",
 33 |     "from torch.utils.data import DataLoader\n",
 34 |     "from torch.autograd import Variable\n",
 35 |     "from torch.autograd import Function\n",
 36 |     "\n",
 37 |     "import matplotlib.pyplot as plt\n",
 38 |     "%matplotlib inline  \n",
 39 |     "\n",
 40 |     "import random"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "markdown",
 45 |    "metadata": {},
 46 |    "source": [
 47 |     "## 2) Hyperparameters"
 48 |    ]
 49 |   },
 50 |   {
 51 |    "cell_type": "code",
 52 |    "execution_count": 2,
 53 |    "metadata": {
 54 |     "collapsed": true
 55 |    },
 56 |    "outputs": [],
 57 |    "source": [
 58 |     "batch_size = 128\n",
 59 |     "learning_rate = 0.0001\n",
 60 |     "num_epoch = 10"
 61 |    ]
 62 |   },
 63 |   {
 64 |    "cell_type": "code",
 65 |    "execution_count": 3,
 66 |    "metadata": {
 67 |     "collapsed": true
 68 |    },
 69 |    "outputs": [],
 70 |    "source": [
 71 |     "def one_sided_padding(x):\n",
 72 |     "    rand1 = random.randrange(0,15,3)\n",
 73 |     "    rand2 = random.randrange(0,15,3)\n",
 74 |     "\n",
 75 |     "    zero = np.zeros(shape=[28,28,1])\n",
 76 |     "    zero[rand1:rand1+12,rand2:rand2+12,:]=np.asarray(x).reshape(12,12,1)\n",
 77 |     "    return zero"
 78 |    ]
 79 |   },
 80 |   {
 81 |    "cell_type": "markdown",
 82 |    "metadata": {},
 83 |    "source": [
 84 |     "## 3) Dataloader"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 4,
 90 |    "metadata": {
 91 |     "collapsed": true
 92 |    },
 93 |    "outputs": [],
 94 |    "source": [
 95 |     "mnist_train = dset.MNIST(\"./\", train=True, \n",
 96 |     "                         transform=transforms.Compose([\n",
 97 |     "                            transforms.RandomCrop(22),\n",
 98 |     "                            transforms.Resize(12),\n",
 99 |     "                            transforms.Lambda(one_sided_padding),\n",
100 |     "                            transforms.ToTensor(),\n",
101 |     "                         ]), \n",
102 |     "                         target_transform=None, \n",
103 |     "                         download=True)\n",
104 |     "\n",
105 |     "mnist_test = dset.MNIST(\"./\", train=False,\n",
106 |     "                        transform=transforms.Compose([\n",
107 |     "                            transforms.RandomCrop(22),\n",
108 |     "                            transforms.Resize(12),\n",
109 |     "                            transforms.Lambda(one_sided_padding),\n",
110 |     "                            transforms.ToTensor(),\n",
111 |     "                        ]),\n",
112 |     "                        target_transform=None, \n",
113 |     "                        download=True)\n",
114 |     "\n",
115 |     "train_loader = torch.utils.data.DataLoader(mnist_train,batch_size=batch_size, shuffle=True,num_workers=2,drop_last=True)\n",
116 |     "test_loader = torch.utils.data.DataLoader(mnist_test,batch_size=batch_size, shuffle=True,num_workers=2,drop_last=True)"
117 |    ]
118 |   },
119 |   {
120 |    "cell_type": "markdown",
121 |    "metadata": {},
122 |    "source": [
123 |     "## 4) Classification Model"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "code",
128 |    "execution_count": 5,
129 |    "metadata": {
130 |     "collapsed": true
131 |    },
132 |    "outputs": [],
133 |    "source": [
134 |     "class CNN(nn.Module):\n",
135 |     "    def __init__(self,num_feature=32):\n",
136 |     "        super(CNN,self).__init__()\n",
137 |     "        self.num_feature=num_feature\n",
138 |     "        \n",
139 |     "        self.layer = nn.Sequential(\n",
140 |     "            nn.Conv2d(1,self.num_feature,3,1,1),\n",
141 |     "            nn.BatchNorm2d(self.num_feature),\n",
142 |     "            nn.ReLU(),\n",
143 |     "            nn.Conv2d(self.num_feature,self.num_feature*2,3,1,1),\n",
144 |     "            nn.BatchNorm2d(self.num_feature*2),\n",
145 |     "            nn.ReLU(),\n",
146 |     "            nn.AvgPool2d(2,2),\n",
147 |     "            \n",
148 |     "            nn.Conv2d(self.num_feature*2,self.num_feature*4,3,1,1),\n",
149 |     "            nn.BatchNorm2d(self.num_feature*4),\n",
150 |     "            nn.ReLU(),\n",
151 |     "            nn.AvgPool2d(2,2),\n",
152 |     "            \n",
153 |     "            nn.Conv2d(self.num_feature*4,self.num_feature*8,3,1,1),\n",
154 |     "            nn.BatchNorm2d(self.num_feature*8),\n",
155 |     "            nn.ReLU(),\n",
156 |     "        )\n",
157 |     "        self.fc_layer = nn.Sequential(\n",
158 |     "            nn.Linear(self.num_feature*8*7*7,1000),\n",
159 |     "            nn.ReLU(),\n",
160 |     "            nn.Linear(1000,10)\n",
161 |     "        )       \n",
162 |     "        \n",
163 |     "        for m in self.modules():\n",
164 |     "            if isinstance(m, nn.Conv2d):\n",
165 |     "                \n",
166 |     "                # Kaming Initialization\n",
167 |     "                init.kaiming_normal(m.weight.data)\n",
168 |     "                m.bias.data.fill_(0)\n",
169 |     "                \n",
170 |     "            elif isinstance(m, nn.Linear):\n",
171 |     "\n",
172 |     "                # Kaming Initialization\n",
173 |     "                init.kaiming_normal(m.weight.data)\n",
174 |     "                m.bias.data.fill_(0)\n",
175 |     "        \n",
176 |     "        \n",
177 |     "    def forward(self,x):\n",
178 |     "        out = self.layer(x)\n",
179 |     "        out = out.view(x.size()[0],-1)\n",
180 |     "        out = self.fc_layer(out)\n",
181 |     "\n",
182 |     "        return out\n",
183 |     "\n",
184 |     "model = nn.DataParallel(CNN().cuda())"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "markdown",
189 |    "metadata": {},
190 |    "source": [
191 |     "## 5) Loss & Optimizer"
192 |    ]
193 |   },
194 |   {
195 |    "cell_type": "code",
196 |    "execution_count": 6,
197 |    "metadata": {
198 |     "collapsed": true
199 |    },
200 |    "outputs": [],
201 |    "source": [
202 |     "loss_func = nn.CrossEntropyLoss()\n",
203 |     "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
204 |    ]
205 |   },
206 |   {
207 |    "cell_type": "markdown",
208 |    "metadata": {},
209 |    "source": [
210 |     "## 6) Train"
211 |    ]
212 |   },
213 |   {
214 |    "cell_type": "code",
215 |    "execution_count": 7,
216 |    "metadata": {
217 |     "scrolled": true
218 |    },
219 |    "outputs": [
220 |     {
221 |      "name": "stdout",
222 |      "output_type": "stream",
223 |      "text": [
224 |       "Test Data Accuracy: [91.796875]%\n",
225 |       "Test Data Accuracy: [95.97356]%\n",
226 |       "Test Data Accuracy: [96.03365]%\n",
227 |       "Test Data Accuracy: [96.905045]%\n",
228 |       "Test Data Accuracy: [97.33574]%\n",
229 |       "Test Data Accuracy: [96.3742]%\n",
230 |       "Test Data Accuracy: [95.8133]%\n",
231 |       "Test Data Accuracy: [97.20553]%\n",
232 |       "Test Data Accuracy: [97.626205]%\n",
233 |       "Test Data Accuracy: [96.484375]%\n"
234 |      ]
235 |     }
236 |    ],
237 |    "source": [
238 |     "for i in range(num_epoch):\n",
239 |     "    model.train()\n",
240 |     "    for j,[image,label] in enumerate(train_loader):\n",
241 |     "        x = Variable(image).cuda()\n",
242 |     "        y_= Variable(label).cuda()\n",
243 |     "        \n",
244 |     "        optimizer.zero_grad()\n",
245 |     "        output = model.forward(x)\n",
246 |     "        loss = loss_func(output,y_)\n",
247 |     "        loss.backward()\n",
248 |     "        optimizer.step()\n",
249 |     "        \n",
250 |     "         \n",
251 |     "    top_1_count = torch.FloatTensor([0])\n",
252 |     "    total = torch.FloatTensor([0])\n",
253 |     "    model.eval() \n",
254 |     "    for image,label in test_loader:\n",
255 |     "        x = Variable(image,volatile=True).cuda()\n",
256 |     "        y_= Variable(label).cuda()\n",
257 |     "\n",
258 |     "        output = model.forward(x)\n",
259 |     "        \n",
260 |     "        values,idx = output.max(dim=1)\n",
261 |     "        top_1_count += torch.sum(y_==idx).float().cpu().data\n",
262 |     "\n",
263 |     "        total += label.size(0)\n",
264 |     "\n",
265 |     "    print(\"Test Data Accuracy: {}%\".format(100*(top_1_count/total).numpy()))\n",
266 |     "    if (top_1_count/total).numpy() > 0.98:\n",
267 |     "        break\n",
268 |     "    "
269 |    ]
270 |   },
271 |   {
272 |    "cell_type": "code",
273 |    "execution_count": 8,
274 |    "metadata": {
275 |     "collapsed": true
276 |    },
277 |    "outputs": [],
278 |    "source": [
279 |     "class GuidedBackpropRelu(Function):\n",
280 |     "    @staticmethod\n",
281 |     "    def forward(ctx,input):\n",
282 |     "        ctx.save_for_backward(input)\n",
283 |     "        return input.clamp(min=0)\n",
284 |     "    \n",
285 |     "    @staticmethod\n",
286 |     "    def backward(ctx,grad_output):\n",
287 |     "        input = ctx.saved_tensors[0]\n",
288 |     "        grad_input = grad_output.clone()\n",
289 |     "        grad_input[grad_input<0] = 0\n",
290 |     "        grad_input[input<0]=0\n",
291 |     "        return grad_input\n",
292 |     "     \n",
293 |     "guided_relu = GuidedBackpropRelu.apply"
294 |    ]
295 |   },
296 |   {
297 |    "cell_type": "code",
298 |    "execution_count": 9,
299 |    "metadata": {
300 |     "collapsed": true
301 |    },
302 |    "outputs": [],
303 |    "source": [
304 |     "class GuidedReluModel:\n",
305 |     "    def __init__(self,model,to_be_replaced,replace_to):\n",
306 |     "        self.model = model\n",
307 |     "        self.to_be_replaced = to_be_replaced\n",
308 |     "        self.replace_to = replace_to\n",
309 |     "        self.layers=[]\n",
310 |     "        self.output=[]\n",
311 |     "        \n",
312 |     "        for m in self.model.modules():\n",
313 |     "            if isinstance(m,self.to_be_replaced):\n",
314 |     "                self.layers.append(self.replace_to )\n",
315 |     "                #self.layers.append(m)\n",
316 |     "            elif isinstance(m,nn.Conv2d):\n",
317 |     "                self.layers.append(m)\n",
318 |     "            elif isinstance(m,nn.BatchNorm2d):\n",
319 |     "                self.layers.append(m)\n",
320 |     "            elif isinstance(m,nn.Linear):\n",
321 |     "                self.layers.append(m)\n",
322 |     "            elif isinstance(m,nn.AvgPool2d):\n",
323 |     "                self.layers.append(m)\n",
324 |     "                \n",
325 |     "        for i in self.layers:\n",
326 |     "            print(i)\n",
327 |     "        \n",
328 |     "    def reset_output(self):\n",
329 |     "        self.output = []\n",
330 |     "    \n",
331 |     "    def hook(self,grad):\n",
332 |     "        out = grad[:,0,:,:].cpu().data#.numpy()\n",
333 |     "        print(\"out_size:\",out.size())\n",
334 |     "        self.output.append(out)\n",
335 |     "        \n",
336 |     "    def visualize(self,idx,origina_img):\n",
337 |     "        grad = self.output[0][idx]\n",
338 |     "        x = origina_img[idx].cpu().data.numpy()[0]\n",
339 |     "        \n",
340 |     "        plt.subplot(1,2,1)\n",
341 |     "        plt.imshow(grad,cmap=\"gray\")\n",
342 |     "        plt.subplot(1,2,2)\n",
343 |     "        plt.imshow(x,cmap=\"gray\")\n",
344 |     "        plt.show()\n",
345 |     "        \n",
346 |     "    def forward(self,x):\n",
347 |     "        out = x \n",
348 |     "        out.register_hook(self.hook)\n",
349 |     "        for i in self.layers[:-3]:\n",
350 |     "            out = i(out)\n",
351 |     "        out = out.view(out.size()[0],-1)\n",
352 |     "        for j in self.layers[-3:]:\n",
353 |     "            out = j(out)\n",
354 |     "        return out\n",
355 |     "        \n",
356 |     "        "
357 |    ]
358 |   },
359 |   {
360 |    "cell_type": "code",
361 |    "execution_count": 10,
362 |    "metadata": {
363 |     "scrolled": false
364 |    },
365 |    "outputs": [
366 |     {
367 |      "name": "stdout",
368 |      "output_type": "stream",
369 |      "text": [
370 |       "Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
371 |       "BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True)\n",
372 |       "<built-in method apply of FunctionMeta object at 0x3be8258>\n",
373 |       "Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
374 |       "BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
375 |       "<built-in method apply of FunctionMeta object at 0x3be8258>\n",
376 |       "AvgPool2d(kernel_size=2, stride=2, padding=0, ceil_mode=False, count_include_pad=True)\n",
377 |       "Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
378 |       "BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
379 |       "<built-in method apply of FunctionMeta object at 0x3be8258>\n",
380 |       "AvgPool2d(kernel_size=2, stride=2, padding=0, ceil_mode=False, count_include_pad=True)\n",
381 |       "Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
382 |       "BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
383 |       "<built-in method apply of FunctionMeta object at 0x3be8258>\n",
384 |       "Linear(in_features=12544, out_features=1000, bias=True)\n",
385 |       "<built-in method apply of FunctionMeta object at 0x3be8258>\n",
386 |       "Linear(in_features=1000, out_features=10, bias=True)\n"
387 |      ]
388 |     }
389 |    ],
390 |    "source": [
391 |     "guide = GuidedReluModel(model,nn.ReLU,guided_relu)"
392 |    ]
393 |   },
394 |   {
395 |    "cell_type": "code",
396 |    "execution_count": 11,
397 |    "metadata": {
398 |     "scrolled": false
399 |    },
400 |    "outputs": [
401 |     {
402 |      "name": "stdout",
403 |      "output_type": "stream",
404 |      "text": [
405 |       "out_size: torch.Size([128, 28, 28])\n"
406 |      ]
407 |     },
408 |     {
409 |      "data": {
410 |       "image/png": "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\n",
411 |       "text/plain": [
412 |        "<matplotlib.figure.Figure at 0x7f3e3c1e59b0>"
413 |       ]
414 |      },
415 |      "metadata": {},
416 |      "output_type": "display_data"
417 |     },
418 |     {
419 |      "data": {
420 |       "image/png": "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\n",
421 |       "text/plain": [
422 |        "<matplotlib.figure.Figure at 0x7f3e3385e6d8>"
423 |       ]
424 |      },
425 |      "metadata": {},
426 |      "output_type": "display_data"
427 |     },
428 |     {
429 |      "data": {
430 |       "image/png": "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\n",
431 |       "text/plain": [
432 |        "<matplotlib.figure.Figure at 0x7f3e3083af98>"
433 |       ]
434 |      },
435 |      "metadata": {},
436 |      "output_type": "display_data"
437 |     },
438 |     {
439 |      "data": {
440 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAFARJREFUeJzt3VuIXVWex/Hf35hKKiZ0jJeQxBi1jeP0yyiWOqIPDuLg+KI+NHYEURiofhhFxUsHL3QjDCp02z702JBW0QbHpkEdA8qMEhW7VcQYxEsyPYYYtZKYGKIxXnPxPw91ApXa/1W1V519Tp2z8v2AVNWqtfde+5xVf3fO+q+1zN0FAOh/R0x3AwAAzSCgA0AhCOgAUAgCOgAUgoAOAIUgoANAIQjoAFAIAjoAFKKtgG5ml5jZ38xso5mtbKpRwHSjb6Mf2VRniprZDEn/J+liSSOS3pS0wt3XN9c8oPvo2+hXR7Zx7DmSNrr7Jkkysz9JukxSstMPDAz44OBgrZPn/I/GzGofH9XtVBswqluv47fffqu9e/c28UZk920zYw0NdJS7T9q32wnoSyR9MubnEUnnTnTA4OCgzjvvvEPKUn/snQroRxxR/ZQpVfeHH36oda3UeUvQxFo/7b6Xqdd2fN1XX301r2Fp2X0b6AXtBPQoslX+cs1sWNKwJM2ePbuNywFdk923gV7QzmPliKSlY34+QdLW8ZXcfZW7D7n70MDAQBuXA7omu293rWXABNp5Qn9T0nIzO1nSFkk/k3TVRAe4e+VjjOhjDalzn0lH//xPtWH//v2VspyPXOp+VJBqV6c0Mb6Qcw/R65h6bWbMmNFWuxqS3beBXjDlgO7u+83sOkn/I2mGpEfc/f3GWgZME/o2+lU7T+hy9+ckPddQW4CeQd9GPyozNQMADkMEdAAoBAEdAArR1mfoucxMRx556CUPHDgQ1s3J+khlqdStm3N8p2aaRnLalTOxafx70JRUe6PMlZTpzgAC+hlP6ABQCAI6ABSCgA4AhSCgA0AhujoomiNncCxn8DAahE0dnzN4GJ0jNRgYTYWPpAY6o2ul6kavWWogut0p9jkrZ+YM4uasnAkczviLAIBCENABoBAEdAAoBAEdAApBQAeAQnQ9y2V8xkLOBhep7JBU1kYkZ9OKdqfep9pVd6/S1PWj8rqZMxOJ7iHnNUhl9XRquQSWBAAOxRM6ABSCgA4AhSCgA0AhCOgAUIi2BkXNbLOkPZIOSNrv7kOTHVN3ICtn3fKcgbsc0UBjzjIBqanpdQdmcwYTc6bBp+rmnCPnNW93bfvpmOI/lb4NTLcmslz+yd13NnAeoNfQt9FX+MgFAArRbkB3Sc+b2VtmNtxEg4AeQd9G32n3I5fz3X2rmR0v6QUz+193f2VshdYfw7AkzZ49u83LAV2T1beBXtDWE7q7b2193SHpaUnnBHVWufuQuw8NDAy0czmga3L7drfbB0Sm/IRuZkdJOsLd97S+/2dJd0923PiMhdSU9SjboYmp3jnZGe1mcrQ75T3n+NS0+5zNJaJzNJHN0qnMlU5N/Z9q3wamWzsfuSyU9HQr6Bwp6T/d/b8baRUwvejb6EtTDujuvknSPzTYFqAn0LfRr0hbBIBCENABoBA9ux56u2t+5wy6pc67b9++Stng4GBYN2fq/6xZsypldddIT0ldK1qTPVU3Z/mBnLXT211XPqe9wOGMJ3QAKAQBHQAKQUAHgEIQ0AGgEAR0AChE17Nc6mYm5GQ75Mg578yZMytlqfVoorqpe607HT8nwyRn2n2qbpTt08R5I6m6OfdGlgtwKJ7QAaAQBHQAKAQBHQAKQUAHgEJM+9T/lGhwLJpeL8WDeanp5jlT4SOpdcej3Zi+++67sG5UHi0HkLpWdA85g4yp+82Zop8jGrzs1FrmwOGMJ3QAKAQBHQAKQUAHgEIQ0AGgEJMGdDN7xMx2mNl7Y8oWmNkLZvZB6+vRnW0m0Dz6NkpTJ8vlUUm/k/THMWUrJa1x93vNbGXr519MdiJ3z9qkYrycqfSpjI0oc+Sbb74J65544om1jpekr7/+ulK2bdu2sG6U5TJv3rxK2VFHHRUeP2fOnLA8EmUGdWrKfOq1ieRk1HRw6v+jaqhvA71g0id0d39F0q5xxZdJeqz1/WOSLm+4XUDH0bdRmql+hr7Q3bdJUuvr8c01CZhW9G30rY5PLDKzYUnDUjz5BuhXY/s20Aum+oS+3cwWSVLr645URXdf5e5D7j4ULTEL9Jgp9e2utQ6YwFSf0FdLukbSva2vz9Q5yMwqg3TRNHYpHjRLTVmPBuNS540GCU8++eSw7ldffVUp++yzz8K60TkuuuiisO769esrZVu3bq2UpQaQo3/ppAYIv//++0pZagmFnMHlTonakDMY3oAp9e0SpAa1ly1bVilbtGhRWHfLli2Vso8//rhS1u1+dbiok7b4hKTXJf2dmY2Y2b9qtLNfbGYfSLq49TPQV+jbKM2kT+juviLxq/jxE+gT9G2UhpmiAFAIAjoAFIKADgCF6OoGF2ZWGUlPjaxHGR45WS4/+tGPwrpz586tlO3aNX6y4Khvv/22UnbeeeeFdc8888xK2dKlS8O6UUbMc889Vyn75JNPwuOjDJ7BwcGwbpTRksoOaXfzj1Q2SnTenCyHVLprp5YwOBwcc8wxlbLrr78+rHv11VdXyhYvXhzW3bBhQ6Xs2muvrZS98847k7QQU8ETOgAUgoAOAIUgoANAIQjoAFCIrg6KRnIGtlKDedHAX2rQbefOnZWyaHq8JK1YUZ13MjAwENaNBnmipQMkaf78+ZWyaHp1alA0Z0356LWJ1mOX4sHLnOn1OVP0c86bqtuhqf9FSQ0o33LLLZWy4eF4nbFNmzZVyhYsWBDWPfXUUytl0TIBDIp2Bk/oAFAIAjoAFIKADgCFIKADQCG6Pig6flZnam3uaIZiaoBn7969lbLUxs9ffPFFpSy1Hno08DMyMhLWjQZWo42jpXhmazTQGc1qleIZrDmbh+zbty8sj9qQmskbDaCm3ssc0cBqzobfOFRqo/Forf7UYHvUX1Izk6N1/T/99NOJmogG8YQOAIUgoANAIQjoAFAIAjoAFKLOnqKPmNkOM3tvTNmvzGyLmb3d+u/SzjYTaB59G6Wpk5bwqKTfSfrjuPLfuvuvcy84PjsiZ23ulGgUPjViH027T02xjzJaTjrppLBulOWSuodoSYD169fXqidJxx57bKXsyy+/DOvOnj27UpazhEKqbs466U1M8++QR9Vg3+5FUUaUJL3xxhuVstNPPz2se9ZZZ1XKUktgvPzyy5WyjRs3TtBCNGnSv0p3f0VSvAME0Mfo2yhNO5+hX2dm77T+2Xp0Yy0Cph99G31pqgH995J+LOkMSdsk/SZV0cyGzWytma2NJgABPWZKfbtbjQMmMqWA7u7b3f2Au/8g6Q+Szpmg7ip3H3L3odTnbkCvmGrf7l4LgbQpzdU2s0Xuvq314xWS3puo/kHuXhkoTA1eRgOKqfW2o6nhqUG7aCp0tByAJK1Zs6ZSlhqovOKKKypl5557blj3wQcfrJRFA7CpDamjqdQ5a4bnDGimBnajc6TOG70/qWn7OW3rhKn27V6VWuv/3nvvrZS9+OKLYd1bb721UpYaQI02O4/64AknnBAeH/XtnPX/D3eTBnQze0LShZKONbMRSb+UdKGZnSHJJW2W9PMOthHoCPo2SjNpQHf36rY90sMdaAvQVfRtlIaZogBQCAI6ABSCgA4Ahej6BhfjM1VyshpSWS7tZlykpvOvXVtNL162bFlY95RTTqmURdOrJenpp5+ulF1wwQWVsrvuuis8/r777quUffjhh2Hd6H5TG0bkvI7Re5F6f6KMltR5m9gkA5PbsmVLpSw1TyTKaHn++efDulFm2PLlyytl1113XXj8nXfeWSnbvn17WBdVPKEDQCEI6ABQCAI6ABSCgA4AheirEajU9PZoPfRoHXApXks8WotcigfzVqyI5qJIc+bMqZQ9++yzYd0lS5ZUyqIlCR566KHw+GipgtQgY7vTplODlNH1Zs6cGdaN3recqf/R+yulB2ExuaOPri4ief3114d1o/72wAMPhHU///zzSlm0Jvs999xT+3jUxxM6ABSCgA4AhSCgA0AhCOgAUAgCOgAUoutZLuOnnacyGHI2rYikpsLPmzevUnbccceFda+66qpKWSrL5Y477qiUbd68Oax7/PHHV8qiTIDXX389PD7KJsmZSv/dd9+FdXN2lIqul8pCit7LVIZKVJ66t+neDKMfpDKPhoeHK2Xnn39+WPfuu++ulK1bt652G6L+tmnTptrHoz7+IgCgEAR0ACgEAR0ACjFpQDezpWb2kpltMLP3zeyGVvkCM3vBzD5ofa1OPQN6GH0bpakzKLpf0s3uvs7M5kl6y8xekHStpDXufq+ZrZS0UtIvJjvZ+IGsnHXLUwOokdTU8mgt8ptuuimse9ttt1XKvvrqq7Dua6+9VinbuXNnWPfss8+ulH300UeVstNOOy08fteuXZWyr7/+OqwbDYqm1r3OWQ89NQBa14EDB2q3od1rTaDRvt2L5s+fH5ZfeeWVlbKRkZGw7urVqytlqT5U16xZs8LyaKmKVF9B1aRP6O6+zd3Xtb7fI2mDpCWSLpP0WKvaY5Iu71QjgU6gb6M0WZ+hm9lJks6U9Iakhe6+TRr9w5BUzcUD+gR9GyWonYduZnMlPSnpRnf/su5Kd2Y2LGlYSq+ACEynJvo20AtqPaGb2UyNdvjH3f2pVvF2M1vU+v0iSTuiY919lbsPuftQzsQVoBua6tvdaS0wsTpZLibpYUkb3P3+Mb9aLema1vfXSHqm+eYBnUPfRmlssgwCM7tA0l8kvSvpYOrJ7Rr9rPHPkk6U9LGkn7p7Nf1ijPnz5/v43e2/+eabsG6U5ZJqa3SO1L8GomnIqanwUebIjh3hw5qWLl1aKVu2bFlYN8oQiNqQmrYdGRwcDMu///77WteS4gyT1AYXkVRmUfQRRupjjSj7IeoL0fVeffVV7d69u/auF032bTPrWCoOIEnuPmnfnvSv1d3/Kil1ootyGwX0Cvo2SsNMUQAoBAEdAApBQAeAQnR9PfRKAxKDbtE0/9QU4Ci/PbVMQDR4mBqgi663cOHCsO7ixYsrZanpzXV3No8GNCc6byQaUEy9jnXzr1PnTYkGS5tYOx3AoXhCB4BCENABoBAEdAAoBAEdAApBQAeAQkx7lksqWyInsyFaFH/u3Llh3Xnz5lXKdu/eXbtudK1UeWozjDlz5lTKotchda0c0XlzpujnbC6R2gwjymTKyZIBUA9P6ABQCAI6ABSCgA4AhSCgA0Ahpn1QNDWQFg3cpQbSosHDVN1o2ns0+JmSmo4flacGH6OlCqLBxz179oTHp16zSM565jnnbXdQM3Wt6HVIDZDnDNgChwOe0AGgEAR0ACgEAR0AClFnk+ilZvaSmW0ws/fN7IZW+a/MbIuZvd3679LONxdoDn0bpakzYrZf0s3uvs7M5kl6y8xeaP3ut+7+6841D+go+jaKUmeT6G2StrW+32NmGyQtmcrF3L12dkSUITIwMDCVyx4i2lwilY2S2ggiMnPmzEpZKiMmeg2irI+cDKBUJkjda6WkMkmi7JlOtSHVZ3LOEWmybwO9IOsvwsxOknSmpDdaRdeZ2Ttm9oiZHd1w24CuoW+jBLUDupnNlfSkpBvd/UtJv5f0Y0lnaPQp5zeJ44bNbK2Zrd27d28DTQaa1UTf7lpjgQnUCuhmNlOjHf5xd39Kktx9u7sfcPcfJP1B0jnRse6+yt2H3H2oiY9MgCY11be712IgrU6Wi0l6WNIGd79/TPmiMdWukPRe880DOoe+jdLUyXI5X9LVkt41s7dbZbdLWmFmZ0hySZsl/XyyE5lZZTAtNeCVMwV81qxZlbJ9+/aFdaPBy5Ro0C2ati/F95G6VmoQdrzU/UbnTQ1edmrd8ahtOVP0c9a7z6mbqbG+DfSCOlkuf5UU/UU913xzgO6hb6M0zBQFgEIQ0AGgEAR0ACgEAR0ACtH1DS7GZyzkTN9OZYdE5am60fVyMkFSG0ZEmRw5SwfkXCtHTjZK3eObaEPO5hSpuh3MfgH6Ek/oAFAIAjoAFIKADgCFIKADQCGsmzunm9lnkj5q/XispJ1du3j3cF/TZ5m7HzcdFx7Tt/vhdZqqUu+tH+6rVt/uakA/5MJma0tcpY77OryV/DqVem8l3RcfuQBAIQjoAFCI6Qzoq6bx2p3EfR3eSn6dSr23Yu5r2j5DBwA0i49cAKAQXQ/oZnaJmf3NzDaa2cpuX79JrR3hd5jZe2PKFpjZC2b2Qetr3+0Yb2ZLzewlM9tgZu+b2Q2t8r6/t04qpW/Tr/vv3g7qakA3sxmS/kPSv0j6iUa3+vpJN9vQsEclXTKubKWkNe6+XNKa1s/9Zr+km9397yX9o6R/a71PJdxbRxTWtx8V/bovdfsJ/RxJG919k7vvlfQnSZd1uQ2NcfdXJO0aV3yZpMda3z8m6fKuNqoB7r7N3de1vt8jaYOkJSrg3jqomL5Nv+6/ezuo2wF9iaRPxvw80ioryUJ33yaNdiBJx09ze9piZidJOlPSGyrs3hpWet8u6r0vtV93O6BHC1iTZtOjzGyupCcl3ejuX053e3ocfbtPlNyvux3QRyQtHfPzCZK2drkNnbbdzBZJUuvrjmluz5SY2UyNdvrH3f2pVnER99YhpfftIt770vt1twP6m5KWm9nJZjYg6WeSVne5DZ22WtI1re+vkfTMNLZlSmx0K6CHJW1w9/vH/Krv762DSu/bff/eHw79uusTi8zsUkkPSJoh6RF3//euNqBBZvaEpAs1ulrbdkm/lPRfkv4s6URJH0v6qbuPH2DqaWZ2gaS/SHpX0sH9+W7X6OeNfX1vnVRK36Zf99+9HcRMUQAoBDNFAaAQBHQAKAQBHQAKQUAHgEIQ0AGgEAR0ACgEAR0ACkFAB4BC/D88kJhG0Y2j9AAAAABJRU5ErkJggg==\n",
441 |       "text/plain": [
442 |        "<matplotlib.figure.Figure at 0x7f3e1c884518>"
443 |       ]
444 |      },
445 |      "metadata": {},
446 |      "output_type": "display_data"
447 |     },
448 |     {
449 |      "data": {
450 |       "image/png": "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\n",
451 |       "text/plain": [
452 |        "<matplotlib.figure.Figure at 0x7f3e2183ec88>"
453 |       ]
454 |      },
455 |      "metadata": {},
456 |      "output_type": "display_data"
457 |     },
458 |     {
459 |      "data": {
460 |       "image/png": "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\n",
461 |       "text/plain": [
462 |        "<matplotlib.figure.Figure at 0x7f3e1c8a3710>"
463 |       ]
464 |      },
465 |      "metadata": {},
466 |      "output_type": "display_data"
467 |     },
468 |     {
469 |      "data": {
470 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAE5RJREFUeJzt3XuInFWax/HfY0zH1qiJZr0Qow5ed1DWS+MK+keCuLiOoAOO6IJkYSTzx4oXvEzwnxFBFJlxFpx1JIPBDLiO42W8gDhqvERlDcYQEjWOikZtE0xExWiisfXZP1KBtt/nJHW63nqr6uT7gdDdp5+qOm/Vqaff1HPOec3dBQAYfHv0ugMAgHqQ0AGgECR0ACgECR0ACkFCB4BCkNABoBAkdAAoBAkdAArRUUI3s3PM7B9m9q6ZLayrU0CvMbYxiGyyK0XNbIqktyWdLWlU0quSLnH3N+vrHtA8xjYG1Z4d3PY0Se+6+3uSZGZ/kXS+pOSgnzZtmg8PD3fwkLF+2L7AzCpt/dCvTkXH1a+2bNmibdu21dHh7LFtZoP/YqOvufsux3YnCX22pI/G/Twq6V93doPh4WHNnTv3R20//PBDGJtq7zS2W/bYo/rpVaf9Sv1BiNqjx0/1IRUbScXm/AHL+aPQyR+QZcuWTfq2E2SPbaAfdJLQo3de5R1tZgskLZC2J3RgAGSPbaAfdFIUHZU0Z9zPh0laPzHI3Re5+4i7jwwNDXXwcEBjssd2Yz0DdqKTM/RXJR1jZj+R9LGkiyX9Ry29yhT9Vz/1X/ec2Bzd+Igo5zP4Oj66ih6vjo99cj6OmjJlys66+CNd/Hy/b8Y2kGPSCd3dx8zsckl/lzRF0mJ3f6O2ngE9wtjGoOrkDF3u/oSkJ2rqC9A3GNsYRKwUBYBCkNABoBAkdAAoREefoXdTPy5cqUs06yNnhknOcxO1p2aY5MwA6ofnsR/6APQTztABoBAkdAAoBAkdAApBQgeAQvS8KDo2NtZ2bE7hr1tL/7vVh5y4qKiZs01AHbGdFqJznsfUdgAlbE8M1IkzdAAoBAkdAApBQgeAQpDQAaAQJHQAKETjs1wmzkzIWYb+/fffh7HRfaRmRkQzLlIzNnKuvRlJzcJod+l/ziyZOi6G0elslDr62+k1UIHdGe8UACgECR0ACkFCB4BCkNABoBAdFUXNbJ2kzZK+lzTm7iO595FTFM25gn2qgDp16tSO7iOnoJjSbvEx53hzHitVZMw5hiYLlXVsP5CrjrENNK2OWS7z3P3TGu4H6DeMbQwUPnIBgEJ0mtBd0lNm9pqZLaijQ0CfYGxj4HT6kcsZ7r7ezA6S9LSZveXuy8YHtN4MCyRpeHi4w4cDGpM1toF+0NEZuruvb33dKOlvkk4LYha5+4i7jwwNDXXycEBjcsd20/0DIpM+QzezfSTt4e6bW9//m6SbdnGbyuyInOXiqeX80WyUPfeMDy1ndkbOMvROl7fnbHWQI5rVU8cFIzrdfiBH6nlIvcadmszYBvpBJ++IgyX9rZWQ95T0v+7+ZC29AnqLsY2BNOmE7u7vSfqXGvsC9AXGNgYV0xYBoBAkdAAoRKP7obt7pSCYsxd5zv7iqfvN2Ts91d6unKX7ObE5e5FHBcWc5yan0JkqXuYUoqNCJ/uhA+3hnQIAhSChA0AhSOgAUAgSOgAUgoQOAIVodJaLVJ1hUccMhk6X6KdE91HHRSei+xgbG6u0pWaNRLNUUhfuiI439dxs27at0pZzQY/UUvyoDzlbM3Q62wjYXXCGDgCFIKEDQCFI6ABQCBI6ABSi8aLoRDlFtxyp4mfOPus59xsVMKNCZ87jpZ6bqD1VQJ0+fXqlbdq0aWFsVFj9+uuvw9icYnbUtzqKy93aDx0YVJyhA0AhSOgAUAgSOgAUgoQOAIXYZUI3s8VmttHMXh/XdoCZPW1m77S+zuxuN4H6MbZRmnamCdwj6Q+S/jyubaGkpe5+q5ktbP3863YecOIskZzZEqkZJp3OiMmZTZKKjZbN51yQI6dfkeHh4bZjt2zZErZ/+OGHlba99torjI36lpp1Et1H6jlo8gIkqnlsA722y8zi7sskfTah+XxJS1rfL5F0Qc39ArqOsY3STPYz9IPdfYMktb4eVF+XgJ5ibGNgdX1lhpktkLRAyvtYAOh348c20A8me4b+iZkdKkmtrxtTge6+yN1H3H1kaGhokg8HNGZSY7ux3gE7Mdkz9MckzZd0a+vro7X1qCUqKNZRFM2JjR4vp1CZeqyc/czbdeCBB4btmzZtqrQtXbo0jJ0zZ06lLbX0f+vWrZW2o446KoyNiqWpAmr03HRa9M7U9bENdEs70xbvk/R/ko4zs1Ez+6W2D/azzewdSWe3fgYGCmMbpdnlGbq7X5L41Vk19wVoFGMbpWGlKAAUgoQOAIUgoQNAIfr2CgE5y+6jZeSpmRGpmTKRnAsz5MzOiPobbR2Qun00Q+TJJ58MY/fZZ59K27PPPhvGzps3r9J24403hrH3339/2B6JlujnbIuQ85ph93HkkUdW2pYsWVINlHT00UdX2q644oow9qGHHuqoX73EGToAFIKEDgCFIKEDQCFI6ABQiL4tiuYUwnKW6EeFxlRsVBQdGxsLY6PCX2o5f9SH6H733nvv8Pbr16+vtO23335h7NVXX912v6677rpK2yuvvBLGRvvypPoQbR/Q6VYHEsXS3UVU2JekSy6prgubMWNGGHvttddW2p544onOOtaHOEMHgEKQ0AGgECR0ACgECR0ACtF4UXRiISsqPEZxqTYpb5VmTmy0IjNVzItWOKb2/P7uu+8qbVEBNFo9Kklr166ttF166aVh7BFHHFFpu/POO8PYNWvWVNpSF4lOFUAj06ZNq7SlXveclaIN75OOBkSv6UUXXRTGRkXRm266KYx95JFHKm2pCQ6DjDN0ACgECR0ACkFCB4BCkNABoBDtXFN0sZltNLPXx7XdaGYfm9mq1r9zu9tNoH6MbZSmnVku90j6g6Q/T2j/vbv/NvcBuzEzIVq6n7Mfes4S8pyr1adio+p6NLtjdHQ0vP1ZZ1UveRntZS5JDzzwQKVt9erVYezmzZsrbdESf6n9Y0i1p2bPRFJbM9TgHtU4ttG5aFZWat/yaE/+xx9/PIwtcUZLZJdn6O6+TNJnDfQFaBRjG6Xp5DP0y81sdeu/rTNr6xHQe4xtDKTJJvQ/SjpK0kmSNkj6XSrQzBaY2QozW5FaKAP0kUmN7aY6B+zMpBK6u3/i7t+7+w+S/iTptJ3ELnL3EXcfSX0eC/SLyY7t5noIpE1q6b+ZHeruG1o//lzS6zuLn3Dbnf68Q7S/eEq39sXOKbZGsalCTPSH7csvv2y7X6effnqlLVWA3bhxY6XthBNOCGOj4uX7778fxn7++eeVttRrFm1rkFr6H20T0GRBq5OxjfalCujRcv6ZM+NPvZ5//vlK2yGHHBLGRu/bTz/9NIz96quvwvZBsMuEbmb3SZoraZaZjUr6jaS5ZnaSJJe0TtKvuthHoCsY2yjNLhO6u1f/ZEp3d6EvQKMY2ygNK0UBoBAkdAAoBAkdAArR8wtcpGaodOtCB9F95CxZT4liU/2KLnDxzTffVNpmz54d3v6www6rtK1bty6MjWa0nHzyyWFsNBvlzTffDGMffPDBStvXX38dxn777beVtlmzZoWx0YyW1OyZbs1uQvdFY02Szj23unVOapbLNddcU2k75phjwthoFtiLL74Yxt58882Vtg8++CCM7TecoQNAIUjoAFAIEjoAFIKEDgCF6HlRNFU4jNo7LX5Kecv5I6lCaaf7oUe3Tx1DtGw+tWd4tEQ/VeiMCpXHHXdcGHveeedV2l566aUwNtqUbXh4OIyNCsYUP8uTKnTvu+++lbb99tsvjD3wwAMrbatWrQpjo33WL7zwwjA2mqBw/fXXtx3bS5yhA0AhSOgAUAgSOgAUgoQOAIUgoQNAIfp2lkvOsvscOTNaIqnZJFF76iIOUR9mzJhRaduyZUt4+2j2zAEHHBDGvvfee5W2l19+OYyNZt9cdtllYezPfvazSltqKXUktU1AdIGLlE5fS/RONJtJkj77rHrN7tHR0TA2Wvr/9ttvh7HHHntspe22224LY+fNm1dpS820YZYLAKArSOgAUAgSOgAUYpcJ3czmmNlzZrbWzN4wsytb7QeY2dNm9k7ra7zHJdCnGNsoTTtF0TFJ17j7SjPbV9JrZva0pP+UtNTdbzWzhZIWSvp1bgdylv6n5CwNjwqVOdsEpJYsR/ebWvoftUcFyVRRdNOmTZW2M888M4x95plnKm0nnnhiGBstpY7aJOmpp56qtKWKwDmi5yH1PNagq2MbaamxvXz58krbKaecEsbOnz+/0rb//vuHsccff3yl7dRTTw1j77333krbV199Fcb2m12eobv7Bndf2fp+s6S1kmZLOl/SklbYEkkXdKuTQDcwtlGarM/QzexISSdLWi7pYHffIG1/Y0g6qO7OAU1hbKMEbf9f1symS3pI0lXu/mW7H4mY2QJJC6T0DntAL9UxtoF+0NYZuplN1fYBf6+7P9xq/sTMDm39/lBJG6Pbuvsidx9x95GhoaE6+gzUpq6x3UxvgZ1rZ5aLSbpb0lp3v33crx6TtKMqMV/So/V3D+gexjZK085HLmdIulTSGjPbsXv8DZJulfRXM/ulpA8l/aKdB2x3SX8086SOi2FEs1RyZsnkbEmQut/oPqL+pmYCLF68uNI2derUMPaWW26ptEXbAUjShg0bKm2pZderV6+utE2fPj2MjfqWWvqd8/rUsPS/1rGNzt11112VtsMPPzyMvfjiiyttqbESbTVxxx13hLHRlgBbt24NY/vNLhO6u78kKfXOOave7gDNYWyjNKwUBYBCkNABoBAkdAAohDV5RfUZM2b43Llzf9SWWi6es4w8VRBs935Te5xHz03O85VTxI2Kgd9++214+6hAM2fOnDA2KgZFe6+nYt96660wdubM6vYms2bNCmNznvOoPbX0f+Lz+MILL+iLL77oySbpZtbcG6lg0XsjtUR/r732qrSlluhH7R999FEYm3rf9Zq773Jsc4YOAIUgoQNAIUjoAFAIEjoAFIKEDgCF6NqVA9qVWkofzYyoY9l9NIsiZ2l5HVeaj44jOt7UZmbRRSBSFftoif3KlSvD2GnTprXVLyme0RLdXspbNh3NaMm5qAgGW/ReXLFiRQ96Mpg4QweAQpDQAaAQJHQAKAQJHQAK0XhRdGJRMqd4mVMUTcm5gny7xcuUnNioX6njjYqlqdhomX9q6X8kdb9RATRV/Ixey1ShMyo6N7k9BTDIOEMHgEKQ0AGgECR0AChEOxeJnmNmz5nZWjN7w8yubLXfaGYfm9mq1r9zu99doD6MbZSmnQrhmKRr3H2lme0r6TUze7r1u9+7+2+71z2gqxjbKEo7F4neIGlD6/vNZrZW0uzJPuDEWQyppfTR7IrUjIucC1HUsXS/XamZHJHo2FJ9jWaYpC7yEbWnYr/55pu2Y6MZPDnPebcuFJKj7rEN9FrWZ+hmdqSkkyUtbzVdbmarzWyxmVUvYQMMCMY2StB2Qjez6ZIeknSVu38p6Y+SjpJ0kraf5fwucbsFZrbCzFZs27athi4D9apjbDfWWWAn2kroZjZV2wf8ve7+sCS5+yfu/r27/yDpT5JOi27r7ovcfcTdR1K7BwK9UtfYbq7HQFo7s1xM0t2S1rr77ePaDx0X9nNJr9ffPaB7GNsoTTuzXM6QdKmkNWa2qtV2g6RLzOwkSS5pnaRftfOA7RayoqXwTRY0pbxia04RNyooRsvjcwrGqdjoflOiAmjq9tHzUEfxMud5qEGtYxvotXZmubwkKXpHPVF/d4DmMLZRGlaKAkAhSOgAUAgSOgAUgoQOAIVo/AIXnVysoFsXOkjdb9SeM2skFdvuUvixsbHw9tEsl9RjdXpRkNT2BTmvRaczYpqe3QQMKs7QAaAQJHQAKAQJHQAKQUIHgEJYk1dUN7NNkj5o/ThL0qeNPXhzOK7eOcLd/6kXDzxubA/C8zRZpR7bIBxXW2O70YT+owc2W1HiLnUc1+6t5Oep1GMr6bj4yAUACkFCB4BC9DKhL+rhY3cTx7V7K/l5KvXYijmunn2GDgCoFx+5AEAhGk/oZnaOmf3DzN41s4VNP36dWleE32hmr49rO8DMnjazd1pfB+6K8WY2x8yeM7O1ZvaGmV3Zah/4Y+umUsY243rwjm2HRhO6mU2R9D+S/l3ST7X9Ul8/bbIPNbtH0jkT2hZKWurux0ha2vp50IxJusbd/1nS6ZL+q/U6lXBsXVHY2L5HjOuB1PQZ+mmS3nX399x9m6S/SDq/4T7Uxt2XSfpsQvP5kpa0vl8i6YJGO1UDd9/g7itb32+WtFbSbBVwbF1UzNhmXA/ese3QdEKfLemjcT+PttpKcrC7b5C2DyBJB/W4Px0xsyMlnSxpuQo7tpqVPraLeu1LHddNJ/RoY2um2fQpM5su6SFJV7n7l73uT59jbA+Iksd10wl9VNKccT8fJml9w33otk/M7FBJan3d2OP+TIqZTdX2QX+vuz/cai7i2Lqk9LFdxGtf+rhuOqG/KukYM/uJmQ1JuljSYw33odsekzS/9f18SY/2sC+TYtsvEXS3pLXufvu4Xw38sXVR6WN74F/73WFcN76wyMzOlfTfkqZIWuzuNzfagRqZ2X2S5mr7bm2fSPqNpEck/VXS4ZI+lPQLd59YYOprZnampBclrZG049p2N2j7540DfWzdVMrYZlwP3rHtwEpRACgEK0UBoBAkdAAoBAkdAApBQgeAQpDQAaAQJHQAKAQJHQAKQUIHgEL8P0bud3J+YqEUAAAAAElFTkSuQmCC\n",
471 |       "text/plain": [
472 |        "<matplotlib.figure.Figure at 0x7f3e1c8971d0>"
473 |       ]
474 |      },
475 |      "metadata": {},
476 |      "output_type": "display_data"
477 |     },
478 |     {
479 |      "data": {
480 |       "image/png": "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\n",
481 |       "text/plain": [
482 |        "<matplotlib.figure.Figure at 0x7f3e1c8a3f28>"
483 |       ]
484 |      },
485 |      "metadata": {},
486 |      "output_type": "display_data"
487 |     },
488 |     {
489 |      "data": {
490 |       "image/png": "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\n",
491 |       "text/plain": [
492 |        "<matplotlib.figure.Figure at 0x7f3e1506f550>"
493 |       ]
494 |      },
495 |      "metadata": {},
496 |      "output_type": "display_data"
497 |     },
498 |     {
499 |      "data": {
500 |       "image/png": "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\n",
501 |       "text/plain": [
502 |        "<matplotlib.figure.Figure at 0x7f3d86fe1cf8>"
503 |       ]
504 |      },
505 |      "metadata": {},
506 |      "output_type": "display_data"
507 |     }
508 |    ],
509 |    "source": [
510 |     "guide.reset_output()\n",
511 |     "for image,label in test_loader:\n",
512 |     "    x = Variable(image,requires_grad=True).cuda()\n",
513 |     "    y_= Variable(label).cuda()\n",
514 |     "        \n",
515 |     "    output = guide.forward(x)  \n",
516 |     "    output = torch.sum(output)\n",
517 |     "    \n",
518 |     "    output.backward()\n",
519 |     "    for idx in range(10):\n",
520 |     "        guide.visualize(idx,x)\n",
521 |     "    \n",
522 |     "    break"
523 |    ]
524 |   }
525 |  ],
526 |  "metadata": {
527 |   "kernelspec": {
528 |    "display_name": "Python 3",
529 |    "language": "python",
530 |    "name": "python3"
531 |   },
532 |   "language_info": {
533 |    "codemirror_mode": {
534 |     "name": "ipython",
535 |     "version": 3
536 |    },
537 |    "file_extension": ".py",
538 |    "mimetype": "text/x-python",
539 |    "name": "python",
540 |    "nbconvert_exporter": "python",
541 |    "pygments_lexer": "ipython3",
542 |    "version": "3.6.3"
543 |   }
544 |  },
545 |  "nbformat": 4,
546 |  "nbformat_minor": 2
547 | }
548 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # [Grad-CAM-Pytorch](https://github.com/GunhoChoi/Grad-CAM-Pytorch/blob/master/%E1%84%8E%E1%85%AC%E1%84%80%E1%85%A5%E1%86%AB%E1%84%92%E1%85%A9_GoogleColab_GradCAM.pdf)
 2 | 
 3 | 
 4 | 
 5 | 1. Understanding how hook is used in PyTorch([Module](./hook_practice/Module_Hook_Practice.ipynb)/[Variable](./hook_practice/Variable_Hook_Practice.ipynb))
 6 | 
 7 | <img src="./hook_practice/asset/hook.jpeg" width="500">
 8 | 
 9 | 2. [Class Activation Map(CAM) with MNIST](./CAM_MNIST.ipynb)
10 | 
11 | <img src="./cam_max.png" width="500">
12 | 
13 | 3. Guided Backpropagation with Custom Activation Function([Guided Backpropagation Practice](./guided_backprop_practice/Guided_Backpropagation.ipynb))
14 | 
15 | <img src="./guided_backprop_practice/guided_backprop.jpg" width="500">
16 | 
17 | 4. [Guided BackPropagation with MNIST](./GuidedBackprop_MNIST.ipynb
18 | )
19 | 
20 | <img src="./guided_backprop_practice/Guidedbackprop.png" width="500">
21 | 
22 | 5. [Grad-CAM with MNIST](https://github.com/GunhoChoi/Grad-CAM-Pytorch/blob/master/GradCAM_MNIST.ipynb)
23 | 
24 | <img src ="./gradcam.png" width="500">
25 | 


--------------------------------------------------------------------------------
/cam_max.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/cam_max.png


--------------------------------------------------------------------------------
/gradcam.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/gradcam.png


--------------------------------------------------------------------------------
/guided_backprop_practice/Guided_Backpropagation.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Guided Backpropagation\n",
  8 |     "\n",
  9 |     "- ReLU\n",
 10 |     "- Deconvnet ReLU\n",
 11 |     "- Guided Backpropagation ReLU\n",
 12 |     "\n",
 13 |     "![alt_text](./guided_backprop.jpg)\n",
 14 |     "\n",
 15 |     "## 1) Import Required Libraries"
 16 |    ]
 17 |   },
 18 |   {
 19 |    "cell_type": "code",
 20 |    "execution_count": 1,
 21 |    "metadata": {
 22 |     "collapsed": true
 23 |    },
 24 |    "outputs": [],
 25 |    "source": [
 26 |     "import torch\n",
 27 |     "import torch.nn as nn\n",
 28 |     "import torch.nn.functional as F\n",
 29 |     "\n",
 30 |     "from torch.autograd import Function \n",
 31 |     "from torch.autograd import Variable"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "markdown",
 36 |    "metadata": {},
 37 |    "source": [
 38 |     "## 2) Data"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "code",
 43 |    "execution_count": 2,
 44 |    "metadata": {},
 45 |    "outputs": [
 46 |     {
 47 |      "name": "stdout",
 48 |      "output_type": "stream",
 49 |      "text": [
 50 |       "Input X:\n",
 51 |       " 3  1  5\n",
 52 |       "-2  5 -7\n",
 53 |       " 3  2 -4\n",
 54 |       "[torch.FloatTensor of size 3x3]\n",
 55 |       " \n",
 56 |       " Target Y:\n",
 57 |       " 2  2  2\n",
 58 |       " 2  2  2\n",
 59 |       " 2  2  2\n",
 60 |       "[torch.FloatTensor of size 3x3]\n",
 61 |       "\n",
 62 |       "Gradient of X: None\n",
 63 |       "\n"
 64 |      ]
 65 |     }
 66 |    ],
 67 |    "source": [
 68 |     "x = torch.Tensor([[3,1,5],[-2,5,-7],[3,2,-4]])\n",
 69 |     "\n",
 70 |     "x = Variable(x,requires_grad=True)\n",
 71 |     "y = Variable(2*torch.ones(3,3))\n",
 72 |     "\n",
 73 |     "print(\"Input X:{} \\n Target Y:{}\".format(x.data,y.data))\n",
 74 |     "print(\"Gradient of X: {}\\n\".format(x.grad))"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "markdown",
 79 |    "metadata": {},
 80 |    "source": [
 81 |     "## 3-1) ReLU"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 3,
 87 |    "metadata": {},
 88 |    "outputs": [
 89 |     {
 90 |      "name": "stdout",
 91 |      "output_type": "stream",
 92 |      "text": [
 93 |       "Input X:\n",
 94 |       " 3  1  5\n",
 95 |       "-2  5 -7\n",
 96 |       " 3  2 -4\n",
 97 |       "[torch.FloatTensor of size 3x3]\n",
 98 |       " \n",
 99 |       " Target Y:\n",
100 |       " 2  2  2\n",
101 |       " 2  2  2\n",
102 |       " 2  2  2\n",
103 |       "[torch.FloatTensor of size 3x3]\n",
104 |       "\n",
105 |       "Output: \n",
106 |       " 3  1  5\n",
107 |       " 0  5  0\n",
108 |       " 3  2  0\n",
109 |       "[torch.FloatTensor of size 3x3]\n",
110 |       "\n",
111 |       "Loss: \n",
112 |       " 1  1  3\n",
113 |       " 2  3  2\n",
114 |       " 1  0  2\n",
115 |       "[torch.FloatTensor of size 3x3]\n",
116 |       "\n",
117 |       "Variable containing:\n",
118 |       " 1 -1  1\n",
119 |       " 0  1  0\n",
120 |       " 1  0  0\n",
121 |       "[torch.FloatTensor of size 3x3]\n",
122 |       "\n"
123 |      ]
124 |     }
125 |    ],
126 |    "source": [
127 |     "x = torch.Tensor([[3,1,5],[-2,5,-7],[3,2,-4]])\n",
128 |     "\n",
129 |     "x = Variable(x,requires_grad=True)\n",
130 |     "y = Variable(2*torch.ones(3,3))\n",
131 |     "\n",
132 |     "print(\"Input X:{} \\n Target Y:{}\".format(x.data,y.data))\n",
133 |     "\n",
134 |     "out = F.relu(x) \n",
135 |     "\n",
136 |     "print(\"Output: {}\".format(out.data))\n",
137 |     "\n",
138 |     "loss = torch.abs(out-y)\n",
139 |     "print(\"Loss: {}\".format(loss.data))\n",
140 |     "loss = torch.sum(loss)\n",
141 |     "loss.backward()\n",
142 |     "\n",
143 |     "print(x.grad)"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "markdown",
148 |    "metadata": {},
149 |    "source": [
150 |     "## 3-2) MyReLU\n",
151 |     "\n",
152 |     "http://pytorch.org/tutorials/beginner/examples_autograd/two_layer_net_custom_function.html"
153 |    ]
154 |   },
155 |   {
156 |    "cell_type": "code",
157 |    "execution_count": 4,
158 |    "metadata": {
159 |     "collapsed": true
160 |    },
161 |    "outputs": [],
162 |    "source": [
163 |     "class MyReLU(torch.autograd.Function):\n",
164 |     "    \"\"\"\n",
165 |     "    We can implement our own custom autograd Functions by subclassing\n",
166 |     "    torch.autograd.Function and implementing the forward and backward passes\n",
167 |     "    which operate on Tensors.\n",
168 |     "    \"\"\"\n",
169 |     "\n",
170 |     "    @staticmethod\n",
171 |     "    def forward(ctx, input):\n",
172 |     "        \"\"\"\n",
173 |     "        In the forward pass we receive a Tensor containing the input and return\n",
174 |     "        a Tensor containing the output. ctx is a context object that can be used\n",
175 |     "        to stash information for backward computation. You can cache arbitrary\n",
176 |     "        objects for use in the backward pass using the ctx.save_for_backward method.\n",
177 |     "        \"\"\"\n",
178 |     "        ctx.save_for_backward(input)\n",
179 |     "        return input.clamp(min=0)\n",
180 |     "\n",
181 |     "    @staticmethod\n",
182 |     "    def backward(ctx, grad_output):\n",
183 |     "        \"\"\"\n",
184 |     "        In the backward pass we receive a Tensor containing the gradient of the loss\n",
185 |     "        with respect to the output, and we need to compute the gradient of the loss\n",
186 |     "        with respect to the input.\n",
187 |     "        \"\"\"\n",
188 |     "        input, = ctx.saved_tensors\n",
189 |     "        grad_input = grad_output.clone()\n",
190 |     "        print(\"grad_input: \",grad_input)\n",
191 |     "        grad_input[input < 0] = 0\n",
192 |     "        return grad_input\n",
193 |     "    \n",
194 |     "my_relu = MyReLU.apply"
195 |    ]
196 |   },
197 |   {
198 |    "cell_type": "code",
199 |    "execution_count": 5,
200 |    "metadata": {},
201 |    "outputs": [
202 |     {
203 |      "name": "stdout",
204 |      "output_type": "stream",
205 |      "text": [
206 |       "Input X:\n",
207 |       " 3  1  5\n",
208 |       "-2  5 -7\n",
209 |       " 3  2 -4\n",
210 |       "[torch.FloatTensor of size 3x3]\n",
211 |       "\n",
212 |       "grad_input:  Variable containing:\n",
213 |       " 1 -1  1\n",
214 |       "-1  1 -1\n",
215 |       " 1  0 -1\n",
216 |       "[torch.FloatTensor of size 3x3]\n",
217 |       "\n",
218 |       "Variable containing:\n",
219 |       " 1 -1  1\n",
220 |       " 0  1  0\n",
221 |       " 1  0  0\n",
222 |       "[torch.FloatTensor of size 3x3]\n",
223 |       "\n"
224 |      ]
225 |     }
226 |    ],
227 |    "source": [
228 |     "x = torch.Tensor([[3,1,5],[-2,5,-7],[3,2,-4]])\n",
229 |     "\n",
230 |     "x = Variable(x,requires_grad=True)\n",
231 |     "y = Variable(2*torch.ones(3,3))\n",
232 |     "\n",
233 |     "print(\"Input X:{}\".format(x.data))\n",
234 |     "\n",
235 |     "out = my_relu(x) \n",
236 |     "\n",
237 |     "loss = torch.abs(out-y)\n",
238 |     "#print(\"Loss: {}\".format(loss.data))\n",
239 |     "loss = torch.sum(loss)\n",
240 |     "loss.backward()\n",
241 |     "\n",
242 |     "print(x.grad)"
243 |    ]
244 |   },
245 |   {
246 |    "cell_type": "markdown",
247 |    "metadata": {},
248 |    "source": [
249 |     "## 3-3) Deconvnet ReLU\n",
250 |     "\n",
251 |     "http://pytorch.org/docs/0.3.1/notes/extending.html#extending-torch-autograd"
252 |    ]
253 |   },
254 |   {
255 |    "cell_type": "code",
256 |    "execution_count": 6,
257 |    "metadata": {
258 |     "collapsed": true,
259 |     "scrolled": false
260 |    },
261 |    "outputs": [],
262 |    "source": [
263 |     "class DeconvReLU(Function):\n",
264 |     "    @staticmethod\n",
265 |     "    def forward(ctx,input):\n",
266 |     "        #ctx.save_for_backward(input)\n",
267 |     "        return input.clamp(min=0)\n",
268 |     "    \n",
269 |     "    @staticmethod\n",
270 |     "    def backward(ctx,grad_output):\n",
271 |     "        #input = ctx.saved_tensors\n",
272 |     "        grad_input = grad_output.clone()\n",
273 |     "        print(\"grad input: \",grad_input)\n",
274 |     "        grad_input[grad_input<0] = 0\n",
275 |     "        return grad_input\n",
276 |     "        \n",
277 |     "deconv_relu = DeconvReLU.apply"
278 |    ]
279 |   },
280 |   {
281 |    "cell_type": "code",
282 |    "execution_count": 7,
283 |    "metadata": {},
284 |    "outputs": [
285 |     {
286 |      "name": "stdout",
287 |      "output_type": "stream",
288 |      "text": [
289 |       "Input X:\n",
290 |       " 3  1  5\n",
291 |       "-2  5 -7\n",
292 |       " 3  2 -4\n",
293 |       "[torch.FloatTensor of size 3x3]\n",
294 |       "\n",
295 |       "grad input:  Variable containing:\n",
296 |       " 1 -1  1\n",
297 |       "-1  1 -1\n",
298 |       " 1  0 -1\n",
299 |       "[torch.FloatTensor of size 3x3]\n",
300 |       "\n",
301 |       "Variable containing:\n",
302 |       " 1  0  1\n",
303 |       " 0  1  0\n",
304 |       " 1  0  0\n",
305 |       "[torch.FloatTensor of size 3x3]\n",
306 |       "\n"
307 |      ]
308 |     }
309 |    ],
310 |    "source": [
311 |     "x = torch.Tensor([[3,1,5],[-2,5,-7],[3,2,-4]])\n",
312 |     "\n",
313 |     "x = Variable(x,requires_grad=True)\n",
314 |     "y = Variable(2*torch.ones(3,3))\n",
315 |     "\n",
316 |     "print(\"Input X:{}\".format(x.data))\n",
317 |     "\n",
318 |     "out = deconv_relu(x)\n",
319 |     "\n",
320 |     "#print(\"Output: {}\".format(out.data))\n",
321 |     "\n",
322 |     "loss = torch.abs(out-y)\n",
323 |     "#print(\"Loss: {}\".format(loss.data))\n",
324 |     "loss = torch.sum(loss)\n",
325 |     "loss.backward()\n",
326 |     "\n",
327 |     "print(x.grad)"
328 |    ]
329 |   },
330 |   {
331 |    "cell_type": "markdown",
332 |    "metadata": {},
333 |    "source": [
334 |     "## 3-4) Guided Backpropagation ReLU"
335 |    ]
336 |   },
337 |   {
338 |    "cell_type": "code",
339 |    "execution_count": 8,
340 |    "metadata": {
341 |     "collapsed": true
342 |    },
343 |    "outputs": [],
344 |    "source": [
345 |     "class GuidedBackpropRelu(Function):\n",
346 |     "    @staticmethod\n",
347 |     "    def forward(ctx,input):\n",
348 |     "        ctx.save_for_backward(input)\n",
349 |     "        return input.clamp(min=0)\n",
350 |     "    \n",
351 |     "    @staticmethod\n",
352 |     "    def backward(ctx,grad_output):\n",
353 |     "        input = ctx.saved_tensors[0]\n",
354 |     "        grad_input = grad_output.clone()\n",
355 |     "        print(\"grad input: \",grad_input)\n",
356 |     "        grad_input[grad_input<0] = 0\n",
357 |     "        grad_input[input<0]=0\n",
358 |     "        return grad_input\n",
359 |     "    \n",
360 |     "guided_backprop_relu = GuidedBackpropRelu.apply"
361 |    ]
362 |   },
363 |   {
364 |    "cell_type": "code",
365 |    "execution_count": 9,
366 |    "metadata": {},
367 |    "outputs": [
368 |     {
369 |      "name": "stdout",
370 |      "output_type": "stream",
371 |      "text": [
372 |       "Input X:\n",
373 |       " 3  1  5\n",
374 |       "-2  5 -7\n",
375 |       " 3  2 -4\n",
376 |       "[torch.FloatTensor of size 3x3]\n",
377 |       "\n",
378 |       "grad input:  Variable containing:\n",
379 |       " 1 -1  1\n",
380 |       "-1  1 -1\n",
381 |       " 1  0 -1\n",
382 |       "[torch.FloatTensor of size 3x3]\n",
383 |       "\n",
384 |       "Variable containing:\n",
385 |       " 1  0  1\n",
386 |       " 0  1  0\n",
387 |       " 1  0  0\n",
388 |       "[torch.FloatTensor of size 3x3]\n",
389 |       "\n"
390 |      ]
391 |     }
392 |    ],
393 |    "source": [
394 |     "x = torch.Tensor([[3,1,5],[-2,5,-7],[3,2,-4]])\n",
395 |     "\n",
396 |     "x = Variable(x,requires_grad=True)\n",
397 |     "y = Variable(2*torch.ones(3,3))\n",
398 |     "\n",
399 |     "print(\"Input X:{}\".format(x.data))\n",
400 |     "\n",
401 |     "out = guided_backprop_relu(x)\n",
402 |     "\n",
403 |     "#print(\"Output: {}\".format(out.data))\n",
404 |     "\n",
405 |     "loss = torch.abs(out-y)\n",
406 |     "#print(\"Loss: {}\".format(loss.data))\n",
407 |     "loss = torch.sum(loss)\n",
408 |     "loss.backward()\n",
409 |     "\n",
410 |     "print(x.grad)"
411 |    ]
412 |   }
413 |  ],
414 |  "metadata": {
415 |   "kernelspec": {
416 |    "display_name": "Python 3",
417 |    "language": "python",
418 |    "name": "python3"
419 |   },
420 |   "language_info": {
421 |    "codemirror_mode": {
422 |     "name": "ipython",
423 |     "version": 3
424 |    },
425 |    "file_extension": ".py",
426 |    "mimetype": "text/x-python",
427 |    "name": "python",
428 |    "nbconvert_exporter": "python",
429 |    "pygments_lexer": "ipython3",
430 |    "version": "3.6.3"
431 |   }
432 |  },
433 |  "nbformat": 4,
434 |  "nbformat_minor": 2
435 | }
436 | 


--------------------------------------------------------------------------------
/guided_backprop_practice/Guidedbackprop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/guided_backprop_practice/Guidedbackprop.png


--------------------------------------------------------------------------------
/guided_backprop_practice/guided_backprop.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/guided_backprop_practice/guided_backprop.jpg


--------------------------------------------------------------------------------
/hook_practice/.ipynb_checkpoints/Module_Hook_Practice-checkpoint.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# What is hook in Pytorch ? - Module\n",
  8 |     "\n",
  9 |     "\n",
 10 |     "![alt text](./asset/hook.jpeg)\n",
 11 |     "\n",
 12 |     "\n",
 13 |     "### Module\n",
 14 |     "\n",
 15 |     "- nn.Module.register_forward_hook \n",
 16 |     "- nn.Module.register_backward_hook         \n",
 17 |     "- nn.Module.register_forward_pre_hook \n",
 18 |     "\n",
 19 |     "http://pytorch.org/docs/0.3.1/nn.html?highlight=register#torch.nn.Module.register_forward_hook\n",
 20 |     "\n",
 21 |     "### 1) Import Required Libraries"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 1,
 27 |    "metadata": {
 28 |     "collapsed": true
 29 |    },
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "import torch\n",
 33 |     "import torch.nn as nn\n",
 34 |     "from torch.autograd import Variable\n",
 35 |     "\n",
 36 |     "batch_size =3"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "markdown",
 41 |    "metadata": {},
 42 |    "source": [
 43 |     "## 2) Define Class\n",
 44 |     "\n",
 45 |     "- Define Model\n",
 46 |     "- Set Weights to 1 & Bias to 0\n",
 47 |     "- Register Hooks\n",
 48 |     "- Define Hooks\n",
 49 |     "- Remove Hooks\n",
 50 |     "- Define Forward"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 2,
 56 |    "metadata": {
 57 |     "collapsed": true
 58 |    },
 59 |    "outputs": [],
 60 |    "source": [
 61 |     "class Linear(nn.Module):\n",
 62 |     "    def __init__(self,feature_list):\n",
 63 |     "        super(Linear,self).__init__()\n",
 64 |     "        self.feature_list = feature_list\n",
 65 |     "        self.layers = []\n",
 66 |     "        \n",
 67 |     "        # Define Layers\n",
 68 |     "        for i in range(len(feature_list)-1):\n",
 69 |     "            self.layers.append(nn.Linear(self.feature_list[i],self.feature_list[i+1]))\n",
 70 |     "        self.total = nn.ModuleList(self.layers)\n",
 71 |     "             \n",
 72 |     "        # Initialize Weights to 1 in order to check gradients easily.\n",
 73 |     "        for idx,m in enumerate(self.total):\n",
 74 |     "            if isinstance(m, nn.Linear):\n",
 75 |     "                m.weight.data.fill_(1)\n",
 76 |     "                m.bias.data.fill_(0)\n",
 77 |     "                \n",
 78 |     "            if idx==1:\n",
 79 |     "                self.h0 = m.register_forward_hook(self.forward_hook)\n",
 80 |     "                self.h1 = m.register_forward_pre_hook(self.forward_pre_hook)\n",
 81 |     "                self.h2 = m.register_backward_hook(self.backward_hook)\n",
 82 |     "                \n",
 83 |     "                \n",
 84 |     "    # hook(module, input, output) -> None            \n",
 85 |     "    def forward_hook(self,*args):\n",
 86 |     "        module,input,output = args[0],args[1],args[2]\n",
 87 |     "        print(\"\\n This is Forward Hook \\n\")\n",
 88 |     "        # This part is weird \n",
 89 |     "        for i in args:\n",
 90 |     "            print(type(i))\n",
 91 |     "            \n",
 92 |     "        \n",
 93 |     "    # hook(module, grad_input, grad_output)\n",
 94 |     "    def backward_hook(self,*args):\n",
 95 |     "        module, grad_input, grad_output = args[0],args[1],args[2]\n",
 96 |     "        print(\"\\n This is Backward Hook \\n\")\n",
 97 |     "        for i in args:\n",
 98 |     "            print(type(i))\n",
 99 |     "        \n",
100 |     "    \n",
101 |     "    # hook(module, input)\n",
102 |     "    def forward_pre_hook(self,*args):\n",
103 |     "        module, input = args[0],args[1]\n",
104 |     "        print(\"\\n This is Forward Pre Hook \\n\")\n",
105 |     "        for i in args:\n",
106 |     "            print(type(i))\n",
107 |     "        \n",
108 |     "    \n",
109 |     "    def remove_hook(self):\n",
110 |     "        self.h0.remove()\n",
111 |     "        self.h1.remove()\n",
112 |     "        self.h2.remove()\n",
113 |     "    \n",
114 |     "    def forward(self,x):\n",
115 |     "        out = x\n",
116 |     "        for idx,layer in enumerate(self.total):\n",
117 |     "            out = layer(out)\n",
118 |     "        return out"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "markdown",
123 |    "metadata": {},
124 |    "source": [
125 |     "## 3) Create Instance & Check Model"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 3,
131 |    "metadata": {},
132 |    "outputs": [
133 |     {
134 |      "name": "stdout",
135 |      "output_type": "stream",
136 |      "text": [
137 |       "Linear(\n",
138 |       "  (total): ModuleList(\n",
139 |       "    (0): Linear(in_features=1, out_features=2, bias=True)\n",
140 |       "    (1): Linear(in_features=2, out_features=4, bias=True)\n",
141 |       "    (2): Linear(in_features=4, out_features=8, bias=True)\n",
142 |       "  )\n",
143 |       ")\n"
144 |      ]
145 |     }
146 |    ],
147 |    "source": [
148 |     "feature_list = [1,2,4,8]\n",
149 |     "model = Linear(feature_list)\n",
150 |     "print(model)"
151 |    ]
152 |   },
153 |   {
154 |    "cell_type": "markdown",
155 |    "metadata": {},
156 |    "source": [
157 |     "## 4) Forward\n",
158 |     "\n",
159 |     "- Forward_Pre_Hook is called Before Forward\n",
160 |     "- Farward_Hook is called After Forward"
161 |    ]
162 |   },
163 |   {
164 |    "cell_type": "code",
165 |    "execution_count": 4,
166 |    "metadata": {},
167 |    "outputs": [
168 |     {
169 |      "name": "stdout",
170 |      "output_type": "stream",
171 |      "text": [
172 |       "\n",
173 |       " This is Forward Pre Hook \n",
174 |       "\n",
175 |       "<class 'torch.nn.modules.linear.Linear'>\n",
176 |       "<class 'tuple'>\n",
177 |       "\n",
178 |       " This is Forward Hook \n",
179 |       "\n",
180 |       "<class 'torch.nn.modules.linear.Linear'>\n",
181 |       "<class 'tuple'>\n",
182 |       "<class 'torch.autograd.variable.Variable'>\n"
183 |      ]
184 |     }
185 |    ],
186 |    "source": [
187 |     "x = Variable(torch.ones(batch_size,1),requires_grad=True)\n",
188 |     "out = model(x)\n",
189 |     "out = torch.sum(out)"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "markdown",
194 |    "metadata": {},
195 |    "source": [
196 |     "## 5) Backward\n",
197 |     "\n",
198 |     "- Backward Hook is called after calculating the gradients"
199 |    ]
200 |   },
201 |   {
202 |    "cell_type": "code",
203 |    "execution_count": 5,
204 |    "metadata": {},
205 |    "outputs": [
206 |     {
207 |      "name": "stdout",
208 |      "output_type": "stream",
209 |      "text": [
210 |       "\n",
211 |       " This is Backward Hook \n",
212 |       "\n",
213 |       "<class 'torch.nn.modules.linear.Linear'>\n",
214 |       "<class 'tuple'>\n",
215 |       "<class 'tuple'>\n"
216 |      ]
217 |     }
218 |    ],
219 |    "source": [
220 |     "out.backward()"
221 |    ]
222 |   },
223 |   {
224 |    "cell_type": "markdown",
225 |    "metadata": {},
226 |    "source": [
227 |     "## 6) Remove Hook & Check"
228 |    ]
229 |   },
230 |   {
231 |    "cell_type": "code",
232 |    "execution_count": 6,
233 |    "metadata": {
234 |     "collapsed": true
235 |    },
236 |    "outputs": [],
237 |    "source": [
238 |     "model.remove_hook()\n",
239 |     "\n",
240 |     "x = Variable(torch.ones(batch_size,1),requires_grad=True)\n",
241 |     "out = model(x)\n",
242 |     "out = torch.sum(out)\n",
243 |     "out.backward()"
244 |    ]
245 |   }
246 |  ],
247 |  "metadata": {
248 |   "kernelspec": {
249 |    "display_name": "Python 3",
250 |    "language": "python",
251 |    "name": "python3"
252 |   },
253 |   "language_info": {
254 |    "codemirror_mode": {
255 |     "name": "ipython",
256 |     "version": 3
257 |    },
258 |    "file_extension": ".py",
259 |    "mimetype": "text/x-python",
260 |    "name": "python",
261 |    "nbconvert_exporter": "python",
262 |    "pygments_lexer": "ipython3",
263 |    "version": "3.6.3"
264 |   }
265 |  },
266 |  "nbformat": 4,
267 |  "nbformat_minor": 2
268 | }
269 | 


--------------------------------------------------------------------------------
/hook_practice/Module_Hook_Practice.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# What is hook in Pytorch ? - Module\n",
  8 |     "\n",
  9 |     "\n",
 10 |     "![alt text](./asset/hook.jpeg)\n",
 11 |     "\n",
 12 |     "\n",
 13 |     "### Module\n",
 14 |     "\n",
 15 |     "- nn.Module.register_forward_hook \n",
 16 |     "- nn.Module.register_backward_hook         \n",
 17 |     "- nn.Module.register_forward_pre_hook \n",
 18 |     "\n",
 19 |     "http://pytorch.org/docs/0.3.1/nn.html?highlight=register#torch.nn.Module.register_forward_hook\n",
 20 |     "\n",
 21 |     "### 1) Import Required Libraries"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 1,
 27 |    "metadata": {
 28 |     "collapsed": true
 29 |    },
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "import torch\n",
 33 |     "import torch.nn as nn\n",
 34 |     "from torch.autograd import Variable\n",
 35 |     "\n",
 36 |     "batch_size =3"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "markdown",
 41 |    "metadata": {},
 42 |    "source": [
 43 |     "## 2) Define Class\n",
 44 |     "\n",
 45 |     "- Define Model\n",
 46 |     "- Set Weights to 1 & Bias to 0\n",
 47 |     "- Register Hooks\n",
 48 |     "- Define Hooks\n",
 49 |     "- Remove Hooks\n",
 50 |     "- Define Forward"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 2,
 56 |    "metadata": {
 57 |     "collapsed": true
 58 |    },
 59 |    "outputs": [],
 60 |    "source": [
 61 |     "class Linear(nn.Module):\n",
 62 |     "    def __init__(self,feature_list):\n",
 63 |     "        super(Linear,self).__init__()\n",
 64 |     "        self.feature_list = feature_list\n",
 65 |     "        self.layers = []\n",
 66 |     "        \n",
 67 |     "        # Define Layers\n",
 68 |     "        for i in range(len(feature_list)-1):\n",
 69 |     "            self.layers.append(nn.Linear(self.feature_list[i],self.feature_list[i+1]))\n",
 70 |     "        self.total = nn.ModuleList(self.layers)\n",
 71 |     "             \n",
 72 |     "        # Initialize Weights to 1 in order to check gradients easily.\n",
 73 |     "        for idx,m in enumerate(self.total):\n",
 74 |     "            if isinstance(m, nn.Linear):\n",
 75 |     "                m.weight.data.fill_(1)\n",
 76 |     "                m.bias.data.fill_(0)\n",
 77 |     "                \n",
 78 |     "            if idx==1:\n",
 79 |     "                self.h0 = m.register_forward_hook(self.forward_hook)\n",
 80 |     "                self.h1 = m.register_forward_pre_hook(self.forward_pre_hook)\n",
 81 |     "                self.h2 = m.register_backward_hook(self.backward_hook)\n",
 82 |     "                \n",
 83 |     "                \n",
 84 |     "    # hook(module, input, output) -> None            \n",
 85 |     "    def forward_hook(self,*args):\n",
 86 |     "        module,input,output = args[0],args[1],args[2]\n",
 87 |     "        print(\"\\n This is Forward Hook \\n\")\n",
 88 |     "        # This part is weird \n",
 89 |     "        for i in args:\n",
 90 |     "            print(type(i))\n",
 91 |     "            \n",
 92 |     "        \n",
 93 |     "    # hook(module, grad_input, grad_output)\n",
 94 |     "    def backward_hook(self,*args):\n",
 95 |     "        module, grad_input, grad_output = args[0],args[1],args[2]\n",
 96 |     "        print(\"\\n This is Backward Hook \\n\")\n",
 97 |     "        for i in args:\n",
 98 |     "            print(type(i))\n",
 99 |     "        \n",
100 |     "    \n",
101 |     "    # hook(module, input)\n",
102 |     "    def forward_pre_hook(self,*args):\n",
103 |     "        module, input = args[0],args[1]\n",
104 |     "        print(\"\\n This is Forward Pre Hook \\n\")\n",
105 |     "        for i in args:\n",
106 |     "            print(type(i))\n",
107 |     "        \n",
108 |     "    \n",
109 |     "    def remove_hook(self):\n",
110 |     "        self.h0.remove()\n",
111 |     "        self.h1.remove()\n",
112 |     "        self.h2.remove()\n",
113 |     "    \n",
114 |     "    def forward(self,x):\n",
115 |     "        out = x\n",
116 |     "        for idx,layer in enumerate(self.total):\n",
117 |     "            out = layer(out)\n",
118 |     "        return out"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "markdown",
123 |    "metadata": {},
124 |    "source": [
125 |     "## 3) Create Instance & Check Model"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 3,
131 |    "metadata": {},
132 |    "outputs": [
133 |     {
134 |      "name": "stdout",
135 |      "output_type": "stream",
136 |      "text": [
137 |       "Linear(\n",
138 |       "  (total): ModuleList(\n",
139 |       "    (0): Linear(in_features=1, out_features=2, bias=True)\n",
140 |       "    (1): Linear(in_features=2, out_features=4, bias=True)\n",
141 |       "    (2): Linear(in_features=4, out_features=8, bias=True)\n",
142 |       "  )\n",
143 |       ")\n"
144 |      ]
145 |     }
146 |    ],
147 |    "source": [
148 |     "feature_list = [1,2,4,8]\n",
149 |     "model = Linear(feature_list)\n",
150 |     "print(model)"
151 |    ]
152 |   },
153 |   {
154 |    "cell_type": "markdown",
155 |    "metadata": {},
156 |    "source": [
157 |     "## 4) Forward\n",
158 |     "\n",
159 |     "- Forward_Pre_Hook is called Before Forward\n",
160 |     "- Farward_Hook is called After Forward"
161 |    ]
162 |   },
163 |   {
164 |    "cell_type": "code",
165 |    "execution_count": 4,
166 |    "metadata": {},
167 |    "outputs": [
168 |     {
169 |      "name": "stdout",
170 |      "output_type": "stream",
171 |      "text": [
172 |       "\n",
173 |       " This is Forward Pre Hook \n",
174 |       "\n",
175 |       "<class 'torch.nn.modules.linear.Linear'>\n",
176 |       "<class 'tuple'>\n",
177 |       "\n",
178 |       " This is Forward Hook \n",
179 |       "\n",
180 |       "<class 'torch.nn.modules.linear.Linear'>\n",
181 |       "<class 'tuple'>\n",
182 |       "<class 'torch.autograd.variable.Variable'>\n"
183 |      ]
184 |     }
185 |    ],
186 |    "source": [
187 |     "x = Variable(torch.ones(batch_size,1),requires_grad=True)\n",
188 |     "out = model(x)\n",
189 |     "out = torch.sum(out)"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "markdown",
194 |    "metadata": {},
195 |    "source": [
196 |     "## 5) Backward\n",
197 |     "\n",
198 |     "- Backward Hook is called after calculating the gradients"
199 |    ]
200 |   },
201 |   {
202 |    "cell_type": "code",
203 |    "execution_count": 5,
204 |    "metadata": {},
205 |    "outputs": [
206 |     {
207 |      "name": "stdout",
208 |      "output_type": "stream",
209 |      "text": [
210 |       "\n",
211 |       " This is Backward Hook \n",
212 |       "\n",
213 |       "<class 'torch.nn.modules.linear.Linear'>\n",
214 |       "<class 'tuple'>\n",
215 |       "<class 'tuple'>\n"
216 |      ]
217 |     }
218 |    ],
219 |    "source": [
220 |     "out.backward()"
221 |    ]
222 |   },
223 |   {
224 |    "cell_type": "markdown",
225 |    "metadata": {},
226 |    "source": [
227 |     "## 6) Remove Hook & Check"
228 |    ]
229 |   },
230 |   {
231 |    "cell_type": "code",
232 |    "execution_count": 6,
233 |    "metadata": {
234 |     "collapsed": true
235 |    },
236 |    "outputs": [],
237 |    "source": [
238 |     "model.remove_hook()\n",
239 |     "\n",
240 |     "x = Variable(torch.ones(batch_size,1),requires_grad=True)\n",
241 |     "out = model(x)\n",
242 |     "out = torch.sum(out)\n",
243 |     "out.backward()"
244 |    ]
245 |   }
246 |  ],
247 |  "metadata": {
248 |   "kernelspec": {
249 |    "display_name": "Python 3",
250 |    "language": "python",
251 |    "name": "python3"
252 |   },
253 |   "language_info": {
254 |    "codemirror_mode": {
255 |     "name": "ipython",
256 |     "version": 3
257 |    },
258 |    "file_extension": ".py",
259 |    "mimetype": "text/x-python",
260 |    "name": "python",
261 |    "nbconvert_exporter": "python",
262 |    "pygments_lexer": "ipython3",
263 |    "version": "3.6.3"
264 |   }
265 |  },
266 |  "nbformat": 4,
267 |  "nbformat_minor": 2
268 | }
269 | 


--------------------------------------------------------------------------------
/hook_practice/Variable_Hook_Practice.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# What is hook in Pytorch ? - Variable\n"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "## Variable\n",
 15 |     "\n",
 16 |     "\n",
 17 |     "- torch.autograd.Variable.register_hook\n",
 18 |     "\n",
 19 |     "http://pytorch.org/docs/0.3.1/autograd.html?highlight=register_hook#torch.autograd.Variable.register_hook\n",
 20 |     "\n",
 21 |     "### 1) Import Required Libraries"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 1,
 27 |    "metadata": {
 28 |     "collapsed": true
 29 |    },
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "import torch\n",
 33 |     "import torch.nn as nn\n",
 34 |     "from torch.autograd import Variable"
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "markdown",
 39 |    "metadata": {},
 40 |    "source": [
 41 |     "## 2) Define Class\n",
 42 |     "\n",
 43 |     "- Define Model\n",
 44 |     "- Initialize Weights\n",
 45 |     "- Define Hook Funciton\n",
 46 |     "- Define Hook Remove Function\n",
 47 |     "- Register Hook at Desired Location when Forwarding"
 48 |    ]
 49 |   },
 50 |   {
 51 |    "cell_type": "code",
 52 |    "execution_count": 2,
 53 |    "metadata": {},
 54 |    "outputs": [],
 55 |    "source": [
 56 |     "class Linear(nn.Module):\n",
 57 |     "    def __init__(self,feature_list):\n",
 58 |     "        super(Linear,self).__init__()\n",
 59 |     "        self.feature_list = feature_list\n",
 60 |     "        self.layers = []\n",
 61 |     "        \n",
 62 |     "        # Define Layers\n",
 63 |     "        for i in range(len(feature_list)-1):\n",
 64 |     "            self.layers.append(nn.Linear(self.feature_list[i],self.feature_list[i+1]))\n",
 65 |     "        self.total = nn.ModuleList(self.layers)\n",
 66 |     "        \n",
 67 |     "        # Initialize Weights to 1 in order to check gradients easily.\n",
 68 |     "        for m in self.modules():\n",
 69 |     "            if isinstance(m, nn.Linear):\n",
 70 |     "                m.weight.data.fill_(1)\n",
 71 |     "                m.bias.data.fill_(0)\n",
 72 |     "    \n",
 73 |     "    # define hook \n",
 74 |     "    # if you uncomment 3rd line, gradients will be doubled.\n",
 75 |     "    def hook(self,grad):\n",
 76 |     "        print(self,grad)\n",
 77 |     "        #return 2*grad\n",
 78 |     "    \n",
 79 |     "    # Once a hook is registered, it stays until explicitly removed.\n",
 80 |     "    def remove_hook(self):\n",
 81 |     "        self.hook.remove()\n",
 82 |     "    \n",
 83 |     "    # register_hook is applied to Variable\n",
 84 |     "    # so it should be registered on a Variable, not nn.Module\n",
 85 |     "    def forward(self,x,hook_layer):\n",
 86 |     "        out = x\n",
 87 |     "        for idx,layer in enumerate(self.total):\n",
 88 |     "            out = layer(out)\n",
 89 |     "            if idx == hook_layer:\n",
 90 |     "                self.hook = out.register_hook(self.hook)\n",
 91 |     "        return out"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "markdown",
 96 |    "metadata": {},
 97 |    "source": [
 98 |     "## 3) Create Instance & Check"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": 3,
104 |    "metadata": {},
105 |    "outputs": [
106 |     {
107 |      "name": "stdout",
108 |      "output_type": "stream",
109 |      "text": [
110 |       "Linear(\n",
111 |       "  (total): ModuleList(\n",
112 |       "    (0): Linear(in_features=1, out_features=2, bias=True)\n",
113 |       "    (1): Linear(in_features=2, out_features=4, bias=True)\n",
114 |       "    (2): Linear(in_features=4, out_features=8, bias=True)\n",
115 |       "  )\n",
116 |       ")\n"
117 |      ]
118 |     }
119 |    ],
120 |    "source": [
121 |     "feature_list = [1,2,4,8]\n",
122 |     "model = Linear(feature_list)\n",
123 |     "print(model)"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "markdown",
128 |    "metadata": {},
129 |    "source": [
130 |     "## 4) Forward a Variable & Register hook"
131 |    ]
132 |   },
133 |   {
134 |    "cell_type": "code",
135 |    "execution_count": 4,
136 |    "metadata": {},
137 |    "outputs": [],
138 |    "source": [
139 |     "x = Variable(torch.ones(1),requires_grad=True)\n",
140 |     "out = model(x,hook_layer=2)\n",
141 |     "out = torch.sum(out)"
142 |    ]
143 |   },
144 |   {
145 |    "cell_type": "markdown",
146 |    "metadata": {},
147 |    "source": [
148 |     "## 5) Hook called with Backward"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "code",
153 |    "execution_count": 5,
154 |    "metadata": {
155 |     "scrolled": true
156 |    },
157 |    "outputs": [
158 |     {
159 |      "name": "stdout",
160 |      "output_type": "stream",
161 |      "text": [
162 |       "Linear(\n",
163 |       "  (total): ModuleList(\n",
164 |       "    (0): Linear(in_features=1, out_features=2, bias=True)\n",
165 |       "    (1): Linear(in_features=2, out_features=4, bias=True)\n",
166 |       "    (2): Linear(in_features=4, out_features=8, bias=True)\n",
167 |       "  )\n",
168 |       ") Variable containing:\n",
169 |       " 1\n",
170 |       " 1\n",
171 |       " 1\n",
172 |       " 1\n",
173 |       " 1\n",
174 |       " 1\n",
175 |       " 1\n",
176 |       " 1\n",
177 |       "[torch.FloatTensor of size 8]\n",
178 |       "\n"
179 |      ]
180 |     }
181 |    ],
182 |    "source": [
183 |     "out.backward()\n",
184 |     "\n",
185 |     "# hook stays until explicitly removed.\n",
186 |     "model.remove_hook()"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "markdown",
191 |    "metadata": {},
192 |    "source": [
193 |     "## 6) Check Gradient of Leaf Variable"
194 |    ]
195 |   },
196 |   {
197 |    "cell_type": "code",
198 |    "execution_count": 6,
199 |    "metadata": {},
200 |    "outputs": [
201 |     {
202 |      "data": {
203 |       "text/plain": [
204 |        "Variable containing:\n",
205 |        " 64\n",
206 |        "[torch.FloatTensor of size 1]"
207 |       ]
208 |      },
209 |      "execution_count": 6,
210 |      "metadata": {},
211 |      "output_type": "execute_result"
212 |     }
213 |    ],
214 |    "source": [
215 |     "# if hook function returns modified gradient, this will also affected.\n",
216 |     "# 64 without returning gradient, 128 with returning 2*grad\n",
217 |     "x.grad"
218 |    ]
219 |   }
220 |  ],
221 |  "metadata": {
222 |   "kernelspec": {
223 |    "display_name": "Python 3",
224 |    "language": "python",
225 |    "name": "python3"
226 |   },
227 |   "language_info": {
228 |    "codemirror_mode": {
229 |     "name": "ipython",
230 |     "version": 3
231 |    },
232 |    "file_extension": ".py",
233 |    "mimetype": "text/x-python",
234 |    "name": "python",
235 |    "nbconvert_exporter": "python",
236 |    "pygments_lexer": "ipython3",
237 |    "version": "3.6.3"
238 |   }
239 |  },
240 |  "nbformat": 4,
241 |  "nbformat_minor": 2
242 | }
243 | 


--------------------------------------------------------------------------------
/hook_practice/asset/hook.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/hook_practice/asset/hook.jpeg


--------------------------------------------------------------------------------
/최건호_GoogleColab_GradCAM.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/Grad-CAM-Pytorch/fb41373cc846123522c44290f4b71849fb76763c/최건호_GoogleColab_GradCAM.pdf


--------------------------------------------------------------------------------