| Date | 86 |Topics | 87 |Slides | 88 |iTorch Notebooks | 89 |Extra Reading | 90 |
|---|---|---|---|---|
| 4th Jan. 2018 | 93 |
|
94 | Slides | 95 |-- 96 | | 97 |-- | 98 |
| 5th Jan. 2018 | 102 |
103 | Camera Geometry
104 |
|
110 | Slides | 111 |-- 112 | | 113 |Homogeneous Representations of Points, Lines and Planes | 114 |
| 12th Jan. 2018 | 117 |
|
123 | Slides | 124 |-- 125 | | 126 |-- | 127 |
| 13th Jan. 2018 | 131 |
|
138 | Slides | 139 |-- 140 | | 141 |Resource on SVD, how/why it can be used to solve eq. sytems of type Ax=0, |x|=1 | 142 |
| 18th Jan. 2018 | 146 |
|
158 |
159 | Slides(1) 160 | Slides(2) 161 | |
162 | -- | 163 |-- | 164 |
| 19th Jan. 2018 | 167 |
|
185 |
186 | Slides(1) 187 | Slides(2) 188 | |
189 | -- | 190 |-- | 191 |
| 25th Jan. 2018 | 195 |
196 | Recognizing images, objects, scenes (Prof. Suyash P. Awate)
197 |
|
203 |
204 | Slides 205 | |
206 | -- | 207 |-- | 208 |
| 1st Feb. 2018 | 211 |
212 | Recognizing images, objects, scenes (Prof. Suyash P. Awate)
213 |
|
217 |
218 | Slides 219 | |
220 | -- | 221 |-- | 222 |
| 2nd Feb. 2018 | 225 |
226 | Robust Methods in Computer Vision
227 |
|
242 |
243 | Slides(1) 244 | Slides(2) 245 | |
246 | KNN | 247 |Matrix calculus reminder 248 | | 249 |
| 8th Feb. 2018 | 252 |
253 |
|
260 |
261 | Slides 262 | |
263 | Gradient Check | 264 | ADAM,
265 | Nesterov 266 | DL optimization algorithms overview 267 | |
268 |
| 9th Feb. 2018 | 271 |
272 |
|
277 |
278 | Slides 279 | |
280 | Linear Layer, 281 | ReLU 282 | | 283 |-- | 284 |
| 15th Feb. 2018 | 287 |
288 |
|
292 |
293 | Slides 294 | |
295 | MaxPool, 296 | Convolution, 297 | Transposed convolution, Dropout 298 | | 299 |Convolution arithmetic for deep 300 | learning | 301 |
| 16th Feb. 2018 | 304 |
305 |
|
310 |
311 | Slides 312 | |
313 | Cross Entropy, 314 | Weight Initialization 315 | | 316 |-- | 317 |22nd Feb. 2018 | 319 |
320 |
|
324 |
325 | Slides 326 | |
327 | 328 | -- 329 | | 330 |-- | 331 | 332 |
| 23rd Feb. 2018 | 334 |
335 |
|
339 |
340 | Slides 341 | |
342 | -- 343 | | 344 |-- | 345 |
| 8th March 2018 | 348 |
349 |
|
355 |
356 | Slides 357 | |
358 | -- 359 | | 360 |-- | 361 |
| 9th March 2018 | 365 |
366 |
|
373 |
374 | Slides 375 | Slides 376 | |
377 | MNIST Vanilla GAN 378 | | 379 |-- | 380 |
| 15th March 2018 | 383 |
384 |
|
387 | 388 | Slides 389 | | 390 |-- | 391 |-- | 392 |
| 16th March 2018 | 395 |
396 | Structure from Motion
397 |
|
402 |
403 | Slides 404 | |
405 | -- | 406 |-- | 407 |
| 22nd March 2018 | 410 |
411 | Kanade-Lucas-Tomasi Feature Tracking (KLT)
412 |
|
416 |
417 | Slides 418 | |
419 | -- | 420 | Lucas-Kanade 20 Years On: A Unifying Framework |
421 |
| 23rd March 2018 | 424 |
425 | Geometric Stereo
426 |
|
431 |
432 | Slides 433 | |
434 | -- | 435 |-- | 436 |
| 5th April 2018 | 439 |
440 |
|
446 |
447 | Slides 448 | |
449 | -- | 450 |-- | 451 |
| 6th April 2018 | 454 |
455 |
|
460 |
461 | Slides(1) 462 | Slides(2) 463 | |
464 | -- | 465 |-- | 466 |
| 12th April 2018 | 469 |
470 |
|
474 |
475 | Slides 476 | |
477 | -- | 478 |-- | 479 |
| 19th April 2018 | 482 |
483 |
|
487 |
488 | Slides 489 | |
490 | -- | 491 |-- | 492 |
| 20th April 2018 | 495 |
496 |
|
499 |
500 | Slides 501 | |
502 | -- | 503 |-- | 504 |
![\"Cross-Entropy](\"https://raw.githubusercontent.com/stencilman/CS763_Spring2017/master/Lec3%2C4/cec.png\")
\n",
140 | "As we saw in the class, the error is equal to $\\hat{o}-[1, 0, 0]^{T}$, where $\\hat{o}=SoftMax(o)$. So, let us know use torch to calcuate gradient of the loss respect to the output and then also do the same manually."
141 | ]
142 | },
143 | {
144 | "cell_type": "code",
145 | "execution_count": 4,
146 | "metadata": {
147 | "collapsed": false,
148 | "deletable": true,
149 | "editable": true
150 | },
151 | "outputs": [
152 | {
153 | "data": {
154 | "text/plain": [
155 | " 0.1300\n",
156 | " 0.8690\n",
157 | " 0.0010\n",
158 | "[torch.DoubleTensor of size 3]\n",
159 | "\n"
160 | ]
161 | },
162 | "execution_count": 4,
163 | "metadata": {},
164 | "output_type": "execute_result"
165 | }
166 | ],
167 | "source": [
168 | "ohat = nn.SoftMax():forward(o)\n",
169 | "print(ohat)"
170 | ]
171 | },
172 | {
173 | "cell_type": "code",
174 | "execution_count": 5,
175 | "metadata": {
176 | "collapsed": false,
177 | "deletable": true,
178 | "editable": true
179 | },
180 | "outputs": [
181 | {
182 | "data": {
183 | "text/plain": [
184 | "-0.8700\n",
185 | " 0.8690\n",
186 | " 0.0010\n",
187 | "[torch.DoubleTensor of size 3]\n",
188 | "\n"
189 | ]
190 | },
191 | "execution_count": 5,
192 | "metadata": {},
193 | "output_type": "execute_result"
194 | }
195 | ],
196 | "source": [
197 | "dl_do = cec:backward(o, t)\n",
198 | "print(dl_do)"
199 | ]
200 | },
201 | {
202 | "cell_type": "code",
203 | "execution_count": 6,
204 | "metadata": {
205 | "collapsed": false,
206 | "deletable": true,
207 | "editable": true
208 | },
209 | "outputs": [
210 | {
211 | "data": {
212 | "text/plain": [
213 | "-0.8700\n",
214 | " 0.8690\n",
215 | " 0.0010\n",
216 | "[torch.DoubleTensor of size 3]\n",
217 | "\n"
218 | ]
219 | },
220 | "execution_count": 6,
221 | "metadata": {},
222 | "output_type": "execute_result"
223 | }
224 | ],
225 | "source": [
226 | "target = torch.Tensor({1, 0, 0})\n",
227 | "dl_do_manual = ohat - target\n",
228 | "print(dl_do_manual)"
229 | ]
230 | },
231 | {
232 | "cell_type": "markdown",
233 | "metadata": {
234 | "deletable": true,
235 | "editable": true
236 | },
237 | "source": [
238 | "Note how ```dl_do``` and ```dl_do_manual``` are exactly the same."
239 | ]
240 | }
241 | ],
242 | "metadata": {
243 | "kernelspec": {
244 | "display_name": "iTorch",
245 | "language": "lua",
246 | "name": "itorch"
247 | },
248 | "language_info": {
249 | "name": "lua",
250 | "version": "5.1"
251 | }
252 | },
253 | "nbformat": 4,
254 | "nbformat_minor": 2
255 | }
256 |
--------------------------------------------------------------------------------
/notebooks/Convolution.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Convolution Layer\n",
8 | "In this notebook, we will look into the forward and the backward the the ```nn.SpatialConvolution``` layer. We will also see how to compute the gradient of the loss with respect to the weights $\\frac{\\partial L}{\\partial W}$ for this layer. I leave gradient of the loss with respect to the input $\\frac{\\partial L}{\\partial I}$ as an excercise."
9 | ]
10 | },
11 | {
12 | "cell_type": "markdown",
13 | "metadata": {},
14 | "source": [
15 | "#### Input\n",
16 | "Similar to the example we used in the class, let us have the input $n$ of size $1 \\times 4$."
17 | ]
18 | },
19 | {
20 | "cell_type": "code",
21 | "execution_count": 1,
22 | "metadata": {},
23 | "outputs": [
24 | {
25 | "data": {
26 | "text/plain": [
27 | "(1,.,.) = \n",
28 | " 0.9741 0.6880 0.2478 0.5842\n",
29 | "[torch.DoubleTensor of size 1x1x4]\n",
30 | "\n"
31 | ]
32 | },
33 | "execution_count": 1,
34 | "metadata": {},
35 | "output_type": "execute_result"
36 | }
37 | ],
38 | "source": [
39 | "require 'nn';\n",
40 | "n = torch.rand(4):reshape(1,1,4)\n",
41 | "print(n)"
42 | ]
43 | },
44 | {
45 | "cell_type": "markdown",
46 | "metadata": {},
47 | "source": [
48 | "#### Output using Convolution Block\n",
49 | "Also similar to the example we used in the class, let us create a convolution block with a weights $w$ of size $1 \\times 3$ and obtain the output $m = Convolution(n, w)$ of size $1\\times2$."
50 | ]
51 | },
52 | {
53 | "cell_type": "code",
54 | "execution_count": 2,
55 | "metadata": {},
56 | "outputs": [
57 | {
58 | "data": {
59 | "text/plain": [
60 | "(1,.,.) = \n",
61 | " 0.1151 -0.0816\n",
62 | "[torch.DoubleTensor of size 1x1x2]\n",
63 | "\n"
64 | ]
65 | },
66 | "execution_count": 2,
67 | "metadata": {},
68 | "output_type": "execute_result"
69 | }
70 | ],
71 | "source": [
72 | "conv = nn.SpatialConvolutionMM(1,1,3,1)\n",
73 | "conv.bias:fill(0)\n",
74 | "m = conv:forward(n)\n",
75 | "print(m)"
76 | ]
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "#### Doing backward and calculating the gradinent of the loss with respect to the weights\n",
83 | "Let us set the gradient of the loss with respect to the input of next layer (flowing in through the next layer) $\\frac{\\partial L}{\\partial I^{l+1}}$ to be random numbers. After the ```backward()``` call, let us print the $\\frac{\\partial L}{\\partial W}$ as calcuated by torch."
84 | ]
85 | },
86 | {
87 | "cell_type": "code",
88 | "execution_count": 3,
89 | "metadata": {},
90 | "outputs": [
91 | {
92 | "data": {
93 | "text/plain": [
94 | " 0.3516 0.1675 0.2284\n",
95 | "[torch.DoubleTensor of size 1x3]\n",
96 | "\n"
97 | ]
98 | },
99 | "execution_count": 3,
100 | "metadata": {},
101 | "output_type": "execute_result"
102 | }
103 | ],
104 | "source": [
105 | "nextgrad=torch.rand(2):reshape(1,1,2)\n",
106 | "conv:backward(n, nextgrad)\n",
107 | "print(conv.gradWeight)"
108 | ]
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {},
113 | "source": [
114 | "#### Expression for calcuating the gradinent of the loss with respect to the weights\n",
115 | "Again, as we learnt in class, the $\\frac{\\partial L}{\\partial W} = Convolution(I, \\frac{\\partial L}{\\partial I^{l+1}})$. We varify that this is indeed exactly equal to $\\frac{\\partial L}{\\partial W}$ computed by torch. "
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "execution_count": 4,
121 | "metadata": {},
122 | "outputs": [
123 | {
124 | "data": {
125 | "text/plain": [
126 | "(1,.,.) = \n",
127 | " 0.3516 0.1675 0.2284\n",
128 | "[torch.DoubleTensor of size 1x1x3]\n",
129 | "\n"
130 | ]
131 | },
132 | "execution_count": 4,
133 | "metadata": {},
134 | "output_type": "execute_result"
135 | }
136 | ],
137 | "source": [
138 | "convback = nn.SpatialConvolutionMM(1,1,2,1)\n",
139 | "convback.bias:fill(0)\n",
140 | "convback.weight:copy(nextgrad:reshape(1,2))\n",
141 | "gradWeight = convback:forward(n)\n",
142 | "print(gradWeight)"
143 | ]
144 | },
145 | {
146 | "cell_type": "markdown",
147 | "metadata": {},
148 | "source": [
149 | "I leave the calculation of $\\frac{\\partial L}{\\partial I}$ as an exercise. Remember: $\\frac{\\partial L}{\\partial I} = Convolution(W^{padded}, \\frac{\\partial L}{\\partial I^{l+1}}^{Flip})$"
150 | ]
151 | }
152 | ],
153 | "metadata": {
154 | "kernelspec": {
155 | "display_name": "iTorch",
156 | "language": "lua",
157 | "name": "itorch"
158 | },
159 | "language_info": {
160 | "name": "lua",
161 | "version": "5.1"
162 | }
163 | },
164 | "nbformat": 4,
165 | "nbformat_minor": 2
166 | }
167 |
--------------------------------------------------------------------------------
/notebooks/Dropout.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "deletable": true,
7 | "editable": true
8 | },
9 | "source": [
10 | "# Dropout Layer\n",
11 | "In this notebook, we will look into the the dropout layer.\n",
12 | "Consider a standard 3 layered network as shown bellow in (a):\n",
13 | "![](\"https://raw.githubusercontent.com/stencilman/CS763_Spring2017/master/Lec3%2C4/dropout_base_network.png\")
\n",
14 | "During training with dropout, as shown bellow in code snippet, we randomly set some neurons to zero in the forward pass. The network with dropout on can be seen in (b)."
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 20,
20 | "metadata": {
21 | "collapsed": false,
22 | "deletable": true,
23 | "editable": true
24 | },
25 | "outputs": [
26 | {
27 | "data": {
28 | "text/plain": [
29 | "Hidden Layer 1 output before dropout:\t\n",
30 | " 0.2164\n",
31 | " 0.0931\n",
32 | "-0.3029\n",
33 | "-0.6296\n",
34 | " 0.3302\n",
35 | "[torch.DoubleTensor of size 5]\n",
36 | "\n",
37 | "Dropout Mask:\t\n",
38 | " 1\n",
39 | " 1\n",
40 | " 1\n",
41 | " 1\n",
42 | " 0\n",
43 | "[torch.DoubleTensor of size 5]\n",
44 | "\n",
45 | "Hidden Layer 1 output after dropout\t\n",
46 | " 0.2164\n",
47 | " 0.0931\n",
48 | "-0.3029\n",
49 | "-0.6296\n",
50 | " 0.0000\n",
51 | "[torch.DoubleTensor of size 5]\n",
52 | "\n",
53 | "-----------------------------------\t\n",
54 | "Hidden Layer 2 output before dropout\t\n",
55 | " 0.1721\n",
56 | " 0.0472\n",
57 | " 0.1428\n",
58 | " 0.1557\n",
59 | " 0.0723\n",
60 | "[torch.DoubleTensor of size 5]\n",
61 | "\n",
62 | "Dropout Mask:\t\n",
63 | " 1\n",
64 | " 1\n",
65 | " 0\n",
66 | " 0\n",
67 | " 1\n",
68 | "[torch.DoubleTensor of size 5]\n",
69 | "\n",
70 | "Hidden Layer 2 output after dropout\t\n",
71 | " 0.1721\n",
72 | " 0.0472\n",
73 | " 0.0000\n",
74 | " 0.0000\n",
75 | " 0.0723\n",
76 | "[torch.DoubleTensor of size 5]\n",
77 | "\n",
78 | "-----------------------------------\t\n",
79 | "Hidden Layer 3 output before dropout\t\n",
80 | "-0.3645\n",
81 | "-0.1621\n",
82 | "-0.0378\n",
83 | "-0.0005\n",
84 | "-0.1822\n",
85 | "[torch.DoubleTensor of size 5]\n",
86 | "\n",
87 | "Dropout Mask:\t\n",
88 | " 0\n",
89 | " 0\n",
90 | " 0\n",
91 | " 1\n",
92 | " 1\n",
93 | "[torch.DoubleTensor of size 5]\n",
94 | "\n",
95 | "Hidden Layer 2 output after dropout\t\n",
96 | "-0.0000\n",
97 | "-0.0000\n",
98 | "-0.0000\n",
99 | "-0.0005\n",
100 | "-0.1822\n",
101 | "[torch.DoubleTensor of size 5]\n",
102 | "\n",
103 | "-----------------------------------\t\n"
104 | ]
105 | },
106 | "execution_count": 20,
107 | "metadata": {},
108 | "output_type": "execute_result"
109 | }
110 | ],
111 | "source": [
112 | "require 'nn';\n",
113 | "p = 0.5\n",
114 | "x = torch.rand(5)\n",
115 | "L1 = nn.Linear(5, 5)\n",
116 | "L2 = nn.Linear(5, 5)\n",
117 | "L3 = nn.Linear(5, 5)\n",
118 | "L4 = nn.Linear(5, 1)\n",
119 | "\n",
120 | "\n",
121 | "H1 = L1:forward(x)\n",
122 | "print('Hidden Layer 1 output before dropout:')\n",
123 | "print(H1)\n",
124 | "U1 = torch.rand(H1:size(1)):gt(p):double()\n",
125 | "print('Dropout Mask:')\n",
126 | "print(U1)\n",
127 | "H1 = H1:cmul(U1)\n",
128 | "print('Hidden Layer 1 output after dropout')\n",
129 | "print(H1)\n",
130 | "print('-----------------------------------')\n",
131 | "\n",
132 | "H2 = L2:forward(H1)\n",
133 | "print('Hidden Layer 2 output before dropout')\n",
134 | "print(H2)\n",
135 | "U2 = torch.rand(H2:size(1)):gt(p):double()\n",
136 | "print('Dropout Mask:')\n",
137 | "print(U2)\n",
138 | "H2 = H2:cmul(U2)\n",
139 | "print('Hidden Layer 2 output after dropout')\n",
140 | "print(H2)\n",
141 | "print('-----------------------------------')\n",
142 | "\n",
143 | "H3 = L3:forward(H2)\n",
144 | "print('Hidden Layer 3 output before dropout')\n",
145 | "print(H3)\n",
146 | "U3 = torch.rand(H3:size(1)):gt(p):double()\n",
147 | "print('Dropout Mask:')\n",
148 | "print(U3)\n",
149 | "H2 = H3:cmul(U3)\n",
150 | "print('Hidden Layer 2 output after dropout')\n",
151 | "print(H3)\n",
152 | "print('-----------------------------------')\n",
153 | "\n",
154 | "out = L4:forward(H3)"
155 | ]
156 | },
157 | {
158 | "cell_type": "markdown",
159 | "metadata": {
160 | "deletable": true,
161 | "editable": true
162 | },
163 | "source": [
164 | "However, we must componsate for the dropout, such as the total magnitude of the activations are same both in the trining and the test phase. This can be done by scaling the activations down during the forward pass at the test time."
165 | ]
166 | },
167 | {
168 | "cell_type": "code",
169 | "execution_count": 21,
170 | "metadata": {
171 | "collapsed": true,
172 | "deletable": true,
173 | "editable": true
174 | },
175 | "outputs": [],
176 | "source": [
177 | "require 'nn';\n",
178 | "p = 0.5\n",
179 | "x = torch.rand(5)\n",
180 | "L1 = nn.Linear(5, 5)\n",
181 | "L2 = nn.Linear(5, 5)\n",
182 | "L3 = nn.Linear(5, 5)\n",
183 | "L4 = nn.Linear(5, 1)\n",
184 | "\n",
185 | "function forward_train(x)\n",
186 | " H1 = L1:forward(x)\n",
187 | " U1 = torch.rand(H1:size(1)):gt(p):double()\n",
188 | " H1 = H1:cmul(U1)\n",
189 | "\n",
190 | " H2 = L2:forward(H1)\n",
191 | " U2 = torch.rand(H2:size(1)):gt(p):double()\n",
192 | " H2 = H2:cmul(U2)\n",
193 | "\n",
194 | " H3 = L3:forward(H2)\n",
195 | " U3 = torch.rand(H3:size(1)):gt(p):double()\n",
196 | " H2 = H3:cmul(U3)\n",
197 | "\n",
198 | " out = L4:forward(H3)\n",
199 | " return out\n",
200 | "end\n",
201 | "\n",
202 | "function forward_test(x)\n",
203 | " H1 = L1:forward(x) * p\n",
204 | " H2 = L2:forward(H1) * p\n",
205 | " H3 = L3:forward(H2) * p\n",
206 | " out = L4:forward(H3)\n",
207 | " return out\n",
208 | "end"
209 | ]
210 | },
211 | {
212 | "cell_type": "markdown",
213 | "metadata": {
214 | "deletable": true,
215 | "editable": true
216 | },
217 | "source": [
218 | "Alternatively, we can scale the activations up at training time, and thus the test time code remains untouched."
219 | ]
220 | },
221 | {
222 | "cell_type": "code",
223 | "execution_count": null,
224 | "metadata": {
225 | "collapsed": true,
226 | "deletable": true,
227 | "editable": true
228 | },
229 | "outputs": [],
230 | "source": [
231 | "function forward_train(x)\n",
232 | " H1 = L1:forward(x)\n",
233 | " U1 = torch.rand(H1:size(1)):gt(p):double()\n",
234 | " H1 = H1:cmul(U1) / p\n",
235 | "\n",
236 | " H2 = L2:forward(H1)\n",
237 | " U2 = torch.rand(H2:size(1)):gt(p):double()\n",
238 | " H2 = H2:cmul(U2) / p\n",
239 | "\n",
240 | " H3 = L3:forward(H2)\n",
241 | " U3 = torch.rand(H3:size(1)):gt(p):double()\n",
242 | " H2 = H3:cmul(U3) / p\n",
243 | "\n",
244 | " out = L4:forward(H3)\n",
245 | " return out\n",
246 | "end\n",
247 | "\n",
248 | "function forward_test(x)\n",
249 | " H1 = L1:forward(x) \n",
250 | " H2 = L2:forward(H1) \n",
251 | " H3 = L3:forward(H2) \n",
252 | " out = L4:forward(H3)\n",
253 | " return out\n",
254 | "end"
255 | ]
256 | }
257 | ],
258 | "metadata": {
259 | "kernelspec": {
260 | "display_name": "iTorch",
261 | "language": "lua",
262 | "name": "itorch"
263 | },
264 | "language_info": {
265 | "name": "lua",
266 | "version": "5.1"
267 | }
268 | },
269 | "nbformat": 4,
270 | "nbformat_minor": 2
271 | }
272 |
--------------------------------------------------------------------------------
/notebooks/Linear.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Fully-Connected (Linear) Layer\n",
8 | "In this notebook, we will look into the forward and the backward the the ```nn.Linear``` layer. We will also manualy derive the expressions for the gradient of the loss respect to the input $\\frac{\\partial L}{\\partial I}$ of this layer and also the gradient of the loss with respect to the weights $\\frac{\\partial L}{\\partial W}$."
9 | ]
10 | },
11 | {
12 | "cell_type": "code",
13 | "execution_count": 1,
14 | "metadata": {},
15 | "outputs": [],
16 | "source": [
17 | "require 'nn';\n",
18 | "n = torch.rand(5)\n",
19 | "lin = nn.Linear(5,4)\n",
20 | "m = lin:forward(n)"
21 | ]
22 | },
23 | {
24 | "cell_type": "markdown",
25 | "metadata": {},
26 | "source": [
27 | "#### Input"
28 | ]
29 | },
30 | {
31 | "cell_type": "code",
32 | "execution_count": 2,
33 | "metadata": {},
34 | "outputs": [
35 | {
36 | "data": {
37 | "text/plain": [
38 | " 0.2647\n",
39 | " 0.7477\n",
40 | " 0.5382\n",
41 | " 0.1914\n",
42 | " 0.0834\n",
43 | "[torch.DoubleTensor of size 5]\n",
44 | "\n"
45 | ]
46 | },
47 | "execution_count": 2,
48 | "metadata": {},
49 | "output_type": "execute_result"
50 | }
51 | ],
52 | "source": [
53 | "n"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "#### Output"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": 3,
66 | "metadata": {},
67 | "outputs": [
68 | {
69 | "data": {
70 | "text/plain": [
71 | " 0.1242\n",
72 | " 0.2382\n",
73 | "-0.6489\n",
74 | "-0.2896\n",
75 | "[torch.DoubleTensor of size 4]\n",
76 | "\n"
77 | ]
78 | },
79 | "execution_count": 3,
80 | "metadata": {},
81 | "output_type": "execute_result"
82 | }
83 | ],
84 | "source": [
85 | "m"
86 | ]
87 | },
88 | {
89 | "cell_type": "markdown",
90 | "metadata": {},
91 | "source": [
92 | "#### Output (manually compute)"
93 | ]
94 | },
95 | {
96 | "cell_type": "code",
97 | "execution_count": 4,
98 | "metadata": {},
99 | "outputs": [
100 | {
101 | "data": {
102 | "text/plain": [
103 | " 0.1242\n",
104 | " 0.2382\n",
105 | "-0.6489\n",
106 | "-0.2896\n",
107 | "[torch.DoubleTensor of size 4]\n",
108 | "\n"
109 | ]
110 | },
111 | "execution_count": 4,
112 | "metadata": {},
113 | "output_type": "execute_result"
114 | }
115 | ],
116 | "source": [
117 | "m_ = lin.weight*n + lin.bias\n",
118 | "print(m_)"
119 | ]
120 | },
121 | {
122 | "cell_type": "markdown",
123 | "metadata": {},
124 | "source": [
125 | "#### Set gradient of the loss with respect of input of the next layer $\\frac{\\partial L}{\\partial I^{l+1}}$ of next layer to random values, and backward propagae the gradient from the next layer via this linear layer."
126 | ]
127 | },
128 | {
129 | "cell_type": "code",
130 | "execution_count": 5,
131 | "metadata": {
132 | "collapsed": true
133 | },
134 | "outputs": [],
135 | "source": [
136 | "nextgrad = torch.rand(4)\n",
137 | "lin:backward(n, nextgrad)"
138 | ]
139 | },
140 | {
141 | "cell_type": "markdown",
142 | "metadata": {},
143 | "source": [
144 | "#### Gradient of the loss with respect of input of this layer $\\frac{\\partial L}{\\partial I}$"
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": 6,
150 | "metadata": {},
151 | "outputs": [
152 | {
153 | "data": {
154 | "text/plain": [
155 | "-0.1486\n",
156 | "-0.3457\n",
157 | "-0.0236\n",
158 | " 0.2292\n",
159 | " 0.3097\n",
160 | "[torch.DoubleTensor of size 5]\n",
161 | "\n"
162 | ]
163 | },
164 | "execution_count": 6,
165 | "metadata": {},
166 | "output_type": "execute_result"
167 | }
168 | ],
169 | "source": [
170 | "lin.gradInput"
171 | ]
172 | },
173 | {
174 | "cell_type": "markdown",
175 | "metadata": {},
176 | "source": [
177 | "#### Relation for calcuating the gradient of loss with respect to the input: $\\frac{\\partial L}{\\partial I^{l}} = \\frac{\\partial L}{\\partial I^{l+1}} \\times \\frac{\\partial O^{l}}{\\partial I^{l}}$. Note how the jacobian $\\frac{\\partial O^{l}}{\\partial I^{l}} = W^{l}$"
178 | ]
179 | },
180 | {
181 | "cell_type": "code",
182 | "execution_count": 7,
183 | "metadata": {},
184 | "outputs": [
185 | {
186 | "data": {
187 | "text/plain": [
188 | "-0.1486 -0.3457 -0.0236 0.2292 0.3097\n",
189 | "[torch.DoubleTensor of size 1x5]\n",
190 | "\n"
191 | ]
192 | },
193 | "execution_count": 7,
194 | "metadata": {},
195 | "output_type": "execute_result"
196 | }
197 | ],
198 | "source": [
199 | "nextgrad:reshape(1,4)*lin.weight"
200 | ]
201 | },
202 | {
203 | "cell_type": "markdown",
204 | "metadata": {},
205 | "source": [
206 | "#### This layers gradient of Loss with respect to the weights: $\\frac{\\partial L}{\\partial W^{l}}$"
207 | ]
208 | },
209 | {
210 | "cell_type": "code",
211 | "execution_count": 8,
212 | "metadata": {},
213 | "outputs": [
214 | {
215 | "data": {
216 | "text/plain": [
217 | " 0.2135 0.6033 0.4343 0.1544 0.0673\n",
218 | " 0.0556 0.1572 0.1132 0.0402 0.0175\n",
219 | " 0.0850 0.2402 0.1729 0.0615 0.0268\n",
220 | " 0.1717 0.4850 0.3491 0.1242 0.0541\n",
221 | "[torch.DoubleTensor of size 4x5]\n",
222 | "\n"
223 | ]
224 | },
225 | "execution_count": 8,
226 | "metadata": {},
227 | "output_type": "execute_result"
228 | }
229 | ],
230 | "source": [
231 | "lin.gradWeight"
232 | ]
233 | },
234 | {
235 | "cell_type": "markdown",
236 | "metadata": {},
237 | "source": [
238 | "#### Relation for calcuating the gradient of the loss with respect to the weights of this layer: $\\frac{\\partial L}{\\partial W^{l}} = \\frac{\\partial L}{\\partial O} \\frac{\\partial O}{\\partial W_{l}}$. Glyph based AR application
36 |
Sachin Goyal, Mohit Madan, Michelle Barnette
37 |
38 | We wish to perform glyph based AR using the following steps: 1) Glyph-boundary recognition using edge detection. 2) Estimating of the distortion (orientation and scaling) in 3D space. 3) Placing any image on the glyph in 3D space (applying rigid transformations). 4) Identification of the glyph pattern and placing specific image on glyph. 5) (If time permits) placing a 3D object on glyph.
39 |
40 |