├── 01-tensor_tutorial.ipynb
├── 02-space_stretching.ipynb
├── 03-autograd_tutorial.ipynb
├── 04-spiral_classification.ipynb
├── 05-regression.ipynb
├── 06-convnet.ipynb
├── 07-listening_to_kernels.ipynb
├── 08-seq_classification.ipynb
├── 09-echo_data.ipynb
├── 10-autoencoder.ipynb
├── 11-VAE.ipynb
├── 12-regularization.ipynb
├── 13-bayesian_nn..ipynb
├── 14-truck_backer-upper.ipynb
├── 15-transformer.ipynb
├── 16-gated_GCN.ipynb
├── LICENSE.md
├── README.md
└── res
    ├── plot_lib.py
    ├── sequential_tasks.py
    ├── test
    └── win_xp_shutdown.wav


/03-autograd_tutorial.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Traduction en français du notebook *03* du cours ***Deep Learning*** d'Alfredo Canziani, professeur assistant à la *New York University*  : \n",
  8 |     "https://github.com/Atcold/pytorch-Deep-Learning/blob/master/03-autograd_tutorial.ipynb"
  9 |    ]
 10 |   },
 11 |   {
 12 |    "cell_type": "code",
 13 |    "execution_count": null,
 14 |    "metadata": {},
 15 |    "outputs": [],
 16 |    "source": []
 17 |   },
 18 |   {
 19 |    "cell_type": "markdown",
 20 |    "metadata": {},
 21 |    "source": [
 22 |     "# Autograd : différenciation automatique\n",
 23 |     "\n",
 24 |     "Le package ``autograd`` fournit une différenciation automatique pour toutes les opérations sur les tenseurs. Il s'agit d'un cadre défini par l'utilisateur, ce qui veut dire que votre toile de fond est\n",
 25 |     "défini par la façon dont votre code est exécuté, et que chaque itération peut être différent.\n"
 26 |    ]
 27 |   },
 28 |   {
 29 |    "cell_type": "code",
 30 |    "execution_count": 1,
 31 |    "metadata": {},
 32 |    "outputs": [],
 33 |    "source": [
 34 |     "import torch"
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "markdown",
 39 |    "metadata": {},
 40 |    "source": [
 41 |     "Créer un tenseur :"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 2,
 47 |    "metadata": {},
 48 |    "outputs": [
 49 |     {
 50 |      "name": "stdout",
 51 |      "output_type": "stream",
 52 |      "text": [
 53 |       "tensor([[1., 2.],\n",
 54 |       "        [3., 4.]], requires_grad=True)\n"
 55 |      ]
 56 |     }
 57 |    ],
 58 |    "source": [
 59 |     "# Créer un tenseur 2x2 avec des capacités d'accumulation de gradients\n",
 60 |     "x = torch.tensor([[1, 2], [3, 4]], requires_grad=True, dtype=torch.float32)\n",
 61 |     "print(x)"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "markdown",
 66 |    "metadata": {},
 67 |    "source": [
 68 |     "Effectuer une opération sur le tenseur :"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 3,
 74 |    "metadata": {},
 75 |    "outputs": [
 76 |     {
 77 |      "name": "stdout",
 78 |      "output_type": "stream",
 79 |      "text": [
 80 |       "tensor([[-1.,  0.],\n",
 81 |       "        [ 1.,  2.]], grad_fn=<SubBackward0>)\n"
 82 |      ]
 83 |     }
 84 |    ],
 85 |    "source": [
 86 |     "# Déduire 2 de tous les éléments\n",
 87 |     "y = x - 2\n",
 88 |     "print(y)"
 89 |    ]
 90 |   },
 91 |   {
 92 |    "cell_type": "markdown",
 93 |    "metadata": {},
 94 |    "source": [
 95 |     "``y`` a été créé à la suite d'une opération, il a donc un ``grad_fn``"
 96 |    ]
 97 |   },
 98 |   {
 99 |    "cell_type": "code",
100 |    "execution_count": 4,
101 |    "metadata": {},
102 |    "outputs": [
103 |     {
104 |      "name": "stdout",
105 |      "output_type": "stream",
106 |      "text": [
107 |       "<SubBackward0 object at 0x000002F8E9782278>\n"
108 |      ]
109 |     }
110 |    ],
111 |    "source": [
112 |     "print(y.grad_fn)"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": null,
118 |    "metadata": {},
119 |    "outputs": [],
120 |    "source": [
121 |     "# Qu'est-ce qui se passe ici ?\n",
122 |     "print(x.grad_fn)"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 6,
128 |    "metadata": {},
129 |    "outputs": [
130 |     {
131 |      "data": {
132 |       "text/plain": [
133 |        "<SubBackward0 at 0x2f8e97820b8>"
134 |       ]
135 |      },
136 |      "execution_count": 6,
137 |      "metadata": {},
138 |      "output_type": "execute_result"
139 |     }
140 |    ],
141 |    "source": [
142 |     "# Creusons un peu plus loin...\n",
143 |     "y.grad_fn"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "code",
148 |    "execution_count": 7,
149 |    "metadata": {},
150 |    "outputs": [
151 |     {
152 |      "data": {
153 |       "text/plain": [
154 |        "<AccumulateGrad at 0x2f8e97826d8>"
155 |       ]
156 |      },
157 |      "execution_count": 7,
158 |      "metadata": {},
159 |      "output_type": "execute_result"
160 |     }
161 |    ],
162 |    "source": [
163 |     "y.grad_fn.next_functions[0][0]"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "code",
168 |    "execution_count": 8,
169 |    "metadata": {},
170 |    "outputs": [
171 |     {
172 |      "data": {
173 |       "text/plain": [
174 |        "tensor([[1., 2.],\n",
175 |        "        [3., 4.]], requires_grad=True)"
176 |       ]
177 |      },
178 |      "execution_count": 8,
179 |      "metadata": {},
180 |      "output_type": "execute_result"
181 |     }
182 |    ],
183 |    "source": [
184 |     "y.grad_fn.next_functions[0][0].variable"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "code",
189 |    "execution_count": 9,
190 |    "metadata": {},
191 |    "outputs": [
192 |     {
193 |      "name": "stdout",
194 |      "output_type": "stream",
195 |      "text": [
196 |       "tensor([[ 3.,  0.],\n",
197 |       "        [ 3., 12.]], grad_fn=<MulBackward0>)\n",
198 |       "tensor(4.5000, grad_fn=<MeanBackward0>)\n"
199 |      ]
200 |     }
201 |    ],
202 |    "source": [
203 |     "# Faire plus d'opérations sur  y\n",
204 |     "z = y * y * 3\n",
205 |     "a = z.mean()  # moyenne\n",
206 |     "\n",
207 |     "print(z)\n",
208 |     "print(a)"
209 |    ]
210 |   },
211 |   {
212 |    "cell_type": "code",
213 |    "execution_count": 10,
214 |    "metadata": {},
215 |    "outputs": [],
216 |    "source": [
217 |     "# # Visualisons le graphique de calcul ! (Alfredo tient à remercier ici @szagoruyko)\n",
218 |     "from torchviz import make_dot"
219 |    ]
220 |   },
221 |   {
222 |    "cell_type": "code",
223 |    "execution_count": 21,
224 |    "metadata": {},
225 |    "outputs": [],
226 |    "source": [
227 |     "make_dot(a)"
228 |    ]
229 |   },
230 |   {
231 |    "cell_type": "markdown",
232 |    "metadata": {},
233 |    "source": [
234 |     "## Gradients\n",
235 |     "\n",
236 |     "Rétropropagons maintenant `out.backward()`. Cela équivaut à faire `out.backward(torch.tensor([1.0]))`."
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "code",
241 |    "execution_count": 12,
242 |    "metadata": {},
243 |    "outputs": [],
244 |    "source": [
245 |     "# Rétropropagation\n",
246 |     "a.backward()"
247 |    ]
248 |   },
249 |   {
250 |    "cell_type": "markdown",
251 |    "metadata": {},
252 |    "source": [
253 |     "Affichage des gradients $\\frac{\\text{d}a}{\\text{d}x}$.\n",
254 |     "\n",
255 |     "\n"
256 |    ]
257 |   },
258 |   {
259 |    "cell_type": "code",
260 |    "execution_count": 13,
261 |    "metadata": {},
262 |    "outputs": [
263 |     {
264 |      "name": "stdout",
265 |      "output_type": "stream",
266 |      "text": [
267 |       "tensor([[-1.5000,  0.0000],\n",
268 |       "        [ 1.5000,  3.0000]])\n"
269 |      ]
270 |     }
271 |    ],
272 |    "source": [
273 |     "# Calculez-le à la main AVANT de l'exécuter\n",
274 |     "print(x.grad)"
275 |    ]
276 |   },
277 |   {
278 |    "cell_type": "markdown",
279 |    "metadata": {},
280 |    "source": [
281 |     "Vous pouvez faire beaucoup de choses avec autograd !\n",
282 |     "> Avec une grande *flexibilité* vient une grande responsabilité"
283 |    ]
284 |   },
285 |   {
286 |    "cell_type": "code",
287 |    "execution_count": 14,
288 |    "metadata": {},
289 |    "outputs": [
290 |     {
291 |      "name": "stdout",
292 |      "output_type": "stream",
293 |      "text": [
294 |       "tensor([  12.5663, -995.8140,  188.6319], grad_fn=<MulBackward0>)\n"
295 |      ]
296 |     }
297 |    ],
298 |    "source": [
299 |     "# Graphes dynamiques!\n",
300 |     "x = torch.randn(3, requires_grad=True)\n",
301 |     "\n",
302 |     "y = x * 2\n",
303 |     "i = 0\n",
304 |     "while y.data.norm() < 1000:\n",
305 |     "    y = y * 2\n",
306 |     "    i += 1\n",
307 |     "print(y)"
308 |    ]
309 |   },
310 |   {
311 |    "cell_type": "code",
312 |    "execution_count": 15,
313 |    "metadata": {},
314 |    "outputs": [
315 |     {
316 |      "name": "stdout",
317 |      "output_type": "stream",
318 |      "text": [
319 |       "tensor([5.1200e+01, 5.1200e+02, 5.1200e-02])\n"
320 |      ]
321 |     }
322 |    ],
323 |    "source": [
324 |     "# # Si nous ne faisons pas le *backward* sur un scalaire, nous devons spécifier le *grad_output*\n",
325 |     "gradients = torch.FloatTensor([0.1, 1.0, 0.0001])\n",
326 |     "y.backward(gradients)\n",
327 |     "\n",
328 |     "print(x.grad)"
329 |    ]
330 |   },
331 |   {
332 |    "cell_type": "code",
333 |    "execution_count": 16,
334 |    "metadata": {},
335 |    "outputs": [
336 |     {
337 |      "name": "stdout",
338 |      "output_type": "stream",
339 |      "text": [
340 |       "8\n"
341 |      ]
342 |     }
343 |    ],
344 |    "source": [
345 |     "# AVANT d'éxécuter la cellule, pouvez-vous dire ce qui sera affiché ?\n",
346 |     "print(i)"
347 |    ]
348 |   },
349 |   {
350 |    "cell_type": "markdown",
351 |    "metadata": {},
352 |    "source": [
353 |     "## Inférence"
354 |    ]
355 |   },
356 |   {
357 |    "cell_type": "code",
358 |    "execution_count": 17,
359 |    "metadata": {},
360 |    "outputs": [],
361 |    "source": [
362 |     "# Cette variable détermine l'étendue du tenseur en dessous\n",
363 |     "n = 3"
364 |    ]
365 |   },
366 |   {
367 |    "cell_type": "code",
368 |    "execution_count": 18,
369 |    "metadata": {},
370 |    "outputs": [
371 |     {
372 |      "name": "stdout",
373 |      "output_type": "stream",
374 |      "text": [
375 |       "tensor([1., 1., 1.])\n",
376 |       "tensor([1., 2., 3.])\n"
377 |      ]
378 |     }
379 |    ],
380 |    "source": [
381 |     "# x et w permettent l'accumulation du gradient\n",
382 |     "x = torch.arange(1., n + 1, requires_grad=True)\n",
383 |     "w = torch.ones(n, requires_grad=True)\n",
384 |     "z = w @ x\n",
385 |     "z.backward()\n",
386 |     "print(x.grad, w.grad, sep='\\n')"
387 |    ]
388 |   },
389 |   {
390 |    "cell_type": "code",
391 |    "execution_count": 19,
392 |    "metadata": {},
393 |    "outputs": [
394 |     {
395 |      "name": "stdout",
396 |      "output_type": "stream",
397 |      "text": [
398 |       "None\n",
399 |       "tensor([1., 2., 3.])\n"
400 |      ]
401 |     }
402 |    ],
403 |    "source": [
404 |     "# Seulement w permet l'accumulation du gradient\n",
405 |     "x = torch.arange(1., n + 1)\n",
406 |     "w = torch.ones(n, requires_grad=True)\n",
407 |     "z = w @ x\n",
408 |     "z.backward()\n",
409 |     "print(x.grad, w.grad, sep='\\n')"
410 |    ]
411 |   },
412 |   {
413 |    "cell_type": "code",
414 |    "execution_count": 20,
415 |    "metadata": {},
416 |    "outputs": [
417 |     {
418 |      "name": "stdout",
419 |      "output_type": "stream",
420 |      "text": [
421 |       "RuntimeError!!! >:[\n",
422 |       "element 0 of tensors does not require grad and does not have a grad_fn\n"
423 |      ]
424 |     }
425 |    ],
426 |    "source": [
427 |     "x = torch.arange(1., n + 1)\n",
428 |     "w = torch.ones(n, requires_grad=True)\n",
429 |     "\n",
430 |     "# Indépendamment de ce que vous faites dans ce contexte, tous les tenseurs de torch n'auront pas d'accumulation de gradient\n",
431 |     "with torch.no_grad():\n",
432 |     "    z = w @ x\n",
433 |     "\n",
434 |     "try:\n",
435 |     "    z.backward()  # PyTorch va renvoyer une erreur ici, puisque z n'a pas de grad accum.\n",
436 |     "except RuntimeError as e:\n",
437 |     "    print('RuntimeError!!! >:[')\n",
438 |     "    print(e)"
439 |    ]
440 |   },
441 |   {
442 |    "cell_type": "markdown",
443 |    "metadata": {},
444 |    "source": [
445 |     "## Plus de choses\n",
446 |     "\n",
447 |     "La documentation relative au paquet de différenciation automatique se trouve à l'adresse suivante\n",
448 |     "http://pytorch.org/docs/autograd."
449 |    ]
450 |   }
451 |  ],
452 |  "metadata": {
453 |   "kernelspec": {
454 |    "display_name": "Python 3",
455 |    "language": "python",
456 |    "name": "python3"
457 |   },
458 |   "language_info": {
459 |    "codemirror_mode": {
460 |     "name": "ipython",
461 |     "version": 3
462 |    },
463 |    "file_extension": ".py",
464 |    "mimetype": "text/x-python",
465 |    "name": "python",
466 |    "nbconvert_exporter": "python",
467 |    "pygments_lexer": "ipython3",
468 |    "version": "3.6.5"
469 |   }
470 |  },
471 |  "nbformat": 4,
472 |  "nbformat_minor": 4
473 | }
474 | 


--------------------------------------------------------------------------------
/09-echo_data.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Traduction en français du notebook *09* du cours ***Deep Learning*** d'Alfredo Canziani, professeur assistant à la *New York University* : \n",
  8 |     "https://github.com/Atcold/pytorch-Deep-Learning/blob/master/09-echo_data.ipynb"
  9 |    ]
 10 |   },
 11 |   {
 12 |    "cell_type": "code",
 13 |    "execution_count": null,
 14 |    "metadata": {},
 15 |    "outputs": [],
 16 |    "source": []
 17 |   },
 18 |   {
 19 |    "cell_type": "markdown",
 20 |    "metadata": {},
 21 |    "source": [
 22 |     "# Echo du signal\n",
 23 |     "\n",
 24 |     "L'écho des signaux `n` étapes est un exemple de tâche synchronisée many-to-many (plusieurs à plusieurs)."
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "code",
 29 |    "execution_count": 2,
 30 |    "metadata": {},
 31 |    "outputs": [],
 32 |    "source": [
 33 |     "from res.sequential_tasks import EchoData\n",
 34 |     "import torch\n",
 35 |     "import torch.nn as nn\n",
 36 |     "# import torch.nn.functional as F\n",
 37 |     "import torch.optim as optim\n",
 38 |     "\n",
 39 |     "torch.manual_seed(1);"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": 3,
 45 |    "metadata": {},
 46 |    "outputs": [],
 47 |    "source": [
 48 |     "batch_size = 5\n",
 49 |     "echo_step = 3\n",
 50 |     "series_length = 20_000\n",
 51 |     "BPTT_T = 20\n",
 52 |     "\n",
 53 |     "train_data = EchoData(\n",
 54 |     "    echo_step=echo_step,\n",
 55 |     "    batch_size=batch_size,\n",
 56 |     "    series_length=series_length,\n",
 57 |     "    truncated_length=BPTT_T,\n",
 58 |     ")\n",
 59 |     "train_size = len(train_data)\n",
 60 |     "\n",
 61 |     "test_data = EchoData(\n",
 62 |     "    echo_step=echo_step,\n",
 63 |     "    batch_size=batch_size,\n",
 64 |     "    series_length=series_length,\n",
 65 |     "    truncated_length=BPTT_T,\n",
 66 |     ")\n",
 67 |     "test_size = len(test_data)"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "code",
 72 |    "execution_count": 4,
 73 |    "metadata": {},
 74 |    "outputs": [
 75 |     {
 76 |      "name": "stdout",
 77 |      "output_type": "stream",
 78 |      "text": [
 79 |       "(Premiere sequence d entrée)  x: 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1 ... \n",
 80 |       "(Premiere sequence cible) y: 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 ... \n"
 81 |      ]
 82 |     }
 83 |    ],
 84 |    "source": [
 85 |     "# Affichons les 20 premiers pas des premières séquences pour voir les données d'écho :\n",
 86 |     "print('(Premiere sequence d entrée)  x:', *train_data.x_batch[0, :20], '... ')\n",
 87 |     "print('(Premiere sequence cible) y:', *train_data.y_batch[0, :20], '... ')"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "code",
 92 |    "execution_count": 5,
 93 |    "metadata": {},
 94 |    "outputs": [
 95 |     {
 96 |      "name": "stdout",
 97 |      "output_type": "stream",
 98 |      "text": [
 99 |       "x_batch:\n",
100 |       "0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1 ...\n",
101 |       "1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0 ...\n",
102 |       "0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 0 0 0 ...\n",
103 |       "1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 0 1 0 ...\n",
104 |       "0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 ...\n",
105 |       "x_batch de taille: (5, 20000)\n",
106 |       "\n",
107 |       "y_batch:\n",
108 |       "0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 ...\n",
109 |       "0 0 0 1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 ...\n",
110 |       "0 0 0 0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 ...\n",
111 |       "0 0 0 1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 ...\n",
112 |       "0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 ...\n",
113 |       "y_batch de taille: (5, 20000)\n"
114 |      ]
115 |     }
116 |    ],
117 |    "source": [
118 |     "# des séquences différentes de batch_size sont créées :\n",
119 |     "print('x_batch:', *(str(d)[1:-1] + ' ...' for d in train_data.x_batch[:, :20]), sep='\\n')\n",
120 |     "print('x_batch de taille:', train_data.x_batch.shape)\n",
121 |     "print()\n",
122 |     "print('y_batch:', *(str(d)[1:-1] + ' ...' for d in train_data.y_batch[:, :20]), sep='\\n')\n",
123 |     "print('y_batch de taille:', train_data.y_batch.shape)"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "code",
128 |    "execution_count": 6,
129 |    "metadata": {},
130 |    "outputs": [
131 |     {
132 |      "name": "stdout",
133 |      "output_type": "stream",
134 |      "text": [
135 |       "x_chunk:\n",
136 |       "[0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1]\n",
137 |       "[1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0]\n",
138 |       "[0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 0 0 0]\n",
139 |       "[1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 0 1 0]\n",
140 |       "[0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1]\n",
141 |       "Premier x_chunk de taille: (5, 20, 1)\n",
142 |       "\n",
143 |       "y_chunk:\n",
144 |       "[0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0]\n",
145 |       "[0 0 0 1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1]\n",
146 |       "[0 0 0 0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1]\n",
147 |       "[0 0 0 1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1]\n",
148 |       "[0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0]\n",
149 |       "Premier y_chunk de taille: (5, 20, 1)\n"
150 |      ]
151 |     }
152 |    ],
153 |    "source": [
154 |     "# Pour utiliser les RNN, les données sont organisées en\n",
155 |     "# morceaux de taille [batch_size, T, feature_dim]\n",
156 |     "print('x_chunk:', *train_data.x_chunks[0].squeeze(), sep='\\n')\n",
157 |     "print('Premier x_chunk de taille:', train_data.x_chunks[0].shape)\n",
158 |     "print()\n",
159 |     "print('y_chunk:', *train_data.y_chunks[0].squeeze(), sep='\\n')\n",
160 |     "print('Premier y_chunk de taille:', train_data.y_chunks[0].shape)"
161 |    ]
162 |   },
163 |   {
164 |    "cell_type": "code",
165 |    "execution_count": 7,
166 |    "metadata": {},
167 |    "outputs": [],
168 |    "source": [
169 |     "class SimpleRNN(nn.Module):\n",
170 |     "    def __init__(self, input_size, rnn_hidden_size, output_size):\n",
171 |     "        super().__init__()\n",
172 |     "        self.rnn_hidden_size = rnn_hidden_size\n",
173 |     "        self.rnn = torch.nn.RNN(\n",
174 |     "            input_size=input_size,\n",
175 |     "            hidden_size=rnn_hidden_size,\n",
176 |     "            num_layers=1,\n",
177 |     "            nonlinearity='relu',\n",
178 |     "            batch_first=True\n",
179 |     "        )\n",
180 |     "        self.linear = torch.nn.Linear(\n",
181 |     "            in_features=rnn_hidden_size,\n",
182 |     "            out_features=1\n",
183 |     "        )\n",
184 |     "\n",
185 |     "    def forward(self, x, hidden):\n",
186 |     "        x, hidden = self.rnn(x, hidden)  \n",
187 |     "        x = self.linear(x)\n",
188 |     "        return x, hidden"
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": 8,
194 |    "metadata": {},
195 |    "outputs": [],
196 |    "source": [
197 |     "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
198 |    ]
199 |   },
200 |   {
201 |    "cell_type": "code",
202 |    "execution_count": 9,
203 |    "metadata": {},
204 |    "outputs": [],
205 |    "source": [
206 |     "def train(hidden):\n",
207 |     "    model.train()\n",
208 |     "       \n",
209 |     "    correct = 0\n",
210 |     "    for batch_idx in range(train_size):\n",
211 |     "        data, target = train_data[batch_idx]\n",
212 |     "        data, target = torch.from_numpy(data).float().to(device), torch.from_numpy(target).float().to(device)\n",
213 |     "        optimizer.zero_grad()\n",
214 |     "        if hidden is not None: hidden.detach_()\n",
215 |     "        logits, hidden = model(data, hidden)\n",
216 |     "        loss = criterion(logits, target)\n",
217 |     "        loss.backward()\n",
218 |     "        optimizer.step()\n",
219 |     "        \n",
220 |     "        pred = (torch.sigmoid(logits) > 0.5)\n",
221 |     "        correct += (pred == target.byte()).int().sum().item()\n",
222 |     "        \n",
223 |     "    return correct, loss.item(), hidden"
224 |    ]
225 |   },
226 |   {
227 |    "cell_type": "code",
228 |    "execution_count": 10,
229 |    "metadata": {},
230 |    "outputs": [],
231 |    "source": [
232 |     "def test(hidden):\n",
233 |     "    model.eval()   \n",
234 |     "    correct = 0\n",
235 |     "    with torch.no_grad():\n",
236 |     "        for batch_idx in range(test_size):\n",
237 |     "            data, target = test_data[batch_idx]\n",
238 |     "            data, target = torch.from_numpy(data).float().to(device), torch.from_numpy(target).float().to(device)\n",
239 |     "            logits, hidden = model(data, hidden)\n",
240 |     "            \n",
241 |     "            pred = (torch.sigmoid(logits) > 0.5)\n",
242 |     "            correct += (pred == target.byte()).int().sum().item()\n",
243 |     "\n",
244 |     "    return correct"
245 |    ]
246 |   },
247 |   {
248 |    "cell_type": "code",
249 |    "execution_count": 11,
250 |    "metadata": {},
251 |    "outputs": [],
252 |    "source": [
253 |     "feature_dim = 1 #puisque nous avons une série scalaire\n",
254 |     "h_units = 4\n",
255 |     "\n",
256 |     "model = SimpleRNN(\n",
257 |     "    input_size=1,\n",
258 |     "    rnn_hidden_size=h_units,\n",
259 |     "    output_size=feature_dim\n",
260 |     ").to(device)\n",
261 |     "hidden = None\n",
262 |     "        \n",
263 |     "criterion = torch.nn.BCEWithLogitsLoss()\n",
264 |     "optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001)"
265 |    ]
266 |   },
267 |   {
268 |    "cell_type": "code",
269 |    "execution_count": 12,
270 |    "metadata": {},
271 |    "outputs": [
272 |     {
273 |      "name": "stdout",
274 |      "output_type": "stream",
275 |      "text": [
276 |       "Train Epoch: 1/5, loss: 0.538, accuracy 59.5%\n",
277 |       "Train Epoch: 2/5, loss: 0.082, accuracy 87.1%\n",
278 |       "Train Epoch: 3/5, loss: 0.001, accuracy 100.0%\n",
279 |       "Train Epoch: 4/5, loss: 0.000, accuracy 100.0%\n",
280 |       "Train Epoch: 5/5, loss: 0.000, accuracy 100.0%\n",
281 |       "Test accuracy: 100.0%\n"
282 |      ]
283 |     }
284 |    ],
285 |    "source": [
286 |     "n_epochs = 5\n",
287 |     "epoch = 0\n",
288 |     "\n",
289 |     "while epoch < n_epochs:\n",
290 |     "    correct, loss, hidden = train(hidden)\n",
291 |     "    epoch += 1\n",
292 |     "    train_accuracy = float(correct) / train_size\n",
293 |     "    print(f'Train Epoch: {epoch}/{n_epochs}, loss: {loss:.3f}, accuracy {train_accuracy:.1f}%')\n",
294 |     "\n",
295 |     "#test    \n",
296 |     "correct = test(hidden)\n",
297 |     "test_accuracy = float(correct) / test_size\n",
298 |     "print(f'Test accuracy: {test_accuracy:.1f}%')"
299 |    ]
300 |   },
301 |   {
302 |    "cell_type": "code",
303 |    "execution_count": 13,
304 |    "metadata": {},
305 |    "outputs": [
306 |     {
307 |      "name": "stdout",
308 |      "output_type": "stream",
309 |      "text": [
310 |       "tensor([[1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1,\n",
311 |       "         0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,\n",
312 |       "         0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n",
313 |       "         0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0,\n",
314 |       "         1, 1, 0, 0]], dtype=torch.uint8)\n",
315 |       "tensor([[ True,  True, False, False,  True,  True,  True,  True, False, False,\n",
316 |       "          True,  True,  True,  True,  True,  True, False,  True,  True, False,\n",
317 |       "         False,  True, False, False,  True,  True,  True, False,  True, False,\n",
318 |       "         False,  True,  True, False,  True,  True,  True,  True, False, False,\n",
319 |       "          True,  True, False, False, False, False,  True,  True,  True, False,\n",
320 |       "          True, False, False,  True,  True, False,  True,  True, False,  True,\n",
321 |       "         False, False,  True,  True,  True, False,  True,  True, False,  True,\n",
322 |       "          True,  True,  True, False, False, False, False, False,  True,  True,\n",
323 |       "          True,  True,  True,  True,  True, False, False, False, False, False,\n",
324 |       "         False,  True,  True,  True,  True,  True,  True, False, False,  True]])\n"
325 |      ]
326 |     }
327 |    ],
328 |    "source": [
329 |     "# Essayons un peu d'écho\n",
330 |     "my_input = torch.empty(1, 100, 1).random_(2).to(device)\n",
331 |     "hidden = None\n",
332 |     "my_out, _ = model(my_input, hidden)\n",
333 |     "print(my_input.view(1, -1).byte(), (my_out > 0).view(1, -1), sep='\\n')"
334 |    ]
335 |   }
336 |  ],
337 |  "metadata": {
338 |   "kernelspec": {
339 |    "display_name": "Python 3",
340 |    "language": "python",
341 |    "name": "python3"
342 |   },
343 |   "language_info": {
344 |    "codemirror_mode": {
345 |     "name": "ipython",
346 |     "version": 3
347 |    },
348 |    "file_extension": ".py",
349 |    "mimetype": "text/x-python",
350 |    "name": "python",
351 |    "nbconvert_exporter": "python",
352 |    "pygments_lexer": "ipython3",
353 |    "version": "3.6.5"
354 |   }
355 |  },
356 |  "nbformat": 4,
357 |  "nbformat_minor": 4
358 | }
359 | 


--------------------------------------------------------------------------------
/14-truck_backer-upper.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "markdown",
   5 |    "metadata": {},
   6 |    "source": [
   7 |     "# Traduction en français du notebook *14* du cours ***Deep Learning*** d'Alfredo Canziani, professeur assistant à la *New York University* :\n",
   8 |     "https://github.com/Atcold/pytorch-Deep-Learning/blob/master/14-truck_backer-upper.ipynb"
   9 |    ]
  10 |   },
  11 |   {
  12 |    "cell_type": "code",
  13 |    "execution_count": null,
  14 |    "metadata": {},
  15 |    "outputs": [],
  16 |    "source": []
  17 |   },
  18 |   {
  19 |    "cell_type": "code",
  20 |    "execution_count": 1,
  21 |    "metadata": {},
  22 |    "outputs": [],
  23 |    "source": [
  24 |     "from matplotlib.pylab import *\n",
  25 |     "from matplotlib.patches import Rectangle\n",
  26 |     "from matplotlib.collections import PatchCollection\n",
  27 |     "from matplotlib.lines import Line2D\n",
  28 |     "π = pi"
  29 |    ]
  30 |   },
  31 |   {
  32 |    "cell_type": "code",
  33 |    "execution_count": 2,
  34 |    "metadata": {},
  35 |    "outputs": [],
  36 |    "source": [
  37 |     "style.use(['dark_background', 'bmh'])\n",
  38 |     "%matplotlib notebook"
  39 |    ]
  40 |   },
  41 |   {
  42 |    "cell_type": "markdown",
  43 |    "metadata": {},
  44 |    "source": [
  45 |     "Diagramme voiture-remorque (image inversée `res/car-trainer-k.png` disponible également) :\n",
  46 |     "![voiture-remorque](car-trailer-w.png)\n",
  47 |     "\n",
  48 |     "Équation de la voiture-remorque :\n",
  49 |     "\\begin{align}\n",
  50 |     "\\dot x &= s \\cos \\theta_0 \\\\\n",
  51 |     "\\dot y &= s \\sin \\theta_0 \\\\\n",
  52 |     "\\dot \\theta_0 &= \\frac{s}{L} \\tan \\phi \\\\\n",
  53 |     "\\dot \\theta_1 &= \\frac{s}{d_1} \\sin(\\theta_1 - \\theta_0)\n",
  54 |     "\\end{align}\n",
  55 |     "où $s$ : vitesse signée, $\\phi$ : angle de braquage négatif,"
  56 |    ]
  57 |   },
  58 |   {
  59 |    "cell_type": "code",
  60 |    "execution_count": 3,
  61 |    "metadata": {},
  62 |    "outputs": [],
  63 |    "source": [
  64 |     "class Truck:\n",
  65 |     "    def __init__(self, display=False):\n",
  66 |     "\n",
  67 |     "        self.W = 1  # largeur de la voiture et de la remorque, pour le dessin uniquement\n",
  68 |     "        self.L = 1 * self.W  # longueur de la voiture\n",
  69 |     "        self.d = 4 * self.L  # d_1\n",
  70 |     "        self.s = -0.1  # vitesse\n",
  71 |     "        self.display = display\n",
  72 |     "        \n",
  73 |     "        self.box = [0, 40, -10, 10]\n",
  74 |     "        if self.display:\n",
  75 |     "            self.f = figure(figsize=(10, 5), num='The truck backer-upper', facecolor='none')\n",
  76 |     "            self.ax = self.f.add_axes([0.01, 0.01, 0.98, 0.98], facecolor='black')\n",
  77 |     "            self.patches = list()\n",
  78 |     "            \n",
  79 |     "            self.ax.axis('equal')\n",
  80 |     "            b = self.box\n",
  81 |     "            self.ax.axis([b[0] - 1, b[1], b[2], b[3]])\n",
  82 |     "            self.ax.set_xticks([], []); self.ax.set_yticks([], [])\n",
  83 |     "            self.ax.axhline(); self.ax.axvline()\n",
  84 |     "\n",
  85 |     "        self.reset()\n",
  86 |     "    \n",
  87 |     "    def reset(self, ϕ=0):\n",
  88 |     "        self.ϕ = ϕ  # angle de braquage initial de la voiture\n",
  89 |     "        \n",
  90 |     "        # self.θ0 = deg2rad(30)  # direction initiale de la voiture\n",
  91 |     "        # self.θ1 = deg2rad(-30)  # direction initiale de la remorque\n",
  92 |     "        # self.x, self.y = 20, -5  # les coordonnées initiales de la voiture\n",
  93 |     "        \n",
  94 |     "        self.θ0 = random() * 2 * π  # 0 <= ϑ₀ < 2π\n",
  95 |     "        self.θ1 = (random() - 0.5) * π / 2 + self.θ0  # -π/4 <= ϑ₁ - ϑ₀ < π/4\n",
  96 |     "        self.x = (random() * .75 + 0.25) * self.box[1]\n",
  97 |     "        self.y = (random() - 0.5) * (self.box[3] - self.box[2])\n",
  98 |     "        \n",
  99 |     "        # En cas de mauvaise initialisation, réinitialiser\n",
 100 |     "        if not self.valid():\n",
 101 |     "            self.reset(ϕ)\n",
 102 |     "        \n",
 103 |     "        # Dessine, si display vaut True\n",
 104 |     "        if self.display: self.draw()\n",
 105 |     "    \n",
 106 |     "    def step(self, ϕ=0, dt=1):\n",
 107 |     "        \n",
 108 |     "        # Contrôle des conditions illégales\n",
 109 |     "        if self.is_jackknifed():\n",
 110 |     "            print('Le camion est en portefeuille !')\n",
 111 |     "            return\n",
 112 |     "        \n",
 113 |     "        if self.is_offscreen():\n",
 114 |     "            print('La voiture ou la remorque est hors champ')\n",
 115 |     "            return\n",
 116 |     "        \n",
 117 |     "        self.ϕ = ϕ\n",
 118 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 119 |     "        \n",
 120 |     "        # Effectuer la mise à jour de l'état\n",
 121 |     "        self.x += s * cos(θ0) * dt\n",
 122 |     "        self.y += s * sin(θ0) * dt\n",
 123 |     "        self.θ0 += s / L * tan(ϕ) * dt\n",
 124 |     "        self.θ1 += s / d * sin(θ0 - θ1) * dt\n",
 125 |     "        \n",
 126 |     "        return (self.x, self.y, self.θ0, *self._traler_xy(), self.θ1)\n",
 127 |     "    \n",
 128 |     "    def state(self):\n",
 129 |     "        return (self.x, self.y, self.θ0, *self._traler_xy(), self.θ1)\n",
 130 |     "    \n",
 131 |     "    def _get_atributes(self):\n",
 132 |     "        return (\n",
 133 |     "            self.x, self.y, self.W, self.L, self.d, self.s,\n",
 134 |     "            self.θ0, self.θ1, self.ϕ\n",
 135 |     "        )\n",
 136 |     "    \n",
 137 |     "    def _traler_xy(self):\n",
 138 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 139 |     "        return x - d * cos(θ1), y - d * sin(θ1)\n",
 140 |     "        \n",
 141 |     "    def is_jackknifed(self):\n",
 142 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 143 |     "        return abs(θ0 - θ1) * 180 / π > 90\n",
 144 |     "    \n",
 145 |     "    def is_offscreen(self):\n",
 146 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 147 |     "        \n",
 148 |     "        x1, y1 = x + 1.5 * L * cos(θ0), y + 1.5 * L * sin(θ0)\n",
 149 |     "        x2, y2 = self._traler_xy()\n",
 150 |     "        \n",
 151 |     "        b = self.box\n",
 152 |     "        return not (\n",
 153 |     "            b[0] <= x1 <= b[1] and b[2] <= y1 <= b[3] and\n",
 154 |     "            b[0] <= x2 <= b[1] and b[2] <= y2 <= b[3]\n",
 155 |     "        )\n",
 156 |     "        \n",
 157 |     "    def valid(self):\n",
 158 |     "        return not self.is_jackknifed() and not self.is_offscreen()\n",
 159 |     "        \n",
 160 |     "    def draw(self):\n",
 161 |     "        if not self.display: return\n",
 162 |     "        if self.patches: self.clear()\n",
 163 |     "        self._draw_car()\n",
 164 |     "        self._draw_trailer()\n",
 165 |     "        self.f.canvas.draw()\n",
 166 |     "            \n",
 167 |     "    def clear(self):\n",
 168 |     "        for p in self.patches:\n",
 169 |     "            p.remove()\n",
 170 |     "        self.patches = list()\n",
 171 |     "        \n",
 172 |     "    def _draw_car(self):\n",
 173 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 174 |     "        ax = self.ax\n",
 175 |     "        \n",
 176 |     "        x1, y1 = x + L / 2 * cos(θ0), y + L / 2 * sin(θ0)\n",
 177 |     "        bar = Line2D((x, x1), (y, y1), lw=5, color='C2', alpha=0.8)\n",
 178 |     "        ax.add_line(bar)\n",
 179 |     "\n",
 180 |     "        car = Rectangle(\n",
 181 |     "            (x1, y1 - W / 2), L, W, 0, color='C2', alpha=0.8, transform=\n",
 182 |     "            matplotlib.transforms.Affine2D().rotate_deg_around(x1, y1, θ0 * 180 / π) +\n",
 183 |     "            ax.transData\n",
 184 |     "        )\n",
 185 |     "        ax.add_patch(car)\n",
 186 |     "\n",
 187 |     "        x2, y2 = x1 + L / 2 ** 0.5 * cos(θ0 + π / 4), y1 + L / 2 ** 0.5 * sin(θ0 + π / 4)\n",
 188 |     "        left_wheel = Line2D(\n",
 189 |     "            (x2 - L / 4 * cos(θ0 + ϕ), x2 + L / 4 * cos(θ0 + ϕ)),\n",
 190 |     "            (y2 - L / 4 * sin(θ0 + ϕ), y2 + L / 4 * sin(θ0 + ϕ)),\n",
 191 |     "            lw=3, color='C5', alpha=1)\n",
 192 |     "        ax.add_line(left_wheel)\n",
 193 |     "\n",
 194 |     "        x3, y3 = x1 + L / 2 ** 0.5 * cos(π / 4 - θ0), y1 - L / 2 ** 0.5 * sin(π / 4 - θ0)\n",
 195 |     "        right_wheel = Line2D(\n",
 196 |     "            (x3 - L / 4 * cos(θ0 + ϕ), x3 + L / 4 * cos(θ0 + ϕ)),\n",
 197 |     "            (y3 - L / 4 * sin(θ0 + ϕ), y3 + L / 4 * sin(θ0 + ϕ)),\n",
 198 |     "            lw=3, color='C5', alpha=1)\n",
 199 |     "        ax.add_line(right_wheel)\n",
 200 |     "        \n",
 201 |     "        self.patches += [car, bar, left_wheel, right_wheel]\n",
 202 |     "        \n",
 203 |     "    def _draw_trailer(self):\n",
 204 |     "        x, y, W, L, d, s, θ0, θ1, ϕ = self._get_atributes()\n",
 205 |     "        ax = self.ax\n",
 206 |     "            \n",
 207 |     "        x, y = x - d * cos(θ1), y - d * sin(θ1) - W / 2\n",
 208 |     "        trailer = Rectangle(\n",
 209 |     "            (x, y), d, W, 0, color='C0', alpha=0.8, transform=\n",
 210 |     "            matplotlib.transforms.Affine2D().rotate_deg_around(x, y + W/2, θ1 * 180 / π) +\n",
 211 |     "            ax.transData\n",
 212 |     "        )\n",
 213 |     "        ax.add_patch(trailer)\n",
 214 |     "        \n",
 215 |     "        self.patches += [trailer]"
 216 |    ]
 217 |   },
 218 |   {
 219 |    "cell_type": "code",
 220 |    "execution_count": 4,
 221 |    "metadata": {},
 222 |    "outputs": [
 223 |     {
 224 |      "data": {
 225 |       "application/javascript": [
 226 |        "/* Put everything inside the global mpl namespace */\n",
 227 |        "window.mpl = {};\n",
 228 |        "\n",
 229 |        "\n",
 230 |        "mpl.get_websocket_type = function() {\n",
 231 |        "    if (typeof(WebSocket) !== 'undefined') {\n",
 232 |        "        return WebSocket;\n",
 233 |        "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
 234 |        "        return MozWebSocket;\n",
 235 |        "    } else {\n",
 236 |        "        alert('Your browser does not have WebSocket support. ' +\n",
 237 |        "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
 238 |        "              'Firefox 4 and 5 are also supported but you ' +\n",
 239 |        "              'have to enable WebSockets in about:config.');\n",
 240 |        "    };\n",
 241 |        "}\n",
 242 |        "\n",
 243 |        "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
 244 |        "    this.id = figure_id;\n",
 245 |        "\n",
 246 |        "    this.ws = websocket;\n",
 247 |        "\n",
 248 |        "    this.supports_binary = (this.ws.binaryType != undefined);\n",
 249 |        "\n",
 250 |        "    if (!this.supports_binary) {\n",
 251 |        "        var warnings = document.getElementById(\"mpl-warnings\");\n",
 252 |        "        if (warnings) {\n",
 253 |        "            warnings.style.display = 'block';\n",
 254 |        "            warnings.textContent = (\n",
 255 |        "                \"This browser does not support binary websocket messages. \" +\n",
 256 |        "                    \"Performance may be slow.\");\n",
 257 |        "        }\n",
 258 |        "    }\n",
 259 |        "\n",
 260 |        "    this.imageObj = new Image();\n",
 261 |        "\n",
 262 |        "    this.context = undefined;\n",
 263 |        "    this.message = undefined;\n",
 264 |        "    this.canvas = undefined;\n",
 265 |        "    this.rubberband_canvas = undefined;\n",
 266 |        "    this.rubberband_context = undefined;\n",
 267 |        "    this.format_dropdown = undefined;\n",
 268 |        "\n",
 269 |        "    this.image_mode = 'full';\n",
 270 |        "\n",
 271 |        "    this.root = $('<div/>');\n",
 272 |        "    this._root_extra_style(this.root)\n",
 273 |        "    this.root.attr('style', 'display: inline-block');\n",
 274 |        "\n",
 275 |        "    $(parent_element).append(this.root);\n",
 276 |        "\n",
 277 |        "    this._init_header(this);\n",
 278 |        "    this._init_canvas(this);\n",
 279 |        "    this._init_toolbar(this);\n",
 280 |        "\n",
 281 |        "    var fig = this;\n",
 282 |        "\n",
 283 |        "    this.waiting = false;\n",
 284 |        "\n",
 285 |        "    this.ws.onopen =  function () {\n",
 286 |        "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
 287 |        "            fig.send_message(\"send_image_mode\", {});\n",
 288 |        "            if (mpl.ratio != 1) {\n",
 289 |        "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
 290 |        "            }\n",
 291 |        "            fig.send_message(\"refresh\", {});\n",
 292 |        "        }\n",
 293 |        "\n",
 294 |        "    this.imageObj.onload = function() {\n",
 295 |        "            if (fig.image_mode == 'full') {\n",
 296 |        "                // Full images could contain transparency (where diff images\n",
 297 |        "                // almost always do), so we need to clear the canvas so that\n",
 298 |        "                // there is no ghosting.\n",
 299 |        "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
 300 |        "            }\n",
 301 |        "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
 302 |        "        };\n",
 303 |        "\n",
 304 |        "    this.imageObj.onunload = function() {\n",
 305 |        "        fig.ws.close();\n",
 306 |        "    }\n",
 307 |        "\n",
 308 |        "    this.ws.onmessage = this._make_on_message_function(this);\n",
 309 |        "\n",
 310 |        "    this.ondownload = ondownload;\n",
 311 |        "}\n",
 312 |        "\n",
 313 |        "mpl.figure.prototype._init_header = function() {\n",
 314 |        "    var titlebar = $(\n",
 315 |        "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
 316 |        "        'ui-helper-clearfix\"/>');\n",
 317 |        "    var titletext = $(\n",
 318 |        "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
 319 |        "        'text-align: center; padding: 3px;\"/>');\n",
 320 |        "    titlebar.append(titletext)\n",
 321 |        "    this.root.append(titlebar);\n",
 322 |        "    this.header = titletext[0];\n",
 323 |        "}\n",
 324 |        "\n",
 325 |        "\n",
 326 |        "\n",
 327 |        "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
 328 |        "\n",
 329 |        "}\n",
 330 |        "\n",
 331 |        "\n",
 332 |        "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
 333 |        "\n",
 334 |        "}\n",
 335 |        "\n",
 336 |        "mpl.figure.prototype._init_canvas = function() {\n",
 337 |        "    var fig = this;\n",
 338 |        "\n",
 339 |        "    var canvas_div = $('<div/>');\n",
 340 |        "\n",
 341 |        "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
 342 |        "\n",
 343 |        "    function canvas_keyboard_event(event) {\n",
 344 |        "        return fig.key_event(event, event['data']);\n",
 345 |        "    }\n",
 346 |        "\n",
 347 |        "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
 348 |        "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
 349 |        "    this.canvas_div = canvas_div\n",
 350 |        "    this._canvas_extra_style(canvas_div)\n",
 351 |        "    this.root.append(canvas_div);\n",
 352 |        "\n",
 353 |        "    var canvas = $('<canvas/>');\n",
 354 |        "    canvas.addClass('mpl-canvas');\n",
 355 |        "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
 356 |        "\n",
 357 |        "    this.canvas = canvas[0];\n",
 358 |        "    this.context = canvas[0].getContext(\"2d\");\n",
 359 |        "\n",
 360 |        "    var backingStore = this.context.backingStorePixelRatio ||\n",
 361 |        "\tthis.context.webkitBackingStorePixelRatio ||\n",
 362 |        "\tthis.context.mozBackingStorePixelRatio ||\n",
 363 |        "\tthis.context.msBackingStorePixelRatio ||\n",
 364 |        "\tthis.context.oBackingStorePixelRatio ||\n",
 365 |        "\tthis.context.backingStorePixelRatio || 1;\n",
 366 |        "\n",
 367 |        "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
 368 |        "\n",
 369 |        "    var rubberband = $('<canvas/>');\n",
 370 |        "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
 371 |        "\n",
 372 |        "    var pass_mouse_events = true;\n",
 373 |        "\n",
 374 |        "    canvas_div.resizable({\n",
 375 |        "        start: function(event, ui) {\n",
 376 |        "            pass_mouse_events = false;\n",
 377 |        "        },\n",
 378 |        "        resize: function(event, ui) {\n",
 379 |        "            fig.request_resize(ui.size.width, ui.size.height);\n",
 380 |        "        },\n",
 381 |        "        stop: function(event, ui) {\n",
 382 |        "            pass_mouse_events = true;\n",
 383 |        "            fig.request_resize(ui.size.width, ui.size.height);\n",
 384 |        "        },\n",
 385 |        "    });\n",
 386 |        "\n",
 387 |        "    function mouse_event_fn(event) {\n",
 388 |        "        if (pass_mouse_events)\n",
 389 |        "            return fig.mouse_event(event, event['data']);\n",
 390 |        "    }\n",
 391 |        "\n",
 392 |        "    rubberband.mousedown('button_press', mouse_event_fn);\n",
 393 |        "    rubberband.mouseup('button_release', mouse_event_fn);\n",
 394 |        "    // Throttle sequential mouse events to 1 every 20ms.\n",
 395 |        "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
 396 |        "\n",
 397 |        "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
 398 |        "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
 399 |        "\n",
 400 |        "    canvas_div.on(\"wheel\", function (event) {\n",
 401 |        "        event = event.originalEvent;\n",
 402 |        "        event['data'] = 'scroll'\n",
 403 |        "        if (event.deltaY < 0) {\n",
 404 |        "            event.step = 1;\n",
 405 |        "        } else {\n",
 406 |        "            event.step = -1;\n",
 407 |        "        }\n",
 408 |        "        mouse_event_fn(event);\n",
 409 |        "    });\n",
 410 |        "\n",
 411 |        "    canvas_div.append(canvas);\n",
 412 |        "    canvas_div.append(rubberband);\n",
 413 |        "\n",
 414 |        "    this.rubberband = rubberband;\n",
 415 |        "    this.rubberband_canvas = rubberband[0];\n",
 416 |        "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
 417 |        "    this.rubberband_context.strokeStyle = \"#000000\";\n",
 418 |        "\n",
 419 |        "    this._resize_canvas = function(width, height) {\n",
 420 |        "        // Keep the size of the canvas, canvas container, and rubber band\n",
 421 |        "        // canvas in synch.\n",
 422 |        "        canvas_div.css('width', width)\n",
 423 |        "        canvas_div.css('height', height)\n",
 424 |        "\n",
 425 |        "        canvas.attr('width', width * mpl.ratio);\n",
 426 |        "        canvas.attr('height', height * mpl.ratio);\n",
 427 |        "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
 428 |        "\n",
 429 |        "        rubberband.attr('width', width);\n",
 430 |        "        rubberband.attr('height', height);\n",
 431 |        "    }\n",
 432 |        "\n",
 433 |        "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
 434 |        "    // upon first draw.\n",
 435 |        "    this._resize_canvas(600, 600);\n",
 436 |        "\n",
 437 |        "    // Disable right mouse context menu.\n",
 438 |        "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
 439 |        "        return false;\n",
 440 |        "    });\n",
 441 |        "\n",
 442 |        "    function set_focus () {\n",
 443 |        "        canvas.focus();\n",
 444 |        "        canvas_div.focus();\n",
 445 |        "    }\n",
 446 |        "\n",
 447 |        "    window.setTimeout(set_focus, 100);\n",
 448 |        "}\n",
 449 |        "\n",
 450 |        "mpl.figure.prototype._init_toolbar = function() {\n",
 451 |        "    var fig = this;\n",
 452 |        "\n",
 453 |        "    var nav_element = $('<div/>');\n",
 454 |        "    nav_element.attr('style', 'width: 100%');\n",
 455 |        "    this.root.append(nav_element);\n",
 456 |        "\n",
 457 |        "    // Define a callback function for later on.\n",
 458 |        "    function toolbar_event(event) {\n",
 459 |        "        return fig.toolbar_button_onclick(event['data']);\n",
 460 |        "    }\n",
 461 |        "    function toolbar_mouse_event(event) {\n",
 462 |        "        return fig.toolbar_button_onmouseover(event['data']);\n",
 463 |        "    }\n",
 464 |        "\n",
 465 |        "    for(var toolbar_ind in mpl.toolbar_items) {\n",
 466 |        "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
 467 |        "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
 468 |        "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
 469 |        "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
 470 |        "\n",
 471 |        "        if (!name) {\n",
 472 |        "            // put a spacer in here.\n",
 473 |        "            continue;\n",
 474 |        "        }\n",
 475 |        "        var button = $('<button/>');\n",
 476 |        "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
 477 |        "                        'ui-button-icon-only');\n",
 478 |        "        button.attr('role', 'button');\n",
 479 |        "        button.attr('aria-disabled', 'false');\n",
 480 |        "        button.click(method_name, toolbar_event);\n",
 481 |        "        button.mouseover(tooltip, toolbar_mouse_event);\n",
 482 |        "\n",
 483 |        "        var icon_img = $('<span/>');\n",
 484 |        "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
 485 |        "        icon_img.addClass(image);\n",
 486 |        "        icon_img.addClass('ui-corner-all');\n",
 487 |        "\n",
 488 |        "        var tooltip_span = $('<span/>');\n",
 489 |        "        tooltip_span.addClass('ui-button-text');\n",
 490 |        "        tooltip_span.html(tooltip);\n",
 491 |        "\n",
 492 |        "        button.append(icon_img);\n",
 493 |        "        button.append(tooltip_span);\n",
 494 |        "\n",
 495 |        "        nav_element.append(button);\n",
 496 |        "    }\n",
 497 |        "\n",
 498 |        "    var fmt_picker_span = $('<span/>');\n",
 499 |        "\n",
 500 |        "    var fmt_picker = $('<select/>');\n",
 501 |        "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
 502 |        "    fmt_picker_span.append(fmt_picker);\n",
 503 |        "    nav_element.append(fmt_picker_span);\n",
 504 |        "    this.format_dropdown = fmt_picker[0];\n",
 505 |        "\n",
 506 |        "    for (var ind in mpl.extensions) {\n",
 507 |        "        var fmt = mpl.extensions[ind];\n",
 508 |        "        var option = $(\n",
 509 |        "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
 510 |        "        fmt_picker.append(option);\n",
 511 |        "    }\n",
 512 |        "\n",
 513 |        "    // Add hover states to the ui-buttons\n",
 514 |        "    $( \".ui-button\" ).hover(\n",
 515 |        "        function() { $(this).addClass(\"ui-state-hover\");},\n",
 516 |        "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
 517 |        "    );\n",
 518 |        "\n",
 519 |        "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
 520 |        "    nav_element.append(status_bar);\n",
 521 |        "    this.message = status_bar[0];\n",
 522 |        "}\n",
 523 |        "\n",
 524 |        "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
 525 |        "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
 526 |        "    // which will in turn request a refresh of the image.\n",
 527 |        "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
 528 |        "}\n",
 529 |        "\n",
 530 |        "mpl.figure.prototype.send_message = function(type, properties) {\n",
 531 |        "    properties['type'] = type;\n",
 532 |        "    properties['figure_id'] = this.id;\n",
 533 |        "    this.ws.send(JSON.stringify(properties));\n",
 534 |        "}\n",
 535 |        "\n",
 536 |        "mpl.figure.prototype.send_draw_message = function() {\n",
 537 |        "    if (!this.waiting) {\n",
 538 |        "        this.waiting = true;\n",
 539 |        "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
 540 |        "    }\n",
 541 |        "}\n",
 542 |        "\n",
 543 |        "\n",
 544 |        "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
 545 |        "    var format_dropdown = fig.format_dropdown;\n",
 546 |        "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
 547 |        "    fig.ondownload(fig, format);\n",
 548 |        "}\n",
 549 |        "\n",
 550 |        "\n",
 551 |        "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
 552 |        "    var size = msg['size'];\n",
 553 |        "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
 554 |        "        fig._resize_canvas(size[0], size[1]);\n",
 555 |        "        fig.send_message(\"refresh\", {});\n",
 556 |        "    };\n",
 557 |        "}\n",
 558 |        "\n",
 559 |        "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
 560 |        "    var x0 = msg['x0'] / mpl.ratio;\n",
 561 |        "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
 562 |        "    var x1 = msg['x1'] / mpl.ratio;\n",
 563 |        "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
 564 |        "    x0 = Math.floor(x0) + 0.5;\n",
 565 |        "    y0 = Math.floor(y0) + 0.5;\n",
 566 |        "    x1 = Math.floor(x1) + 0.5;\n",
 567 |        "    y1 = Math.floor(y1) + 0.5;\n",
 568 |        "    var min_x = Math.min(x0, x1);\n",
 569 |        "    var min_y = Math.min(y0, y1);\n",
 570 |        "    var width = Math.abs(x1 - x0);\n",
 571 |        "    var height = Math.abs(y1 - y0);\n",
 572 |        "\n",
 573 |        "    fig.rubberband_context.clearRect(\n",
 574 |        "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
 575 |        "\n",
 576 |        "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
 577 |        "}\n",
 578 |        "\n",
 579 |        "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
 580 |        "    // Updates the figure title.\n",
 581 |        "    fig.header.textContent = msg['label'];\n",
 582 |        "}\n",
 583 |        "\n",
 584 |        "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
 585 |        "    var cursor = msg['cursor'];\n",
 586 |        "    switch(cursor)\n",
 587 |        "    {\n",
 588 |        "    case 0:\n",
 589 |        "        cursor = 'pointer';\n",
 590 |        "        break;\n",
 591 |        "    case 1:\n",
 592 |        "        cursor = 'default';\n",
 593 |        "        break;\n",
 594 |        "    case 2:\n",
 595 |        "        cursor = 'crosshair';\n",
 596 |        "        break;\n",
 597 |        "    case 3:\n",
 598 |        "        cursor = 'move';\n",
 599 |        "        break;\n",
 600 |        "    }\n",
 601 |        "    fig.rubberband_canvas.style.cursor = cursor;\n",
 602 |        "}\n",
 603 |        "\n",
 604 |        "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
 605 |        "    fig.message.textContent = msg['message'];\n",
 606 |        "}\n",
 607 |        "\n",
 608 |        "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
 609 |        "    // Request the server to send over a new figure.\n",
 610 |        "    fig.send_draw_message();\n",
 611 |        "}\n",
 612 |        "\n",
 613 |        "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
 614 |        "    fig.image_mode = msg['mode'];\n",
 615 |        "}\n",
 616 |        "\n",
 617 |        "mpl.figure.prototype.updated_canvas_event = function() {\n",
 618 |        "    // Called whenever the canvas gets updated.\n",
 619 |        "    this.send_message(\"ack\", {});\n",
 620 |        "}\n",
 621 |        "\n",
 622 |        "// A function to construct a web socket function for onmessage handling.\n",
 623 |        "// Called in the figure constructor.\n",
 624 |        "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
 625 |        "    return function socket_on_message(evt) {\n",
 626 |        "        if (evt.data instanceof Blob) {\n",
 627 |        "            /* FIXME: We get \"Resource interpreted as Image but\n",
 628 |        "             * transferred with MIME type text/plain:\" errors on\n",
 629 |        "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
 630 |        "             * to be part of the websocket stream */\n",
 631 |        "            evt.data.type = \"image/png\";\n",
 632 |        "\n",
 633 |        "            /* Free the memory for the previous frames */\n",
 634 |        "            if (fig.imageObj.src) {\n",
 635 |        "                (window.URL || window.webkitURL).revokeObjectURL(\n",
 636 |        "                    fig.imageObj.src);\n",
 637 |        "            }\n",
 638 |        "\n",
 639 |        "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
 640 |        "                evt.data);\n",
 641 |        "            fig.updated_canvas_event();\n",
 642 |        "            fig.waiting = false;\n",
 643 |        "            return;\n",
 644 |        "        }\n",
 645 |        "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
 646 |        "            fig.imageObj.src = evt.data;\n",
 647 |        "            fig.updated_canvas_event();\n",
 648 |        "            fig.waiting = false;\n",
 649 |        "            return;\n",
 650 |        "        }\n",
 651 |        "\n",
 652 |        "        var msg = JSON.parse(evt.data);\n",
 653 |        "        var msg_type = msg['type'];\n",
 654 |        "\n",
 655 |        "        // Call the  \"handle_{type}\" callback, which takes\n",
 656 |        "        // the figure and JSON message as its only arguments.\n",
 657 |        "        try {\n",
 658 |        "            var callback = fig[\"handle_\" + msg_type];\n",
 659 |        "        } catch (e) {\n",
 660 |        "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
 661 |        "            return;\n",
 662 |        "        }\n",
 663 |        "\n",
 664 |        "        if (callback) {\n",
 665 |        "            try {\n",
 666 |        "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
 667 |        "                callback(fig, msg);\n",
 668 |        "            } catch (e) {\n",
 669 |        "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
 670 |        "            }\n",
 671 |        "        }\n",
 672 |        "    };\n",
 673 |        "}\n",
 674 |        "\n",
 675 |        "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
 676 |        "mpl.findpos = function(e) {\n",
 677 |        "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
 678 |        "    var targ;\n",
 679 |        "    if (!e)\n",
 680 |        "        e = window.event;\n",
 681 |        "    if (e.target)\n",
 682 |        "        targ = e.target;\n",
 683 |        "    else if (e.srcElement)\n",
 684 |        "        targ = e.srcElement;\n",
 685 |        "    if (targ.nodeType == 3) // defeat Safari bug\n",
 686 |        "        targ = targ.parentNode;\n",
 687 |        "\n",
 688 |        "    // jQuery normalizes the pageX and pageY\n",
 689 |        "    // pageX,Y are the mouse positions relative to the document\n",
 690 |        "    // offset() returns the position of the element relative to the document\n",
 691 |        "    var x = e.pageX - $(targ).offset().left;\n",
 692 |        "    var y = e.pageY - $(targ).offset().top;\n",
 693 |        "\n",
 694 |        "    return {\"x\": x, \"y\": y};\n",
 695 |        "};\n",
 696 |        "\n",
 697 |        "/*\n",
 698 |        " * return a copy of an object with only non-object keys\n",
 699 |        " * we need this to avoid circular references\n",
 700 |        " * http://stackoverflow.com/a/24161582/3208463\n",
 701 |        " */\n",
 702 |        "function simpleKeys (original) {\n",
 703 |        "  return Object.keys(original).reduce(function (obj, key) {\n",
 704 |        "    if (typeof original[key] !== 'object')\n",
 705 |        "        obj[key] = original[key]\n",
 706 |        "    return obj;\n",
 707 |        "  }, {});\n",
 708 |        "}\n",
 709 |        "\n",
 710 |        "mpl.figure.prototype.mouse_event = function(event, name) {\n",
 711 |        "    var canvas_pos = mpl.findpos(event)\n",
 712 |        "\n",
 713 |        "    if (name === 'button_press')\n",
 714 |        "    {\n",
 715 |        "        this.canvas.focus();\n",
 716 |        "        this.canvas_div.focus();\n",
 717 |        "    }\n",
 718 |        "\n",
 719 |        "    var x = canvas_pos.x * mpl.ratio;\n",
 720 |        "    var y = canvas_pos.y * mpl.ratio;\n",
 721 |        "\n",
 722 |        "    this.send_message(name, {x: x, y: y, button: event.button,\n",
 723 |        "                             step: event.step,\n",
 724 |        "                             guiEvent: simpleKeys(event)});\n",
 725 |        "\n",
 726 |        "    /* This prevents the web browser from automatically changing to\n",
 727 |        "     * the text insertion cursor when the button is pressed.  We want\n",
 728 |        "     * to control all of the cursor setting manually through the\n",
 729 |        "     * 'cursor' event from matplotlib */\n",
 730 |        "    event.preventDefault();\n",
 731 |        "    return false;\n",
 732 |        "}\n",
 733 |        "\n",
 734 |        "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
 735 |        "    // Handle any extra behaviour associated with a key event\n",
 736 |        "}\n",
 737 |        "\n",
 738 |        "mpl.figure.prototype.key_event = function(event, name) {\n",
 739 |        "\n",
 740 |        "    // Prevent repeat events\n",
 741 |        "    if (name == 'key_press')\n",
 742 |        "    {\n",
 743 |        "        if (event.which === this._key)\n",
 744 |        "            return;\n",
 745 |        "        else\n",
 746 |        "            this._key = event.which;\n",
 747 |        "    }\n",
 748 |        "    if (name == 'key_release')\n",
 749 |        "        this._key = null;\n",
 750 |        "\n",
 751 |        "    var value = '';\n",
 752 |        "    if (event.ctrlKey && event.which != 17)\n",
 753 |        "        value += \"ctrl+\";\n",
 754 |        "    if (event.altKey && event.which != 18)\n",
 755 |        "        value += \"alt+\";\n",
 756 |        "    if (event.shiftKey && event.which != 16)\n",
 757 |        "        value += \"shift+\";\n",
 758 |        "\n",
 759 |        "    value += 'k';\n",
 760 |        "    value += event.which.toString();\n",
 761 |        "\n",
 762 |        "    this._key_event_extra(event, name);\n",
 763 |        "\n",
 764 |        "    this.send_message(name, {key: value,\n",
 765 |        "                             guiEvent: simpleKeys(event)});\n",
 766 |        "    return false;\n",
 767 |        "}\n",
 768 |        "\n",
 769 |        "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
 770 |        "    if (name == 'download') {\n",
 771 |        "        this.handle_save(this, null);\n",
 772 |        "    } else {\n",
 773 |        "        this.send_message(\"toolbar_button\", {name: name});\n",
 774 |        "    }\n",
 775 |        "};\n",
 776 |        "\n",
 777 |        "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
 778 |        "    this.message.textContent = tooltip;\n",
 779 |        "};\n",
 780 |        "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
 781 |        "\n",
 782 |        "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
 783 |        "\n",
 784 |        "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
 785 |        "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
 786 |        "    // object with the appropriate methods. Currently this is a non binary\n",
 787 |        "    // socket, so there is still some room for performance tuning.\n",
 788 |        "    var ws = {};\n",
 789 |        "\n",
 790 |        "    ws.close = function() {\n",
 791 |        "        comm.close()\n",
 792 |        "    };\n",
 793 |        "    ws.send = function(m) {\n",
 794 |        "        //console.log('sending', m);\n",
 795 |        "        comm.send(m);\n",
 796 |        "    };\n",
 797 |        "    // Register the callback with on_msg.\n",
 798 |        "    comm.on_msg(function(msg) {\n",
 799 |        "        //console.log('receiving', msg['content']['data'], msg);\n",
 800 |        "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
 801 |        "        ws.onmessage(msg['content']['data'])\n",
 802 |        "    });\n",
 803 |        "    return ws;\n",
 804 |        "}\n",
 805 |        "\n",
 806 |        "mpl.mpl_figure_comm = function(comm, msg) {\n",
 807 |        "    // This is the function which gets called when the mpl process\n",
 808 |        "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
 809 |        "\n",
 810 |        "    var id = msg.content.data.id;\n",
 811 |        "    // Get hold of the div created by the display call when the Comm\n",
 812 |        "    // socket was opened in Python.\n",
 813 |        "    var element = $(\"#\" + id);\n",
 814 |        "    var ws_proxy = comm_websocket_adapter(comm)\n",
 815 |        "\n",
 816 |        "    function ondownload(figure, format) {\n",
 817 |        "        window.open(figure.imageObj.src);\n",
 818 |        "    }\n",
 819 |        "\n",
 820 |        "    var fig = new mpl.figure(id, ws_proxy,\n",
 821 |        "                           ondownload,\n",
 822 |        "                           element.get(0));\n",
 823 |        "\n",
 824 |        "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
 825 |        "    // web socket which is closed, not our websocket->open comm proxy.\n",
 826 |        "    ws_proxy.onopen();\n",
 827 |        "\n",
 828 |        "    fig.parent_element = element.get(0);\n",
 829 |        "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
 830 |        "    if (!fig.cell_info) {\n",
 831 |        "        console.error(\"Failed to find cell for figure\", id, fig);\n",
 832 |        "        return;\n",
 833 |        "    }\n",
 834 |        "\n",
 835 |        "    var output_index = fig.cell_info[2]\n",
 836 |        "    var cell = fig.cell_info[0];\n",
 837 |        "\n",
 838 |        "};\n",
 839 |        "\n",
 840 |        "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
 841 |        "    var width = fig.canvas.width/mpl.ratio\n",
 842 |        "    fig.root.unbind('remove')\n",
 843 |        "\n",
 844 |        "    // Update the output cell to use the data from the current canvas.\n",
 845 |        "    fig.push_to_output();\n",
 846 |        "    var dataURL = fig.canvas.toDataURL();\n",
 847 |        "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
 848 |        "    // the notebook keyboard shortcuts fail.\n",
 849 |        "    IPython.keyboard_manager.enable()\n",
 850 |        "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
 851 |        "    fig.close_ws(fig, msg);\n",
 852 |        "}\n",
 853 |        "\n",
 854 |        "mpl.figure.prototype.close_ws = function(fig, msg){\n",
 855 |        "    fig.send_message('closing', msg);\n",
 856 |        "    // fig.ws.close()\n",
 857 |        "}\n",
 858 |        "\n",
 859 |        "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
 860 |        "    // Turn the data on the canvas into data in the output cell.\n",
 861 |        "    var width = this.canvas.width/mpl.ratio\n",
 862 |        "    var dataURL = this.canvas.toDataURL();\n",
 863 |        "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
 864 |        "}\n",
 865 |        "\n",
 866 |        "mpl.figure.prototype.updated_canvas_event = function() {\n",
 867 |        "    // Tell IPython that the notebook contents must change.\n",
 868 |        "    IPython.notebook.set_dirty(true);\n",
 869 |        "    this.send_message(\"ack\", {});\n",
 870 |        "    var fig = this;\n",
 871 |        "    // Wait a second, then push the new image to the DOM so\n",
 872 |        "    // that it is saved nicely (might be nice to debounce this).\n",
 873 |        "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
 874 |        "}\n",
 875 |        "\n",
 876 |        "mpl.figure.prototype._init_toolbar = function() {\n",
 877 |        "    var fig = this;\n",
 878 |        "\n",
 879 |        "    var nav_element = $('<div/>');\n",
 880 |        "    nav_element.attr('style', 'width: 100%');\n",
 881 |        "    this.root.append(nav_element);\n",
 882 |        "\n",
 883 |        "    // Define a callback function for later on.\n",
 884 |        "    function toolbar_event(event) {\n",
 885 |        "        return fig.toolbar_button_onclick(event['data']);\n",
 886 |        "    }\n",
 887 |        "    function toolbar_mouse_event(event) {\n",
 888 |        "        return fig.toolbar_button_onmouseover(event['data']);\n",
 889 |        "    }\n",
 890 |        "\n",
 891 |        "    for(var toolbar_ind in mpl.toolbar_items){\n",
 892 |        "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
 893 |        "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
 894 |        "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
 895 |        "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
 896 |        "\n",
 897 |        "        if (!name) { continue; };\n",
 898 |        "\n",
 899 |        "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
 900 |        "        button.click(method_name, toolbar_event);\n",
 901 |        "        button.mouseover(tooltip, toolbar_mouse_event);\n",
 902 |        "        nav_element.append(button);\n",
 903 |        "    }\n",
 904 |        "\n",
 905 |        "    // Add the status bar.\n",
 906 |        "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
 907 |        "    nav_element.append(status_bar);\n",
 908 |        "    this.message = status_bar[0];\n",
 909 |        "\n",
 910 |        "    // Add the close button to the window.\n",
 911 |        "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
 912 |        "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
 913 |        "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
 914 |        "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
 915 |        "    buttongrp.append(button);\n",
 916 |        "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
 917 |        "    titlebar.prepend(buttongrp);\n",
 918 |        "}\n",
 919 |        "\n",
 920 |        "mpl.figure.prototype._root_extra_style = function(el){\n",
 921 |        "    var fig = this\n",
 922 |        "    el.on(\"remove\", function(){\n",
 923 |        "\tfig.close_ws(fig, {});\n",
 924 |        "    });\n",
 925 |        "}\n",
 926 |        "\n",
 927 |        "mpl.figure.prototype._canvas_extra_style = function(el){\n",
 928 |        "    // this is important to make the div 'focusable\n",
 929 |        "    el.attr('tabindex', 0)\n",
 930 |        "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
 931 |        "    // off when our div gets focus\n",
 932 |        "\n",
 933 |        "    // location in version 3\n",
 934 |        "    if (IPython.notebook.keyboard_manager) {\n",
 935 |        "        IPython.notebook.keyboard_manager.register_events(el);\n",
 936 |        "    }\n",
 937 |        "    else {\n",
 938 |        "        // location in version 2\n",
 939 |        "        IPython.keyboard_manager.register_events(el);\n",
 940 |        "    }\n",
 941 |        "\n",
 942 |        "}\n",
 943 |        "\n",
 944 |        "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
 945 |        "    var manager = IPython.notebook.keyboard_manager;\n",
 946 |        "    if (!manager)\n",
 947 |        "        manager = IPython.keyboard_manager;\n",
 948 |        "\n",
 949 |        "    // Check for shift+enter\n",
 950 |        "    if (event.shiftKey && event.which == 13) {\n",
 951 |        "        this.canvas_div.blur();\n",
 952 |        "        // select the cell after this one\n",
 953 |        "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
 954 |        "        IPython.notebook.select(index + 1);\n",
 955 |        "    }\n",
 956 |        "}\n",
 957 |        "\n",
 958 |        "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
 959 |        "    fig.ondownload(fig, null);\n",
 960 |        "}\n",
 961 |        "\n",
 962 |        "\n",
 963 |        "mpl.find_output_cell = function(html_output) {\n",
 964 |        "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
 965 |        "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
 966 |        "    // IPython event is triggered only after the cells have been serialised, which for\n",
 967 |        "    // our purposes (turning an active figure into a static one), is too late.\n",
 968 |        "    var cells = IPython.notebook.get_cells();\n",
 969 |        "    var ncells = cells.length;\n",
 970 |        "    for (var i=0; i<ncells; i++) {\n",
 971 |        "        var cell = cells[i];\n",
 972 |        "        if (cell.cell_type === 'code'){\n",
 973 |        "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
 974 |        "                var data = cell.output_area.outputs[j];\n",
 975 |        "                if (data.data) {\n",
 976 |        "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
 977 |        "                    data = data.data;\n",
 978 |        "                }\n",
 979 |        "                if (data['text/html'] == html_output) {\n",
 980 |        "                    return [cell, data, j];\n",
 981 |        "                }\n",
 982 |        "            }\n",
 983 |        "        }\n",
 984 |        "    }\n",
 985 |        "}\n",
 986 |        "\n",
 987 |        "// Register the function which deals with the matplotlib target/channel.\n",
 988 |        "// The kernel may be null if the page has been refreshed.\n",
 989 |        "if (IPython.notebook.kernel != null) {\n",
 990 |        "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
 991 |        "}\n"
 992 |       ],
 993 |       "text/plain": [
 994 |        "<IPython.core.display.Javascript object>"
 995 |       ]
 996 |      },
 997 |      "metadata": {},
 998 |      "output_type": "display_data"
 999 |     },
1000 |     {
1001 |      "data": {
1002 |       "text/html": [
1003 |        "<img src=\"data:image/png;base64,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\" width=\"1000\">"
1004 |       ],
1005 |       "text/plain": [
1006 |        "<IPython.core.display.HTML object>"
1007 |       ]
1008 |      },
1009 |      "metadata": {},
1010 |      "output_type": "display_data"
1011 |     },
1012 |     {
1013 |      "name": "stderr",
1014 |      "output_type": "stream",
1015 |      "text": [
1016 |       "C:\\Users\\loick\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:19: MatplotlibDeprecationWarning: Passing the minor parameter of set_xticks() positionally is deprecated since Matplotlib 3.2; the parameter will become keyword-only two minor releases later.\n",
1017 |       "C:\\Users\\loick\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:19: MatplotlibDeprecationWarning: Passing the minor parameter of set_yticks() positionally is deprecated since Matplotlib 3.2; the parameter will become keyword-only two minor releases later.\n"
1018 |      ]
1019 |     }
1020 |    ],
1021 |    "source": [
1022 |     "truck = Truck(display=True)"
1023 |    ]
1024 |   },
1025 |   {
1026 |    "cell_type": "code",
1027 |    "execution_count": 5,
1028 |    "metadata": {},
1029 |    "outputs": [],
1030 |    "source": [
1031 |     "ϕ = deg2rad(-35)  # positif à gauche, négatif à droite\n",
1032 |     "truck.step(ϕ)\n",
1033 |     "truck.draw()"
1034 |    ]
1035 |   },
1036 |   {
1037 |    "cell_type": "code",
1038 |    "execution_count": 6,
1039 |    "metadata": {},
1040 |    "outputs": [],
1041 |    "source": [
1042 |     "truck.reset()"
1043 |    ]
1044 |   },
1045 |   {
1046 |    "cell_type": "code",
1047 |    "execution_count": 7,
1048 |    "metadata": {},
1049 |    "outputs": [],
1050 |    "source": [
1051 |     "import torch\n",
1052 |     "import torch.nn as nn\n",
1053 |     "from torch.optim import SGD\n",
1054 |     "from tqdm import tqdm"
1055 |    ]
1056 |   },
1057 |   {
1058 |    "cell_type": "code",
1059 |    "execution_count": 8,
1060 |    "metadata": {},
1061 |    "outputs": [
1062 |     {
1063 |      "name": "stderr",
1064 |      "output_type": "stream",
1065 |      "text": [
1066 |       "100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [00:12<00:00,  1.22s/it]\n"
1067 |      ]
1068 |     }
1069 |    ],
1070 |    "source": [
1071 |     "# Construire un jeu de données expert\n",
1072 |     "\n",
1073 |     "episodes = 10\n",
1074 |     "inputs = list()\n",
1075 |     "outputs = list()\n",
1076 |     "# truck = Truck(); episodes = 10_000  # décommenter pour créer le jeu de données test\n",
1077 |     "\n",
1078 |     "for episode in tqdm(range(episodes)):\n",
1079 |     "    \n",
1080 |     "    truck.reset()\n",
1081 |     "    \n",
1082 |     "    while truck.valid():\n",
1083 |     "        initial_state = truck.state()\n",
1084 |     "        ϕ = (random() - 0.5) * π / 2\n",
1085 |     "        inputs.append((ϕ, *initial_state))\n",
1086 |     "        outputs.append(truck.step(ϕ))\n",
1087 |     "        truck.draw()"
1088 |    ]
1089 |   },
1090 |   {
1091 |    "cell_type": "code",
1092 |    "execution_count": 9,
1093 |    "metadata": {},
1094 |    "outputs": [
1095 |     {
1096 |      "data": {
1097 |       "text/plain": [
1098 |        "(702, 702)"
1099 |       ]
1100 |      },
1101 |      "execution_count": 9,
1102 |      "metadata": {},
1103 |      "output_type": "execute_result"
1104 |     }
1105 |    ],
1106 |    "source": [
1107 |     "len(inputs), len(outputs)"
1108 |    ]
1109 |   },
1110 |   {
1111 |    "cell_type": "code",
1112 |    "execution_count": 10,
1113 |    "metadata": {},
1114 |    "outputs": [],
1115 |    "source": [
1116 |     "state_size = 6\n",
1117 |     "steering_size = 1\n",
1118 |     "hidden_units_e = 45\n",
1119 |     "\n",
1120 |     "emulator = nn.Sequential(\n",
1121 |     "    nn.Linear(steering_size + state_size, hidden_units_e),\n",
1122 |     "    nn.ReLU(),\n",
1123 |     "    nn.Linear(hidden_units_e, state_size)\n",
1124 |     ")\n",
1125 |     "\n",
1126 |     "optimiser_e = SGD(emulator.parameters(), lr=0.005)\n",
1127 |     "criterion = nn.MSELoss()"
1128 |    ]
1129 |   },
1130 |   {
1131 |    "cell_type": "code",
1132 |    "execution_count": 11,
1133 |    "metadata": {},
1134 |    "outputs": [],
1135 |    "source": [
1136 |     "tensor_inputs = torch.Tensor(inputs)\n",
1137 |     "tensor_outputs = torch.Tensor(outputs)"
1138 |    ]
1139 |   },
1140 |   {
1141 |    "cell_type": "code",
1142 |    "execution_count": 12,
1143 |    "metadata": {},
1144 |    "outputs": [],
1145 |    "source": [
1146 |     "mean = tensor_inputs.mean(0)\n",
1147 |     "std = tensor_inputs.std(0)\n",
1148 |     "tensor_inputs = (tensor_inputs - mean) / std\n",
1149 |     "tensor_outputs = (tensor_outputs - mean[1:]) / std[1:]"
1150 |    ]
1151 |   },
1152 |   {
1153 |    "cell_type": "code",
1154 |    "execution_count": 13,
1155 |    "metadata": {},
1156 |    "outputs": [
1157 |     {
1158 |      "name": "stdout",
1159 |      "output_type": "stream",
1160 |      "text": [
1161 |       "702 561\n"
1162 |      ]
1163 |     }
1164 |    ],
1165 |    "source": [
1166 |     "# Découpe les données en 80/20 pour entraînement/test\n",
1167 |     "test_size = int(len(tensor_inputs) * 0.8)\n",
1168 |     "print(len(tensor_inputs), test_size)\n",
1169 |     "\n",
1170 |     "train_inputs = tensor_inputs[:test_size]\n",
1171 |     "train_outputs = tensor_outputs[:test_size]\n",
1172 |     "test_inputs = tensor_inputs[test_size:]\n",
1173 |     "test_outputs = tensor_outputs[test_size:]"
1174 |    ]
1175 |   },
1176 |   {
1177 |    "cell_type": "code",
1178 |    "execution_count": 14,
1179 |    "metadata": {},
1180 |    "outputs": [
1181 |     {
1182 |      "data": {
1183 |       "text/plain": [
1184 |        "561"
1185 |       ]
1186 |      },
1187 |      "execution_count": 14,
1188 |      "metadata": {},
1189 |      "output_type": "execute_result"
1190 |     }
1191 |    ],
1192 |    "source": [
1193 |     "len(train_inputs)"
1194 |    ]
1195 |   },
1196 |   {
1197 |    "cell_type": "code",
1198 |    "execution_count": 15,
1199 |    "metadata": {},
1200 |    "outputs": [
1201 |     {
1202 |      "name": "stdout",
1203 |      "output_type": "stream",
1204 |      "text": [
1205 |       "   1 / 561, 0.8471342921\n"
1206 |      ]
1207 |     }
1208 |    ],
1209 |    "source": [
1210 |     "# Entraînement de l'émulateur\n",
1211 |     "cnt = 0\n",
1212 |     "for i in torch.randperm(len(train_inputs)):\n",
1213 |     "    ϕ_state = train_inputs[i]\n",
1214 |     "    next_state_prediction = emulator(ϕ_state)\n",
1215 |     "    \n",
1216 |     "    next_state = train_outputs[i]\n",
1217 |     "    loss = criterion(next_state_prediction, next_state)\n",
1218 |     "    \n",
1219 |     "    optimiser_e.zero_grad()\n",
1220 |     "    loss.backward()\n",
1221 |     "    optimiser_e.step()\n",
1222 |     "    \n",
1223 |     "    if cnt == 0 or (cnt + 1) % 1000 == 0:\n",
1224 |     "        print(f'{cnt + 1:4d} / {len(train_inputs)}, {loss.item():.10f}')\n",
1225 |     "    cnt += 1"
1226 |    ]
1227 |   },
1228 |   {
1229 |    "cell_type": "code",
1230 |    "execution_count": 16,
1231 |    "metadata": {},
1232 |    "outputs": [
1233 |     {
1234 |      "name": "stdout",
1235 |      "output_type": "stream",
1236 |      "text": [
1237 |       "Test loss: 0.0527631068\n"
1238 |      ]
1239 |     }
1240 |    ],
1241 |    "source": [
1242 |     "# Test\n",
1243 |     "total_loss = 0\n",
1244 |     "with torch.no_grad():\n",
1245 |     "    for idx, ϕ_state in enumerate(test_inputs):\n",
1246 |     "        next_state_prediction = emulator(ϕ_state)\n",
1247 |     "\n",
1248 |     "        next_state = test_outputs[idx]\n",
1249 |     "        total_loss += criterion(next_state_prediction, next_state).item()\n",
1250 |     "\n",
1251 |     "ave_test_loss = total_loss/test_size\n",
1252 |     "print(f'Test loss: {ave_test_loss:.10f}')"
1253 |    ]
1254 |   },
1255 |   {
1256 |    "cell_type": "code",
1257 |    "execution_count": null,
1258 |    "metadata": {},
1259 |    "outputs": [],
1260 |    "source": [
1261 |     "# Ici vous devez insérer le code pour l'entraînement du contrôleur\n",
1262 |     "# en utilisant l'émulateur pour la rétropropagation\n",
1263 |     "\n",
1264 |     "# Si vous réussissez, n'hésitez pas à envoyer une PR"
1265 |    ]
1266 |   }
1267 |  ],
1268 |  "metadata": {
1269 |   "kernelspec": {
1270 |    "display_name": "Python 3",
1271 |    "language": "python",
1272 |    "name": "python3"
1273 |   },
1274 |   "language_info": {
1275 |    "codemirror_mode": {
1276 |     "name": "ipython",
1277 |     "version": 3
1278 |    },
1279 |    "file_extension": ".py",
1280 |    "mimetype": "text/x-python",
1281 |    "name": "python",
1282 |    "nbconvert_exporter": "python",
1283 |    "pygments_lexer": "ipython3",
1284 |    "version": "3.6.5"
1285 |   }
1286 |  },
1287 |  "nbformat": 4,
1288 |  "nbformat_minor": 4
1289 | }
1290 | 


--------------------------------------------------------------------------------
/15-transformer.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Traduction en français du notebook *15* du cours ***Deep Learning*** d'Alfredo Canziani, professeur assistant à la *New York University* :\n",
  8 |     "https://github.com/Atcold/pytorch-Deep-Learning/blob/master/15-transformer.ipynb"
  9 |    ]
 10 |   },
 11 |   {
 12 |    "cell_type": "code",
 13 |    "execution_count": null,
 14 |    "metadata": {},
 15 |    "outputs": [],
 16 |    "source": []
 17 |   },
 18 |   {
 19 |    "cell_type": "markdown",
 20 |    "metadata": {},
 21 |    "source": [
 22 |     "# Transformers\n",
 23 |     "\n",
 24 |     "Pour comprendre tout ce qui se passe ci-dessous, consultez d'abord les notes de cours / la leçon vidéo."
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "code",
 29 |    "execution_count": 1,
 30 |    "metadata": {},
 31 |    "outputs": [],
 32 |    "source": [
 33 |     "import torch \n",
 34 |     "from torch import nn\n",
 35 |     "import torch.nn.functional as f\n",
 36 |     "import numpy as np "
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": 2,
 42 |    "metadata": {},
 43 |    "outputs": [],
 44 |    "source": [
 45 |     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
 46 |     "nn_Softargmax = nn.Softmax  "
 47 |    ]
 48 |   },
 49 |   {
 50 |    "cell_type": "markdown",
 51 |    "metadata": {},
 52 |    "source": [
 53 |     "## Attention multi-têtes"
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": 3,
 59 |    "metadata": {},
 60 |    "outputs": [],
 61 |    "source": [
 62 |     "class MultiHeadAttention(nn.Module):\n",
 63 |     "    def __init__(self, d_model, num_heads, p, d_input=None):\n",
 64 |     "        super().__init__()\n",
 65 |     "        self.num_heads = num_heads\n",
 66 |     "        self.d_model = d_model\n",
 67 |     "        if d_input is None:\n",
 68 |     "            d_xq = d_xk = d_xv = d_model\n",
 69 |     "        else:\n",
 70 |     "            d_xq, d_xk, d_xv = d_input\n",
 71 |     "            \n",
 72 |     "        # S'assurer que la dimension d'enchâssement du modèle est un multiple du nombre de têtes\n",
 73 |     "        assert d_model % self.num_heads == 0\n",
 74 |     "\n",
 75 |     "        self.d_k = d_model // self.num_heads\n",
 76 |     "        \n",
 77 |     "        # Ils sont encore de dimension d_model. Ils seront divisés en nombre de têtes \n",
 78 |     "        self.W_q = nn.Linear(d_xq, d_model, bias=False)\n",
 79 |     "        self.W_k = nn.Linear(d_xk, d_model, bias=False)\n",
 80 |     "        self.W_v = nn.Linear(d_xv, d_model, bias=False)\n",
 81 |     "        \n",
 82 |     "        # Les résultats de toutes les sous-couches doivent être de dimension d_model\n",
 83 |     "        self.W_h = nn.Linear(d_model, d_model)\n",
 84 |     "        \n",
 85 |     "    def scaled_dot_product_attention(self, Q, K, V):\n",
 86 |     "        batch_size = Q.size(0) \n",
 87 |     "        k_length = K.size(-2) \n",
 88 |     "        \n",
 89 |     "        # Mise à l'échelle par d_k pour que le soft(arg)max ne sature pas\n",
 90 |     "        Q = Q / np.sqrt(self.d_k)                         # (bs, n_heads, q_length, dim_per_head)\n",
 91 |     "        scores = torch.matmul(Q, K.transpose(2,3))          # (bs, n_heads, q_length, k_length)\n",
 92 |     "        \n",
 93 |     "        A = nn_Softargmax(dim=-1)(scores)   # (bs, n_heads, q_length, k_length)\n",
 94 |     "        \n",
 95 |     "        # Obtenir la moyenne pondérée des valeurs\n",
 96 |     "        H = torch.matmul(A, V)     # (bs, n_heads, q_length, dim_per_head)\n",
 97 |     "\n",
 98 |     "        return H, A \n",
 99 |     "\n",
100 |     "        \n",
101 |     "    def split_heads(self, x, batch_size):\n",
102 |     "        \"\"\"\n",
103 |     "        Découpe la dernière dimension en (têtes X profondeur)\n",
104 |     "        Retourne après transposition pour mettre en forme (batch_size X num_heads X seq_length X d_k)\n",
105 |     "        \"\"\"\n",
106 |     "        return x.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)\n",
107 |     "\n",
108 |     "    def group_heads(self, x, batch_size):\n",
109 |     "        \"\"\"\n",
110 |     "        Combinez à nouveau les têtes pour obtenir (batch_size X seq_length X (num_heads times d_k))\n",
111 |     "        \"\"\"\n",
112 |     "        return x.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k)\n",
113 |     "    \n",
114 |     "\n",
115 |     "    def forward(self, X_q, X_k, X_v):\n",
116 |     "        batch_size, seq_length, dim = X_q.size()\n",
117 |     "\n",
118 |     "        # Après transformation, découpage en num_heads \n",
119 |     "        Q = self.split_heads(self.W_q(X_q), batch_size)  # (bs, n_heads, q_length, dim_per_head)\n",
120 |     "        K = self.split_heads(self.W_k(X_k), batch_size)  # (bs, n_heads, k_length, dim_per_head)\n",
121 |     "        V = self.split_heads(self.W_v(X_v), batch_size)  # (bs, n_heads, v_length, dim_per_head)\n",
122 |     "        \n",
123 |     "        # Calculer les poids d'attention pour chacune des têtes\n",
124 |     "        H_cat, A = self.scaled_dot_product_attention(Q, K, V)\n",
125 |     "        \n",
126 |     "        # Remettre toutes les têtes ensemble par concaténation\n",
127 |     "        H_cat = self.group_heads(H_cat, batch_size)    # (bs, q_length, dim)\n",
128 |     "        \n",
129 |     "        # Couche linéaire finale  \n",
130 |     "        H = self.W_h(H_cat)          # (bs, q_length, dim)\n",
131 |     "        \n",
132 |     "        return H, A"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "markdown",
137 |    "metadata": {},
138 |    "source": [
139 |     "### Quelques contrôles :"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": 4,
145 |    "metadata": {},
146 |    "outputs": [],
147 |    "source": [
148 |     "temp_mha = MultiHeadAttention(d_model=512, num_heads=8, p=0)\n",
149 |     "def print_out(Q, K, V):\n",
150 |     "    temp_out, temp_attn = temp_mha.scaled_dot_product_attention(Q, K, V)\n",
151 |     "    print('Les poids d attention sont:', temp_attn.squeeze())\n",
152 |     "    print('La sortie est:', temp_out.squeeze())"
153 |    ]
154 |   },
155 |   {
156 |    "cell_type": "markdown",
157 |    "metadata": {},
158 |    "source": [
159 |     "Pour vérifier que notre auto-attention fonctionne : si la requête correspond à l'une des valeurs clés, toute l'attention doit y être portée, la valeur renvoyée étant celle de cet indice"
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "code",
164 |    "execution_count": 5,
165 |    "metadata": {
166 |     "scrolled": true
167 |    },
168 |    "outputs": [
169 |     {
170 |      "name": "stdout",
171 |      "output_type": "stream",
172 |      "text": [
173 |       "Les poids d attention sont: tensor([3.7266e-06, 9.9999e-01, 3.7266e-06, 3.7266e-06])\n",
174 |       "La sortie est: tensor([1.0004e+01, 4.0993e-05, 0.0000e+00])\n"
175 |      ]
176 |     }
177 |    ],
178 |    "source": [
179 |     "test_K = torch.tensor(\n",
180 |     "    [[10, 0, 0],\n",
181 |     "     [ 0,10, 0],\n",
182 |     "     [ 0, 0,10],\n",
183 |     "     [ 0, 0,10]]\n",
184 |     ").float()[None,None]\n",
185 |     "\n",
186 |     "test_V = torch.tensor(\n",
187 |     "    [[   1,0,0],\n",
188 |     "     [  10,0,0],\n",
189 |     "     [ 100,5,0],\n",
190 |     "     [1000,6,0]]\n",
191 |     ").float()[None,None]\n",
192 |     "\n",
193 |     "test_Q = torch.tensor(\n",
194 |     "    [[0, 10, 0]]\n",
195 |     ").float()[None,None]\n",
196 |     "print_out(test_Q, test_K, test_V)"
197 |    ]
198 |   },
199 |   {
200 |    "cell_type": "markdown",
201 |    "metadata": {},
202 |    "source": [
203 |     "Super ! On peut voir qu'il se concentre sur la deuxième clé et renvoie la deuxième valeur. \n",
204 |     "\n",
205 |     "Si nous donnons une requête qui correspond exactement à deux clés, elle devrait retourner la valeur moyenne des deux valeurs pour ces deux clés. "
206 |    ]
207 |   },
208 |   {
209 |    "cell_type": "code",
210 |    "execution_count": 6,
211 |    "metadata": {},
212 |    "outputs": [
213 |     {
214 |      "name": "stdout",
215 |      "output_type": "stream",
216 |      "text": [
217 |       "Les poids d attention sont: tensor([1.8633e-06, 1.8633e-06, 5.0000e-01, 5.0000e-01])\n",
218 |       "La sortie est: tensor([549.9979,   5.5000,   0.0000])\n"
219 |      ]
220 |     }
221 |    ],
222 |    "source": [
223 |     "test_Q = torch.tensor([[0, 0, 10]]).float()  \n",
224 |     "print_out(test_Q, test_K, test_V)"
225 |    ]
226 |   },
227 |   {
228 |    "cell_type": "markdown",
229 |    "metadata": {},
230 |    "source": [
231 |     "Nous constatons qu'il se concentre à parts égales sur la troisième et la quatrième clé et renvoie la moyenne de leurs valeurs.\n",
232 |     "\n",
233 |     "Il donne maintenant toutes les requêtes en même temps :"
234 |    ]
235 |   },
236 |   {
237 |    "cell_type": "code",
238 |    "execution_count": 7,
239 |    "metadata": {},
240 |    "outputs": [
241 |     {
242 |      "name": "stdout",
243 |      "output_type": "stream",
244 |      "text": [
245 |       "Les poids d attention sont: tensor([[1.8633e-06, 1.8633e-06, 5.0000e-01, 5.0000e-01],\n",
246 |       "        [3.7266e-06, 9.9999e-01, 3.7266e-06, 3.7266e-06],\n",
247 |       "        [5.0000e-01, 5.0000e-01, 1.8633e-06, 1.8633e-06]])\n",
248 |       "La sortie est: tensor([[5.5000e+02, 5.5000e+00, 0.0000e+00],\n",
249 |       "        [1.0004e+01, 4.0993e-05, 0.0000e+00],\n",
250 |       "        [5.5020e+00, 2.0497e-05, 0.0000e+00]])\n"
251 |      ]
252 |     }
253 |    ],
254 |    "source": [
255 |     "test_Q = torch.tensor(\n",
256 |     "    [[0, 0, 10], [0, 10, 0], [10, 10, 0]]\n",
257 |     ").float()[None,None]\n",
258 |     "print_out(test_Q, test_K, test_V)"
259 |    ]
260 |   },
261 |   {
262 |    "cell_type": "markdown",
263 |    "metadata": {},
264 |    "source": [
265 |     "## Convolution 1D  avec `kernel_size = 1`"
266 |    ]
267 |   },
268 |   {
269 |    "cell_type": "markdown",
270 |    "metadata": {},
271 |    "source": [
272 |     "Il s'agit essentiellement d'un MLP avec une couche cachée et une activation ReLU appliquée à chaque élément de l'ensemble."
273 |    ]
274 |   },
275 |   {
276 |    "cell_type": "code",
277 |    "execution_count": 8,
278 |    "metadata": {},
279 |    "outputs": [],
280 |    "source": [
281 |     "class CNN(nn.Module):\n",
282 |     "    def __init__(self, d_model, hidden_dim, p):\n",
283 |     "        super().__init__()\n",
284 |     "        self.k1convL1 = nn.Linear(d_model,    hidden_dim)\n",
285 |     "        self.k1convL2 = nn.Linear(hidden_dim, d_model)\n",
286 |     "        self.activation = nn.ReLU()\n",
287 |     "\n",
288 |     "    def forward(self, x):\n",
289 |     "        x = self.k1convL1(x)\n",
290 |     "        x = self.activation(x)\n",
291 |     "        x = self.k1convL2(x)\n",
292 |     "        return x"
293 |    ]
294 |   },
295 |   {
296 |    "cell_type": "markdown",
297 |    "metadata": {},
298 |    "source": [
299 |     "## Bloc encodeur du Transformer"
300 |    ]
301 |   },
302 |   {
303 |    "cell_type": "markdown",
304 |    "metadata": {},
305 |    "source": [
306 |     "Nous avons maintenant tous les composants pour le bloc encodeur du Transformer ci-dessous !!!"
307 |    ]
308 |   },
309 |   {
310 |    "cell_type": "code",
311 |    "execution_count": 9,
312 |    "metadata": {},
313 |    "outputs": [],
314 |    "source": [
315 |     "class EncoderLayer(nn.Module):\n",
316 |     "    def __init__(self, d_model, num_heads, conv_hidden_dim, p=0.1):\n",
317 |     "        super().__init__()\n",
318 |     "\n",
319 |     "        self.mha = MultiHeadAttention(d_model, num_heads, p)\n",
320 |     "        self.cnn = CNN(d_model, conv_hidden_dim, p)\n",
321 |     "\n",
322 |     "        self.layernorm1 = nn.LayerNorm(normalized_shape=d_model, eps=1e-6)\n",
323 |     "        self.layernorm2 = nn.LayerNorm(normalized_shape=d_model, eps=1e-6)\n",
324 |     "    \n",
325 |     "    def forward(self, x):\n",
326 |     "        \n",
327 |     "        # Attention multi-têtes \n",
328 |     "        attn_output, _ = self.mha(x, x, x)  # (batch_size, input_seq_len, d_model)\n",
329 |     "        \n",
330 |     "        # Couche de normalisation après avoir ajouté la connexion résiduelle \n",
331 |     "        out1 = self.layernorm1(x + attn_output)  # (batch_size, input_seq_len, d_model)\n",
332 |     "        \n",
333 |     "        # Passe avant \n",
334 |     "        cnn_output = self.cnn(out1)  # (batch_size, input_seq_len, d_model)\n",
335 |     "        \n",
336 |     "        # Deuxième couche de normalisation après avoir ajouté la connexion résiduelle \n",
337 |     "        out2 = self.layernorm2(out1 + cnn_output)  # (batch_size, input_seq_len, d_model)\n",
338 |     "\n",
339 |     "        return out2"
340 |    ]
341 |   },
342 |   {
343 |    "cell_type": "markdown",
344 |    "metadata": {},
345 |    "source": [
346 |     "### Encodeur \n",
347 |     "#### Blocks de N couches d'encodeurs + encodage positionnel + enchâssement des entrées"
348 |    ]
349 |   },
350 |   {
351 |    "cell_type": "markdown",
352 |    "metadata": {},
353 |    "source": [
354 |     "L'auto-attention en elle-même n'a pas de récurrence ou de convolutions, donc pour la rendre sensible à la position, nous devons fournir des codages de position supplémentaires. Ceux-ci sont calculés comme suit :\n",
355 |     "\n",
356 |     "\\begin{aligned}\n",
357 |     "E(p, 2i)    &= \\sin(p / 10000^{2i / d}) \\\\\n",
358 |     "E(p, 2i+1) &= \\cos(p / 10000^{2i / d})\n",
359 |     "\\end{aligned}"
360 |    ]
361 |   },
362 |   {
363 |    "cell_type": "code",
364 |    "execution_count": 10,
365 |    "metadata": {},
366 |    "outputs": [],
367 |    "source": [
368 |     "def create_sinusoidal_embeddings(nb_p, dim, E):\n",
369 |     "    theta = np.array([\n",
370 |     "        [p / np.power(10000, 2 * (j // 2) / dim) for j in range(dim)]\n",
371 |     "        for p in range(nb_p)\n",
372 |     "    ])\n",
373 |     "    E[:, 0::2] = torch.FloatTensor(np.sin(theta[:, 0::2]))\n",
374 |     "    E[:, 1::2] = torch.FloatTensor(np.cos(theta[:, 1::2]))\n",
375 |     "    E.detach_()\n",
376 |     "    E.requires_grad = False\n",
377 |     "    E = E.to(device)\n",
378 |     "\n",
379 |     "class Embeddings(nn.Module):\n",
380 |     "    def __init__(self, d_model, vocab_size, max_position_embeddings, p):\n",
381 |     "        super().__init__()\n",
382 |     "        self.word_embeddings = nn.Embedding(vocab_size, d_model, padding_idx=1)\n",
383 |     "        self.position_embeddings = nn.Embedding(max_position_embeddings, d_model)\n",
384 |     "        create_sinusoidal_embeddings(\n",
385 |     "            nb_p=max_position_embeddings,\n",
386 |     "            dim=d_model,\n",
387 |     "            E=self.position_embeddings.weight\n",
388 |     "        )\n",
389 |     "\n",
390 |     "        self.LayerNorm = nn.LayerNorm(d_model, eps=1e-12)\n",
391 |     "\n",
392 |     "    def forward(self, input_ids):\n",
393 |     "        seq_length = input_ids.size(1)\n",
394 |     "        position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device) # (max_seq_length)\n",
395 |     "        position_ids = position_ids.unsqueeze(0).expand_as(input_ids)                      # (bs, max_seq_length)\n",
396 |     "        \n",
397 |     "        # Obtenir l'enchâssement des mots pour chaque entrée id\n",
398 |     "        word_embeddings = self.word_embeddings(input_ids)                   # (bs, max_seq_length, dim)\n",
399 |     "        \n",
400 |     "        # Obtenir la position d'enchâssement pour chaque position\n",
401 |     "        position_embeddings = self.position_embeddings(position_ids)        # (bs, max_seq_length, dim)\n",
402 |     "        \n",
403 |     "        # Sommer les deux \n",
404 |     "        embeddings = word_embeddings + position_embeddings  # (bs, max_seq_length, dim)\n",
405 |     "        \n",
406 |     "        # Couche de normalisation \n",
407 |     "        embeddings = self.LayerNorm(embeddings)             # (bs, max_seq_length, dim)\n",
408 |     "        return embeddings"
409 |    ]
410 |   },
411 |   {
412 |    "cell_type": "code",
413 |    "execution_count": 11,
414 |    "metadata": {},
415 |    "outputs": [],
416 |    "source": [
417 |     "class Encoder(nn.Module):\n",
418 |     "    def __init__(self, num_layers, d_model, num_heads, ff_hidden_dim, input_vocab_size,\n",
419 |     "               maximum_position_encoding, p=0.1):\n",
420 |     "        super().__init__()\n",
421 |     "\n",
422 |     "        self.d_model = d_model\n",
423 |     "        self.num_layers = num_layers\n",
424 |     "\n",
425 |     "        self.embedding = Embeddings(d_model, input_vocab_size,maximum_position_encoding, p)\n",
426 |     "\n",
427 |     "        self.enc_layers = nn.ModuleList()\n",
428 |     "        for _ in range(num_layers):\n",
429 |     "            self.enc_layers.append(EncoderLayer(d_model, num_heads, ff_hidden_dim, p))\n",
430 |     "        \n",
431 |     "    def forward(self, x):\n",
432 |     "        x = self.embedding(x) # Transforme en (batch_size, input_seq_length, d_model)\n",
433 |     "\n",
434 |     "        for i in range(self.num_layers):\n",
435 |     "            x = self.enc_layers[i](x)\n",
436 |     "\n",
437 |     "        return x  # (batch_size, input_seq_len, d_model)"
438 |    ]
439 |   },
440 |   {
441 |    "cell_type": "code",
442 |    "execution_count": 12,
443 |    "metadata": {},
444 |    "outputs": [],
445 |    "source": [
446 |     "import torchtext.data as data\n",
447 |     "import torchtext.datasets as datasets"
448 |    ]
449 |   },
450 |   {
451 |    "cell_type": "code",
452 |    "execution_count": 13,
453 |    "metadata": {},
454 |    "outputs": [
455 |     {
456 |      "name": "stdout",
457 |      "output_type": "stream",
458 |      "text": [
459 |       "train :  25000\n",
460 |       "test :  25000\n",
461 |       "train.fields : {'text': <torchtext.data.field.Field object at 0x0000020960520A90>, 'label': <torchtext.data.field.LabelField object at 0x0000020960520AC8>}\n"
462 |      ]
463 |     }
464 |    ],
465 |    "source": [
466 |     "max_len = 200\n",
467 |     "text = data.Field(sequential=True, fix_length=max_len, batch_first=True, lower=True, dtype=torch.long)\n",
468 |     "label = data.LabelField(sequential=False, dtype=torch.long)\n",
469 |     "datasets.IMDB.download('./')\n",
470 |     "ds_train, ds_test = datasets.IMDB.splits(text, label, path='./imdb/aclImdb/')\n",
471 |     "print('train : ', len(ds_train))\n",
472 |     "print('test : ', len(ds_test))\n",
473 |     "print('train.fields :', ds_train.fields)"
474 |    ]
475 |   },
476 |   {
477 |    "cell_type": "code",
478 |    "execution_count": 14,
479 |    "metadata": {},
480 |    "outputs": [
481 |     {
482 |      "name": "stdout",
483 |      "output_type": "stream",
484 |      "text": [
485 |       "train :  22500\n",
486 |       "valid :  2500\n",
487 |       "test :  25000\n"
488 |      ]
489 |     }
490 |    ],
491 |    "source": [
492 |     "ds_train, ds_valid = ds_train.split(0.9)\n",
493 |     "print('train : ', len(ds_train))\n",
494 |     "print('valid : ', len(ds_valid))\n",
495 |     "print('test : ', len(ds_test))"
496 |    ]
497 |   },
498 |   {
499 |    "cell_type": "code",
500 |    "execution_count": 15,
501 |    "metadata": {},
502 |    "outputs": [],
503 |    "source": [
504 |     "num_words = 50_000\n",
505 |     "text.build_vocab(ds_train, max_size=num_words, specials=['<pad>','<unk>'])\n",
506 |     "label.build_vocab(ds_train)\n",
507 |     "vocab = text.vocab"
508 |    ]
509 |   },
510 |   {
511 |    "cell_type": "code",
512 |    "execution_count": 16,
513 |    "metadata": {},
514 |    "outputs": [],
515 |    "source": [
516 |     "batch_size = 164\n",
517 |     "train_loader, valid_loader, test_loader = data.BucketIterator.splits(\n",
518 |     "    (ds_train, ds_valid, ds_test), batch_size=batch_size, sort_key=lambda x: len(x.text), repeat=False)"
519 |    ]
520 |   },
521 |   {
522 |    "cell_type": "code",
523 |    "execution_count": 17,
524 |    "metadata": {},
525 |    "outputs": [],
526 |    "source": [
527 |     "class TransformerClassifier(nn.Module):\n",
528 |     "    def __init__(self, num_layers, d_model, num_heads, conv_hidden_dim, input_vocab_size, num_answers):\n",
529 |     "        super().__init__()\n",
530 |     "        \n",
531 |     "        self.encoder = Encoder(num_layers, d_model, num_heads, conv_hidden_dim, input_vocab_size,\n",
532 |     "                         maximum_position_encoding=10000)\n",
533 |     "        self.dense = nn.Linear(d_model, num_answers)\n",
534 |     "\n",
535 |     "    def forward(self, x):\n",
536 |     "        x = self.encoder(x)\n",
537 |     "        \n",
538 |     "        x, _ = torch.max(x, dim=1)\n",
539 |     "        x = self.dense(x)\n",
540 |     "        return x"
541 |    ]
542 |   },
543 |   {
544 |    "cell_type": "code",
545 |    "execution_count": 18,
546 |    "metadata": {},
547 |    "outputs": [
548 |     {
549 |      "data": {
550 |       "text/plain": [
551 |        "TransformerClassifier(\n",
552 |        "  (encoder): Encoder(\n",
553 |        "    (embedding): Embeddings(\n",
554 |        "      (word_embeddings): Embedding(50002, 32, padding_idx=1)\n",
555 |        "      (position_embeddings): Embedding(10000, 32)\n",
556 |        "      (LayerNorm): LayerNorm((32,), eps=1e-12, elementwise_affine=True)\n",
557 |        "    )\n",
558 |        "    (enc_layers): ModuleList(\n",
559 |        "      (0): EncoderLayer(\n",
560 |        "        (mha): MultiHeadAttention(\n",
561 |        "          (W_q): Linear(in_features=32, out_features=32, bias=False)\n",
562 |        "          (W_k): Linear(in_features=32, out_features=32, bias=False)\n",
563 |        "          (W_v): Linear(in_features=32, out_features=32, bias=False)\n",
564 |        "          (W_h): Linear(in_features=32, out_features=32, bias=True)\n",
565 |        "        )\n",
566 |        "        (cnn): CNN(\n",
567 |        "          (k1convL1): Linear(in_features=32, out_features=128, bias=True)\n",
568 |        "          (k1convL2): Linear(in_features=128, out_features=32, bias=True)\n",
569 |        "          (activation): ReLU()\n",
570 |        "        )\n",
571 |        "        (layernorm1): LayerNorm((32,), eps=1e-06, elementwise_affine=True)\n",
572 |        "        (layernorm2): LayerNorm((32,), eps=1e-06, elementwise_affine=True)\n",
573 |        "      )\n",
574 |        "    )\n",
575 |        "  )\n",
576 |        "  (dense): Linear(in_features=32, out_features=2, bias=True)\n",
577 |        ")"
578 |       ]
579 |      },
580 |      "execution_count": 18,
581 |      "metadata": {},
582 |      "output_type": "execute_result"
583 |     }
584 |    ],
585 |    "source": [
586 |     "model = TransformerClassifier(num_layers=1, d_model=32, num_heads=2, \n",
587 |     "                         conv_hidden_dim=128, input_vocab_size=50002, num_answers=2)\n",
588 |     "model.to(device)"
589 |    ]
590 |   },
591 |   {
592 |    "cell_type": "code",
593 |    "execution_count": 19,
594 |    "metadata": {},
595 |    "outputs": [],
596 |    "source": [
597 |     "optimizer = torch.optim.AdamW(model.parameters(), lr=0.001)\n",
598 |     "epochs = 10\n",
599 |     "t_total = len(train_loader) * epochs"
600 |    ]
601 |   },
602 |   {
603 |    "cell_type": "code",
604 |    "execution_count": 20,
605 |    "metadata": {},
606 |    "outputs": [],
607 |    "source": [
608 |     "def train(train_loader, valid_loader):\n",
609 |     "    \n",
610 |     "    for epoch in range(epochs):\n",
611 |     "        train_iterator, valid_iterator = iter(train_loader), iter(valid_loader)\n",
612 |     "        nb_batches_train = len(train_loader)\n",
613 |     "        train_acc = 0\n",
614 |     "        model.train()\n",
615 |     "        losses = 0.0\n",
616 |     "\n",
617 |     "        for batch in train_iterator:\n",
618 |     "            x = batch.text.to(device)\n",
619 |     "            y = batch.label.to(device)\n",
620 |     "            \n",
621 |     "            out = model(x)  # ①\n",
622 |     "\n",
623 |     "            loss = f.cross_entropy(out, y)  # ②\n",
624 |     "            \n",
625 |     "            model.zero_grad()  # ③\n",
626 |     "\n",
627 |     "            loss.backward()  # ④\n",
628 |     "            losses += loss.item()\n",
629 |     "\n",
630 |     "            optimizer.step()  # ⑤\n",
631 |     "                        \n",
632 |     "            train_acc += (out.argmax(1) == y).cpu().numpy().mean()\n",
633 |     "        \n",
634 |     "        print(f\"Training loss at epoch {epoch} is {losses / nb_batches_train}\")\n",
635 |     "        print(f\"Training accuracy: {train_acc / nb_batches_train}\")\n",
636 |     "        print('Evaluating on validation:')\n",
637 |     "        evaluate(valid_loader)"
638 |    ]
639 |   },
640 |   {
641 |    "cell_type": "code",
642 |    "execution_count": 21,
643 |    "metadata": {},
644 |    "outputs": [],
645 |    "source": [
646 |     "def evaluate(data_loader):\n",
647 |     "    data_iterator = iter(data_loader)\n",
648 |     "    nb_batches = len(data_loader)\n",
649 |     "    model.eval()\n",
650 |     "    acc = 0 \n",
651 |     "    for batch in data_iterator:\n",
652 |     "        x = batch.text.to(device)\n",
653 |     "        y = batch.label.to(device)\n",
654 |     "                \n",
655 |     "        out = model(x)\n",
656 |     "        acc += (out.argmax(1) == y).cpu().numpy().mean()\n",
657 |     "\n",
658 |     "    print(f\"Eval accuracy: {acc / nb_batches}\")"
659 |    ]
660 |   },
661 |   {
662 |    "cell_type": "code",
663 |    "execution_count": 22,
664 |    "metadata": {
665 |     "scrolled": false
666 |    },
667 |    "outputs": [
668 |     {
669 |      "name": "stdout",
670 |      "output_type": "stream",
671 |      "text": [
672 |       "Training loss at epoch 0 is 0.6654672907746356\n",
673 |       "Training accuracy: 0.59256804524567\n",
674 |       "Evaluating on validation:\n",
675 |       "Eval accuracy: 0.6500762195121951\n",
676 |       "Training loss at epoch 1 is 0.5884601322637089\n",
677 |       "Training accuracy: 0.6856994521032167\n",
678 |       "Evaluating on validation:\n",
679 |       "Eval accuracy: 0.7198170731707317\n",
680 |       "Training loss at epoch 2 is 0.5068715074356052\n",
681 |       "Training accuracy: 0.7531261046306116\n",
682 |       "Evaluating on validation:\n",
683 |       "Eval accuracy: 0.7416539634146341\n",
684 |       "Training loss at epoch 3 is 0.42528726894786395\n",
685 |       "Training accuracy: 0.8040827147401908\n",
686 |       "Evaluating on validation:\n",
687 |       "Eval accuracy: 0.7926448170731708\n",
688 |       "Training loss at epoch 4 is 0.3583308711000111\n",
689 |       "Training accuracy: 0.8450092788971366\n",
690 |       "Evaluating on validation:\n",
691 |       "Eval accuracy: 0.8034679878048779\n",
692 |       "Training loss at epoch 5 is 0.3021336953709091\n",
693 |       "Training accuracy: 0.8747127960410039\n",
694 |       "Evaluating on validation:\n",
695 |       "Eval accuracy: 0.8129192073170731\n",
696 |       "Training loss at epoch 6 is 0.2558224143973295\n",
697 |       "Training accuracy: 0.8986998497702369\n",
698 |       "Evaluating on validation:\n",
699 |       "Eval accuracy: 0.8213033536585366\n",
700 |       "Training loss at epoch 7 is 0.2121112690023754\n",
701 |       "Training accuracy: 0.9206764757864968\n",
702 |       "Evaluating on validation:\n",
703 |       "Eval accuracy: 0.8195503048780488\n",
704 |       "Training loss at epoch 8 is 0.17223535332342851\n",
705 |       "Training accuracy: 0.9366383881230114\n",
706 |       "Evaluating on validation:\n",
707 |       "Eval accuracy: 0.8206173780487803\n",
708 |       "Training loss at epoch 9 is 0.13448018056974895\n",
709 |       "Training accuracy: 0.9550636267232236\n",
710 |       "Evaluating on validation:\n",
711 |       "Eval accuracy: 0.8282774390243901\n"
712 |      ]
713 |     }
714 |    ],
715 |    "source": [
716 |     "# L'éxécutution de cette cellule peut prendre du temps sur un CPU\n",
717 |     "train(train_loader, valid_loader)"
718 |    ]
719 |   },
720 |   {
721 |    "cell_type": "code",
722 |    "execution_count": 23,
723 |    "metadata": {},
724 |    "outputs": [
725 |     {
726 |      "name": "stdout",
727 |      "output_type": "stream",
728 |      "text": [
729 |       "Eval accuracy: 0.8077541314628836\n"
730 |      ]
731 |     }
732 |    ],
733 |    "source": [
734 |     "evaluate(test_loader)"
735 |    ]
736 |   }
737 |  ],
738 |  "metadata": {
739 |   "kernelspec": {
740 |    "display_name": "Python 3",
741 |    "language": "python",
742 |    "name": "python3"
743 |   },
744 |   "language_info": {
745 |    "codemirror_mode": {
746 |     "name": "ipython",
747 |     "version": 3
748 |    },
749 |    "file_extension": ".py",
750 |    "mimetype": "text/x-python",
751 |    "name": "python",
752 |    "nbconvert_exporter": "python",
753 |    "pygments_lexer": "ipython3",
754 |    "version": "3.6.5"
755 |   }
756 |  },
757 |  "nbformat": 4,
758 |  "nbformat_minor": 2
759 | }
760 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # EN 
 2 | This work is licensed under the Creative Commons
 3 | Attribution-NonCommercial-ShareAlike 4.0 International License.
 4 | To view a copy of this license, visit
 5 | http://creativecommons.org/licenses/by-nc-sa/4.0/ or send a letter to
 6 | Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
 7 | 
 8 | 
 9 | # FR
10 | Cette œuvre est placée sous licence Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. Pour consulter une copie de cette licence, visitez le site https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr ou envoyez un courrier à Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
11 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Deep Learning (with PyTorch) : version française des notebooks 
 2 | 
 3 | Les notebooks disponibles sur ce répertoire sont des traductions des *notebooks* en anglais de l'édition *Spring 2020* du cours **Deep Learning** du corps enseignant de la New York University. 
 4 | Les *notebooks* présentés ici se basent sur les versions anglaises datant de septembre 2021.
 5 | Comme les *notebooks* anglais évoluent avec les éditions des cours, vous pouvez trouver des versions plus récentes et mises à jour sur le [Github d'Alfredo Canziani](https://github.com/Atcold/pytorch-Deep-Learning).
 6 | 
 7 | Les cours accompagnants les *notebooks* sont disponibles à l'adresse suivante : [https://atcold.github.io/pytorch-Deep-Learning/fr/](https://atcold.github.io/pytorch-Deep-Learning/fr/)
 8 | 
 9 | Note : ces *notebooks* ont été intégrés à la version finale du [Cours d’apprentissage profond de la New York University](https://lbourdois.github.io/cours-dl-nyu/) (2023).
10 | 


--------------------------------------------------------------------------------
/res/plot_lib.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # coding: utf-8
  3 | 
  4 | # In[ ]:
  5 | 
  6 | 
  7 | from matplotlib import pyplot as plt
  8 | import numpy as np
  9 | import torch
 10 | from IPython.display import HTML, display
 11 | 
 12 | 
 13 | def set_default(figsize=(10, 10), dpi=100):
 14 |     plt.style.use(['dark_background', 'bmh'])
 15 |     plt.rc('axes', facecolor='k')
 16 |     plt.rc('figure', facecolor='k')
 17 |     plt.rc('figure', figsize=figsize, dpi=dpi)
 18 | 
 19 | 
 20 | def plot_data(X, y, d=0, auto=False, zoom=1):
 21 |     X = X.cpu()
 22 |     y = y.cpu()
 23 |     plt.scatter(X.numpy()[:, 0], X.numpy()[:, 1], c=y, s=20, cmap=plt.cm.Spectral)
 24 |     plt.axis('square')
 25 |     plt.axis(np.array((-1.1, 1.1, -1.1, 1.1)) * zoom)
 26 |     if auto is True: plt.axis('equal')
 27 |     plt.axis('off')
 28 | 
 29 |     _m, _c = 0, '.15'
 30 |     plt.axvline(0, ymin=_m, color=_c, lw=1, zorder=0)
 31 |     plt.axhline(0, xmin=_m, color=_c, lw=1, zorder=0)
 32 | 
 33 | 
 34 | def plot_model(X, y, model):
 35 |     model.cpu()
 36 |     mesh = np.arange(-1.1, 1.1, 0.01)
 37 |     xx, yy = np.meshgrid(mesh, mesh)
 38 |     with torch.no_grad():
 39 |         data = torch.from_numpy(np.vstack((xx.reshape(-1), yy.reshape(-1))).T).float()
 40 |         Z = model(data).detach()
 41 |     Z = np.argmax(Z, axis=1).reshape(xx.shape)
 42 |     plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.3)
 43 |     plot_data(X, y)
 44 | 
 45 | 
 46 | def show_scatterplot(X, colors, title=''):
 47 |     colors = colors.cpu().numpy()
 48 |     X = X.cpu().numpy()
 49 |     plt.figure()
 50 |     plt.axis('equal')
 51 |     plt.scatter(X[:, 0], X[:, 1], c=colors, s=30)
 52 |     # plt.grid(True)
 53 |     plt.title(title)
 54 |     plt.axis('off')
 55 | 
 56 | 
 57 | def plot_bases(bases, width=0.04):
 58 |     bases = bases.cpu()
 59 |     bases[2:] -= bases[:2]
 60 |     plt.arrow(*bases[0], *bases[2], width=width, color=(1,0,0), zorder=10, alpha=1., length_includes_head=True)
 61 |     plt.arrow(*bases[1], *bases[3], width=width, color=(0,1,0), zorder=10, alpha=1., length_includes_head=True)
 62 | 
 63 | 
 64 | def show_mat(mat, vect, prod, threshold=-1):
 65 |     # Subplot grid definition
 66 |     fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=False, sharey=True,
 67 |                                         gridspec_kw={'width_ratios':[5,1,1]})
 68 |     # Plot matrices
 69 |     cax1 = ax1.matshow(mat.numpy(), clim=(-1, 1))
 70 |     ax2.matshow(vect.numpy(), clim=(-1, 1))
 71 |     cax3 = ax3.matshow(prod.numpy(), clim=(threshold, 1))
 72 | 
 73 |     # Set titles
 74 |     ax1.set_title(f'A: {mat.size(0)} \u00D7 {mat.size(1)}')
 75 |     ax2.set_title(f'a^(i): {vect.numel()}')
 76 |     ax3.set_title(f'p: {prod.numel()}')
 77 | 
 78 |     # Remove xticks for vectors
 79 |     ax2.set_xticks(tuple())
 80 |     ax3.set_xticks(tuple())
 81 |     
 82 |     # Plot colourbars
 83 |     fig.colorbar(cax1, ax=ax2)
 84 |     fig.colorbar(cax3, ax=ax3)
 85 | 
 86 |     # Fix y-axis limits
 87 |     ax1.set_ylim(bottom=max(len(prod), len(vect)) - 0.5)
 88 | 
 89 | 
 90 | colors = dict(
 91 |     aqua='#8dd3c7',
 92 |     yellow='#ffffb3',
 93 |     lavender='#bebada',
 94 |     red='#fb8072',
 95 |     blue='#80b1d3',
 96 |     orange='#fdb462',
 97 |     green='#b3de69',
 98 |     pink='#fccde5',
 99 |     grey='#d9d9d9',
100 |     violet='#bc80bd',
101 |     unk1='#ccebc5',
102 |     unk2='#ffed6f',
103 | )
104 | 
105 | 
106 | def _cstr(s, color='black'):
107 |     if s == ' ':
108 |         return f'<text style=color:#000;padding-left:10px;background-color:{color}> </text>'
109 |     else:
110 |         return f'<text style=color:#000;background-color:{color}>{s} </text>'
111 | 
112 | # print html
113 | def _print_color(t):
114 |     display(HTML(''.join([_cstr(ti, color=ci) for ti, ci in t])))
115 | 
116 | # get appropriate color for value
117 | def _get_clr(value):
118 |     colors = ('#85c2e1', '#89c4e2', '#95cae5', '#99cce6', '#a1d0e8',
119 |               '#b2d9ec', '#baddee', '#c2e1f0', '#eff7fb', '#f9e8e8',
120 |               '#f9e8e8', '#f9d4d4', '#f9bdbd', '#f8a8a8', '#f68f8f',
121 |               '#f47676', '#f45f5f', '#f34343', '#f33b3b', '#f42e2e')
122 |     value = int((value * 100) / 5)
123 |     if value == len(colors): value -= 1  # fixing bugs...
124 |     return colors[value]
125 | 
126 | def _visualise_values(output_values, result_list):
127 |     text_colours = []
128 |     for i in range(len(output_values)):
129 |         text = (result_list[i], _get_clr(output_values[i]))
130 |         text_colours.append(text)
131 |     _print_color(text_colours)
132 | 
133 | def print_colourbar():
134 |     color_range = torch.linspace(-2.5, 2.5, 20)
135 |     to_print = [(f'{x:.2f}', _get_clr((x+2.5)/5)) for x in color_range]
136 |     _print_color(to_print)
137 | 
138 | 
139 | # Let's only focus on the last time step for now
140 | # First, the cell state (Long term memory)
141 | def plot_state(data, state, b, decoder):
142 |     actual_data = decoder(data[b, :, :].numpy())
143 |     seq_len = len(actual_data)
144 |     seq_len_w_pad = len(state)
145 |     for s in range(state.size(2)):
146 |         states = torch.sigmoid(state[:, b, s])
147 |         _visualise_values(states[seq_len_w_pad - seq_len:], list(actual_data))
148 | 
149 | 


--------------------------------------------------------------------------------
/res/sequential_tasks.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # coding: utf-8
  3 | 
  4 | # In[ ]:
  5 | 
  6 | 
  7 | import numpy as np
  8 | import six
  9 | 
 10 | def pad_sequences(sequences, maxlen=None, dtype='int32',
 11 |                   padding='pre', truncating='pre', value=0.):
 12 |     if not hasattr(sequences, '__len__'):
 13 |         raise ValueError('`sequences` must be iterable.')
 14 |     lengths = []
 15 |     for x in sequences:
 16 |         if not hasattr(x, '__len__'):
 17 |             raise ValueError('`sequences` must be a list of iterables. '
 18 |                              'Found non-iterable: ' + str(x))
 19 |         lengths.append(len(x))
 20 | 
 21 |     num_samples = len(sequences)
 22 |     if maxlen is None:
 23 |         maxlen = np.max(lengths)
 24 | 
 25 |     # take the sample shape from the first non empty sequence
 26 |     # checking for consistency in the main loop below.
 27 |     sample_shape = tuple()
 28 |     for s in sequences:
 29 |         if len(s) > 0:
 30 |             sample_shape = np.asarray(s).shape[1:]
 31 |             break
 32 | 
 33 |     is_dtype_str = np.issubdtype(dtype, np.str_) or np.issubdtype(dtype, np.unicode_)
 34 |     if isinstance(value, six.string_types) and dtype != object and not is_dtype_str:
 35 |         raise ValueError("`dtype` {} is not compatible with `value`'s type: {}\n"
 36 |                          "You should set `dtype=object` for variable length strings."
 37 |                          .format(dtype, type(value)))
 38 | 
 39 |     x = np.full((num_samples, maxlen) + sample_shape, value, dtype=dtype)
 40 |     for idx, s in enumerate(sequences):
 41 |         if not len(s):
 42 |             continue  # empty list/array was found
 43 |         if truncating == 'pre':
 44 |             trunc = s[-maxlen:]
 45 |         elif truncating == 'post':
 46 |             trunc = s[:maxlen]
 47 |         else:
 48 |             raise ValueError('Truncating type "%s" '
 49 |                              'not understood' % truncating)
 50 | 
 51 |         # check `trunc` has expected shape
 52 |         trunc = np.asarray(trunc, dtype=dtype)
 53 |         if trunc.shape[1:] != sample_shape:
 54 |             raise ValueError('Shape of sample %s of sequence at position %s '
 55 |                              'is different from expected shape %s' %
 56 |                              (trunc.shape[1:], idx, sample_shape))
 57 | 
 58 |         if padding == 'post':
 59 |             x[idx, :len(trunc)] = trunc
 60 |         elif padding == 'pre':
 61 |             x[idx, -len(trunc):] = trunc
 62 |         else:
 63 |             raise ValueError('Padding type "%s" not understood' % padding)
 64 |     return x
 65 | 
 66 | def to_categorical(y, num_classes=None, dtype='float32'):
 67 |     y = np.array(y, dtype='int')
 68 |     input_shape = y.shape
 69 |     if input_shape and input_shape[-1] == 1 and len(input_shape) > 1:
 70 |         input_shape = tuple(input_shape[:-1])
 71 |     y = y.ravel()
 72 |     if not num_classes:
 73 |         num_classes = np.max(y) + 1
 74 |     n = y.shape[0]
 75 |     categorical = np.zeros((n, num_classes), dtype=dtype)
 76 |     categorical[np.arange(n), y] = 1
 77 |     output_shape = input_shape + (num_classes,)
 78 |     categorical = np.reshape(categorical, output_shape)
 79 |     return categorical
 80 | 
 81 | class EchoData():
 82 | 
 83 |     def __init__(self, series_length=40000, batch_size=32,
 84 |                  echo_step=3, truncated_length=10, seed=None):
 85 | 
 86 |         self.series_length = series_length
 87 |         self.truncated_length = truncated_length
 88 |         self.n_batches = series_length//truncated_length
 89 | 
 90 |         self.echo_step = echo_step
 91 |         self.batch_size = batch_size
 92 |         if seed is not None:
 93 |             np.random.seed(seed)
 94 |         self.x_batch = None
 95 |         self.y_batch = None
 96 |         self.x_chunks = []
 97 |         self.y_chunks = []
 98 |         self.generate_new_series()
 99 |         self.prepare_batches()
100 | 
101 |     def __getitem__(self, index):
102 |         if index == 0:
103 |             self.generate_new_series()
104 |             self.prepare_batches()
105 |         return self.x_chunks[index], self.y_chunks[index]
106 | 
107 |     def __len__(self):
108 |         return self.n_batches
109 | 
110 |     def generate_new_series(self):
111 |         x = np.random.choice(
112 |             2,
113 |             size=(self.batch_size, self.series_length),
114 |             p=[0.5, 0.5])
115 |         y = np.roll(x, self.echo_step, axis=1)
116 |         y[:, 0:self.echo_step] = 0
117 |         self.x_batch = x
118 |         self.y_batch = y
119 | 
120 |     def prepare_batches(self):
121 |         x = np.expand_dims(self.x_batch, axis=-1)
122 |         y = np.expand_dims(self.y_batch, axis=-1)
123 |         self.x_chunks = np.split(x, self.n_batches, axis=1)
124 |         self.y_chunks = np.split(y, self.n_batches, axis=1)
125 | 
126 | class TemporalOrderExp6aSequence():
127 |     """
128 |     From Hochreiter&Schmidhuber(1997):
129 | 
130 |         The goal is to classify sequences. Elements and targets are represented locally
131 |         (input vectors with only one non-zero bit). The sequence starts with an E, ends
132 |         with a B (the "trigger symbol") and otherwise consists of randomly chosen symbols
133 |         from the set {a, b, c, d} except for two elements at positions t1 and t2 that are
134 |         either X or Y . The sequence length is randomly chosen between 100 and 110, t1 is
135 |         randomly chosen between 10 and 20, and t2 is randomly chosen between 50 and 60.
136 |         There are 4 sequence classes Q, R, S, U which depend on the temporal order of X and Y.
137 |         The rules are:
138 |             X, X -> Q,
139 |             X, Y -> R,
140 |             Y , X -> S,
141 |             Y , Y -> U.
142 | 
143 |     """
144 | 
145 |     def __init__(self, length_range=(100, 111), t1_range=(10, 21), t2_range=(50, 61),
146 |                  batch_size=32, seed=None):
147 | 
148 |         self.classes = ['Q', 'R', 'S', 'U']
149 |         self.n_classes = len(self.classes)
150 | 
151 |         self.relevant_symbols = ['X', 'Y']
152 |         self.distraction_symbols = ['a', 'b', 'c', 'd']
153 |         self.start_symbol = 'B'
154 |         self.end_symbol = 'E'
155 | 
156 |         self.length_range = length_range
157 |         self.t1_range = t1_range
158 |         self.t2_range = t2_range
159 |         self.batch_size = batch_size
160 | 
161 |         if seed is not None:
162 |             np.random.seed(seed)
163 | 
164 |         all_symbols = self.relevant_symbols + self.distraction_symbols +                       [self.start_symbol] + [self.end_symbol]
165 |         self.n_symbols = len(all_symbols)
166 |         self.s_to_idx = {s: n for n, s in enumerate(all_symbols)}
167 |         self.idx_to_s = {n: s for n, s in enumerate(all_symbols)}
168 | 
169 |         self.c_to_idx = {c: n for n, c in enumerate(self.classes)}
170 |         self.idx_to_c = {n: c for n, c in enumerate(self.classes)}
171 | 
172 |     def generate_pair(self):
173 |         length = np.random.randint(self.length_range[0], self.length_range[1])
174 |         t1 = np.random.randint(self.t1_range[0], self.t1_range[1])
175 |         t2 = np.random.randint(self.t2_range[0], self.t2_range[1])
176 | 
177 |         x = np.random.choice(self.distraction_symbols, length)
178 |         x[0] = self.start_symbol
179 |         x[-1] = self.end_symbol
180 | 
181 |         y = np.random.choice(self.classes)
182 |         if y == 'Q':
183 |             x[t1], x[t2] = self.relevant_symbols[0], self.relevant_symbols[0]
184 |         elif y == 'R':
185 |             x[t1], x[t2] = self.relevant_symbols[0], self.relevant_symbols[1]
186 |         elif y == 'S':
187 |             x[t1], x[t2] = self.relevant_symbols[1], self.relevant_symbols[0]
188 |         else:
189 |             x[t1], x[t2] = self.relevant_symbols[1], self.relevant_symbols[1]
190 | 
191 |         return ''.join(x), y
192 | 
193 |     # encoding/decoding single instance version
194 | 
195 |     def encode_x(self, x):
196 |         idx_x = [self.s_to_idx[s] for s in x]
197 |         return to_categorical(idx_x, num_classes=self.n_symbols)
198 | 
199 |     def encode_y(self, y):
200 |         idx_y = self.c_to_idx[y]
201 |         return to_categorical(idx_y, num_classes=self.n_classes)
202 | 
203 |     def decode_x(self, x):
204 |         x = x[np.sum(x, axis=1) > 0]    # remove padding
205 |         return ''.join([self.idx_to_s[pos] for pos in np.argmax(x, axis=1)])
206 | 
207 |     def decode_y(self, y):
208 |         return self.idx_to_c[np.argmax(y)]
209 | 
210 |     # encoding/decoding batch versions
211 | 
212 |     def encode_x_batch(self, x_batch):
213 |         return pad_sequences([self.encode_x(x) for x in x_batch],
214 |                              maxlen=self.length_range[1])
215 | 
216 |     def encode_y_batch(self, y_batch):
217 |         return np.array([self.encode_y(y) for y in y_batch])
218 | 
219 |     def decode_x_batch(self, x_batch):
220 |         return [self.decode_x(x) for x in x_batch]
221 | 
222 |     def decode_y_batch(self, y_batch):
223 |         return [self.idx_to_c[pos] for pos in np.argmax(y_batch, axis=1)]
224 | 
225 |     def __len__(self):
226 |         """ Let's assume 1000 sequences as the size of data. """
227 |         return int(1000. / self.batch_size)
228 | 
229 |     def __getitem__(self, index):
230 |         batch_x, batch_y = [], []
231 |         for _ in range(self.batch_size):
232 |             x, y = self.generate_pair()
233 |             batch_x.append(x)
234 |             batch_y.append(y)
235 |         return self.encode_x_batch(batch_x), self.encode_y_batch(batch_y)
236 | 
237 |     class DifficultyLevel:
238 |         """ On HARD, settings are identical to the original settings from the '97 paper."""
239 |         EASY, NORMAL, MODERATE, HARD, NIGHTMARE = range(5)
240 | 
241 |     @staticmethod
242 |     def get_predefined_generator(difficulty_level, batch_size=32, seed=8382):
243 |         EASY = TemporalOrderExp6aSequence.DifficultyLevel.EASY
244 |         NORMAL = TemporalOrderExp6aSequence.DifficultyLevel.NORMAL
245 |         MODERATE = TemporalOrderExp6aSequence.DifficultyLevel.MODERATE
246 |         HARD = TemporalOrderExp6aSequence.DifficultyLevel.HARD
247 | 
248 |         if difficulty_level == EASY:
249 |             length_range = (7, 9)
250 |             t1_range = (1, 3)
251 |             t2_range = (4, 6)
252 |         elif difficulty_level == NORMAL:
253 |             length_range = (30, 41)
254 |             t1_range = (2, 6)
255 |             t2_range = (20, 28)
256 |         elif difficulty_level == MODERATE:
257 |             length_range = (60, 81)
258 |             t1_range = (10, 21)
259 |             t2_range = (45, 55)
260 |         elif difficulty_level == HARD:
261 |             length_range = (100, 111)
262 |             t1_range = (10, 21)
263 |             t2_range = (50, 61)
264 |         else:
265 |             length_range = (300, 501)
266 |             t1_range = (10, 81)
267 |             t2_range = (250, 291)
268 |         return TemporalOrderExp6aSequence(length_range, t1_range, t2_range,
269 |                                           batch_size, seed)
270 |     
271 | 
272 | 


--------------------------------------------------------------------------------
/res/test:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/res/win_xp_shutdown.wav:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lbourdois/pytorch-Deep-Learning-Notebooks-in-French/25bad5ee16a7b6290e42006f0a092db5a949a554/res/win_xp_shutdown.wav


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