pytorch_introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to\n",
    "![](pytorch-logo-dark.svg)\n",
    "## Thomas Viehmann, MathInf GmbH\n",
    "## [LOD 2021 Tutorial](https://lod2021.icas.cc/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "These slides are (c) 2020 by MathInf GmbH except graphics with attribution (and the PyTorch logo above).\n",
    "\n",
    "Please use what you learn but don't just take my slides without asking. Thank you!\n",
    "\n",
    "Thanks to: Giuseppe Nicosia for the invitation and virtual hospitability. Piotr Bialecki for feedback on the draft of these slides and many interesting perspectives on PyTorch and teaching PyTorch. Luca Antiga made the autograd graphic for our book."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NVIDIA GeForce RTX 3090'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pyplot\n",
    "import numpy\n",
    "\n",
    "assert torch.cuda.is_available(), \"Some examples need the GPU\"\n",
    "torch.cuda.get_device_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Hello\n",
    "\n",
    "I'm Thomas Viehmann.\n",
    "\n",
    "- In 2018 I founded MathInf GmbH, a boutique ML research and development consultancy & PyTorch training company\n",
    "- With &gt;150 patches I am one of the most prolific independent contributors to PyTorch.\n",
    "- With Eli Stevens and Luca Antiga, I wrote [Deep Learning with PyTorch](https://pytorch.org/deep-learning-with-pytorch).\n",
    "- I do some online course (advertised on my blog [lernapparat.de](https://lernapparat.de/)),\n",
    "- Background: PhD in pen and paper Mathematics, have been an Actuary & Consultant for 10 years, Debian Developer emeritus\n",
    "\n",
    "\n",
    "<img src=\"deep-learning-thumbnail.png\" width=200px style=\"width: 200px; float: right;\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Plan\n",
    "\n",
    "A mix of basic and advanced... but always practical!\n",
    "\n",
    "- Part I: What is PyTorch? - A guided quick tour\n",
    "- Part II: How can we make programs in PyTorch fast? - Model Optimization\n",
    "- Part III: After training our model, are we done? -\n",
    "     Aspects of deployment and the model lifecycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part I: What is PyTorch?\n",
    "### A guided quick tour\n",
    "\n",
    "  We take a tour of PyTorch, nominally from 0, but we put best practices and pitfalls into the spotlight.\n",
    "  - Tensors\n",
    "  - Functions\n",
    "  - **Autograd**\n",
    "  - Models\n",
    "  - Optimizers / Data\n",
    "  - Predefined models + Ecosystem\n",
    " \n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part II: How can we make programs in PyTorch fast?\n",
    "### Model optimization\n",
    "  - Efficient modelling\n",
    "  - Slow things and fast things in GPU computing\n",
    "  - Beyond the model\n",
    "  - Measuring in PyTorch (Benchmarking)\n",
    "  - Live speedup of a model\n",
    "  - Hard optimization and the JIT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part III: After training our model, are we done?\n",
    "\n",
    "### Aspects of deployment and the model lifecycle\n",
    "\n",
    "  - The PyTorch JIT for export\n",
    "  - Keeping an eye on your model: Drift detection\n",
    "    - Why, what, how\n",
    "    - Better drift detection\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... Tensors\n",
    "\n",
    "At the heart of PyTorch is the Tensor data type. It is a multidimensional array.\n",
    "\n",
    "When we speak of the dimension of tensors, it is the number of axes (or, in PyTorch, dimensions) - so dimension is in the sense of arrays, not the mathematical one.\n",
    "\n",
    "Tensors can be 0d (i.e. scalars - single numbers), 1d (vectors), 2d (matrices), 3d..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.7071, 1.4142, 1.6180],\n",
       "        [0.8346, 2.7183, 3.1416]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = torch.tensor([[0.7071, 1.4142, 1.6180],\n",
    "                  [0.8346, 2.7183, 3.1416]])\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tensors are arrays\n",
    "Tensors have a shape (the size of each dimension):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, torch.Size([2, 3]))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.dim(), t.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing - also with assignments - works as expected. Use .item() to get numbers from tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(3.1416)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.7071, 1.4142, 1.6180],\n",
       "         [0.8346, 2.7183, 3.1416]]),\n",
       " 3.1415927410125732)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[1, 2] = 3.141592653589793\n",
    "t, t[1, 2].item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\"Advanced indexing\" with masks also works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0000, 1.4142, 1.6180],\n",
       "        [0.0000, 2.7183, 3.1416]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[t < 1] = 0\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "so does slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[1.4142, 1.6180],\n",
       "         [2.7183, 3.1416]]),\n",
       " tensor([[0.0000, 1.6180],\n",
       "         [0.0000, 3.1416]]),\n",
       " tensor([3.1416]))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[:, 1:], t[:, ::2], t[1, 2, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Tensors always hold elements (numbers) of a given scalar type, the \"data type\" or dtype.\n",
    "For PyTorch (with its GPU focus), `float32` is perhaps the most common dtype.\n",
    "Apropos GPU, they do have a device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.float32, device(type='cpu'))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.dtype, t.device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can move between devices and convert between dtypes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0000, 1.4142, 1.6180],\n",
       "        [0.0000, 2.7183, 3.1416]], device='cuda:0', dtype=torch.float64)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.to(dtype=torch.float64, device=\"cuda\")  # if we have a GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tensors - a scenic view of memory blobs\n",
    "\n",
    "Internally, Tensors are stored as a blob of memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " 0.0\n",
       " 1.414199948310852\n",
       " 1.6180000305175781\n",
       " 0.0\n",
       " 2.7183001041412354\n",
       " 3.1415927410125732\n",
       "[torch.FloatStorage of size 6]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.storage()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 1), torch.Size([2, 3]), 0, 99365120)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.stride(), t.shape, t.storage_offset(), t.data_ptr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0000, 1.4142, 1.6180],\n",
       "        [0.0000, 2.7183, 3.1416]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Indexing and Slicing (and taking Diagonals, too) do *not* copy, but create views:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = t[:, 2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 1), torch.Size([2, 1]), 2, 99365128, 99365120)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.stride(), v.shape, v.storage_offset(), v.data_ptr(), v.storage().data_ptr() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[1.6180],\n",
       "         [3.1416]]),\n",
       "  0.0\n",
       "  1.414199948310852\n",
       "  1.6180000305175781\n",
       "  0.0\n",
       "  2.7183001041412354\n",
       "  3.1415927410125732\n",
       " [torch.FloatStorage of size 6])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v, v.storage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(`data_ptr` already subsumes the storage offset...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Generalized tensors are tensors, too.\n",
    "\n",
    "- These were strided tensors\n",
    "- There are other Tensor types: Sparse, on TPU,...\n",
    "- Quantized is a bit special, but similar in spirit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.strided"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(indices=tensor([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]),\n",
       "        values=tensor([-0.5283,  0.4430,  0.5310, -1.0570,  0.2895, -1.0272,\n",
       "                        1.1280,  0.6830, -0.0562,  0.8406]),\n",
       "        size=(10,), nnz=10, layout=torch.sparse_coo),\n",
       " torch.sparse_coo)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = torch.sparse_coo_tensor(torch.arange(10)[None], torch.randn(10))\n",
    "s, s.layout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Where to get Tensors?\n",
    "\n",
    "PyTorch has ~90 factory functions:\n",
    "\n",
    "- torch.tensor, torch.sparse_coo_tensor\n",
    "\n",
    "- torch.zeros, ones, randn, ...\n",
    "\n",
    "- torch.zeros_like, ones_like, randn_like, ...\n",
    "\n",
    "Conversion to and from Numpy works without copying (there also is `torch.utils.dlpack` for a similar effect with GPU tensors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.numpy()\n",
    "t2 = torch.from_numpy(a)\n",
    "t2.data_ptr() == t.data_ptr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Careful: Numpy uses a dtype of float64 by default, PyTorch float32 (as you typically want that for GPUs)\n",
    "\n",
    "Sometimes you see FloatTensor, .data, ... in old code or copied from old code. Don't do that.\n",
    "\n",
    "There also are `torch.utils.dlpack.to_dlpack` / `from_dlpack` for interchange with GPU tensors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Saving and loading tensors\n",
    "\n",
    "Saving and loading tensors and dicts, lists of them (and other types) can be done though `torch.save` and `torch.load`. Optionally, you can specify where the tensors should be loaded to (the default is to put GPU tensors back on the GPU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0000, 1.4142, 1.6180],\n",
       "        [0.0000, 2.7183, 3.1416]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.save(t, 'my-tensor.pt')\n",
    "torch.load('my-tensor.pt', map_location=\"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Style advice**: Do use `.pt` as an extension, not `.pth` or anything else (`pth` collides with Python \"path\" files)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... operations on tensors\n",
    "\n",
    "PyTorch mostly follows numpy in naming. Most things are available as methods (`t.tanh()`) and functions (`torch.tanh(t)`). More neural-network specific things are in `torch.nn.functional`.\n",
    "\n",
    "I'm not going to list them, but generally we follow NumPy naming, the [documentation](https://pytorch.org/docs/) has all the details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000, 0.8884, 0.9243],\n",
       "         [0.0000, 0.9913, 0.9963]]),\n",
       " tensor([[0.0000, 0.8884, 0.9243],\n",
       "         [0.0000, 0.9913, 0.9963]]))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.tanh(), torch.tanh(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Inplace operations are signaled by a trailing underscore `_`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7156,  0.6660, -0.3969,  0.7263, -0.5892],\n",
       "        [-0.1670,  0.8236,  0.0158, -0.4610,  0.6732],\n",
       "        [ 0.8942, -0.0725, -0.3623,  0.9110, -0.8333],\n",
       "        [-0.0252,  0.4489, -0.6231,  0.5585,  0.8250],\n",
       "        [ 0.4238,  0.8421, -0.6662, -0.5534,  0.4282]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = torch.randn(5, 5)\n",
    "z.tanh_()\n",
    "z\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The `torch.nn.functional` namespace (sometimes mapped to `F.`) contains functions that are more neural-network related.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.8668, -1.0281,  2.1666, -1.0091,  1.6341,  0.2331,  4.0137, -4.1339,\n",
       "          0.8154, -0.2092],\n",
       "        [-0.1300, -1.7957,  3.0111, -1.2490, -1.0192,  2.6302, -1.8312, -1.9049,\n",
       "          0.3584, -1.0503]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = torch.randn(10, 5)\n",
    "i = torch.randn(2, 5)\n",
    "torch.nn.functional.linear(i, w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... autograd\n",
    "\n",
    "PyTorch has a backpropagation-based autograd mechanism. It computes the gradient of *scalar* functions (and, by proxy of Jacobian-Vector products) at the point where is was evaluated. (Image from Deep Learning with PyTorch)\n",
    "\n",
    "<img src='backprop.png' style='width: 100%' />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Autograd in action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.linspace(-3, 3, 50, requires_grad=True)\n",
    "y = torch.linspace(-3, 3, 50, requires_grad=True)\n",
    "\n",
    "f = 10 * torch.sin(y)**2 + torch.tanh(x)\n",
    "gr_x, gr_y = torch.autograd.grad(f.sum(), [x,y]) # gr always returns a list of gradients\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'gr' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-2eb37d8fb048>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mpyplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'--'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mdelta\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mxi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mpyplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mfi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mgi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# tangents at every 10th point\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'gr' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pyplot\n",
    "pyplot.plot(x.detach().numpy(), f.detach().numpy(), '--')\n",
    "delta = 0.2\n",
    "for xi, fi, gi in zip(x[::10].tolist(), f[::10].tolist(), gr[::10].tolist()):\n",
    "    pyplot.plot([xi-delta, xi+delta], [fi-delta*gi, fi+delta*gi]) # tangents at every 10th point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A mickey mouse example of optimizing a model (actually 100 times, starting from random initializations).\n",
    "\n",
    "- We have 100 mini batches à 10 items.\n",
    "- Each is, for a (normally) random $x$ the value $f(x) = \\sin(2x)$.\n",
    "- This we approximate by a 2-layer network with 10 hidden units. Our loss is the squared euclidean distance.\n",
    "- By trying various starting values, we represent the uncertainty coming from the random initializaiton of the weights (of course, we would expect that to go away with more iterations)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-27-4c8c223fb653>:24: UserWarning: Not providing a value for linspace's steps is deprecated and will throw a runtime error in a future release. This warning will appear only once per process. (Triggered internally at  /home/tv/pytorch/pytorch/aten/src/ATen/native/RangeFactories.cpp:20.)\n",
      "  x0 = torch.linspace(-2, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([100, 100])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_preds = []\n",
    "for no in range(100):   # 100 experiments\n",
    "    w1 = torch.randn(1, 10, requires_grad=True)   # initialise random paramters\n",
    "    b1 = torch.randn(10, requires_grad=True)\n",
    "    w2 = torch.randn(10, 1, requires_grad=True)\n",
    "    b2 = torch.randn(1, requires_grad=True)\n",
    "    params = [w1, b1, w2, b2]\n",
    "\n",
    "    for i in range(100):  # fitting 100 minibatches\n",
    "        x = torch.randn(10, 1)   # input value\n",
    "        target = torch.sin(2 * x)   # target value (usually from dataset)\n",
    "\n",
    "        pred = torch.tanh(x @ w1 + b1) @ w2 + b2   # our model\n",
    "\n",
    "        loss = ((pred - target) ** 2).sum()\n",
    "\n",
    "        grads = torch.autograd.grad(loss, params)\n",
    "\n",
    "        for p, g in zip(params, grads):\n",
    "            with torch.no_grad():\n",
    "                p -= 1e-2 * g\n",
    "\n",
    "    with torch.no_grad(): # no gradients here...\n",
    "        x0 = torch.linspace(-2, 2)\n",
    "        final_preds.append(torch.tanh(x0[:, None] @ w1 + b1) @ w2 + b2)\n",
    "\n",
    "final_preds = torch.cat(final_preds, dim=1)\n",
    "final_preds.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f3a2c56c0d0>]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x0 = torch.linspace(-2, 2)\n",
    "pyplot.plot(x0, final_preds, alpha=0.3)\n",
    "pyplot.plot(x0, torch.sin(2 * x0), linewidth=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f3a2c4c6250>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pyplot.plot(x0, final_preds.mean(1), label='estimate')\n",
    "pyplot.plot(x0, torch.sin(2 * x0), label='true')\n",
    "pyplot.fill_between(x0, numpy.percentile(final_preds, 2.5, axis=1), numpy.percentile(final_preds, 97.5, axis=1),\n",
    "                   color='lightgray')\n",
    "pyplot.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Leaves, intermediates, inplace and ...\n",
    "\n",
    "There roughly are these types of tensors from an autograd perspective:\n",
    "\n",
    "- \"Plain\" tensors, not requiring gradients (in particular all integral tensors).\n",
    "- Leaves are the initial tensors requiring grad, from the factory functions or by taking a non-grad-requiring tensor and saying `t.requires_grad_()`.\n",
    "- Computed tensors where an input requires gradients will, in general, require gradient.\n",
    "- \"views\", tensors sharing memory, are special."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's look at this in some detail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import graphviz\n",
    "import warnings\n",
    "def ptgraph(tensors=None):\n",
    "    g = graphviz.Digraph()\n",
    "    with warnings.catch_warnings():\n",
    "        warnings.filterwarnings('ignore')\n",
    "        names = {v:k for k,v in globals().items() if isinstance(v, torch.Tensor) and not k.startswith('_')}\n",
    "        for n, m in globals().items():\n",
    "            if isinstance(m, torch.nn.Module) and not n.startswith('_'):            \n",
    "                names.update({p: n+':'+np for np, p in m.named_parameters()})\n",
    "        new_names = names\n",
    "        while new_names:\n",
    "            new_names = {k.grad: v+'.grad' for k, v in new_names.items() if k.grad is not None}\n",
    "            names.update(new_names)\n",
    "        known_gradfns = {k.grad_fn: k for k,v in names.items() if k.grad_fn is not None}\n",
    "    seen = set()\n",
    "    def traverse_node(node):\n",
    "        node = known_gradfns.get(node, node)\n",
    "        node_id = str(hash(node))\n",
    "        nodename = node.__class__.__name__\n",
    "        if isinstance(node, torch.Tensor) and node in names:\n",
    "            nodename = names[node]\n",
    "            if node.grad_fn is None:\n",
    "                g.node(node_id, nodename)\n",
    "                return node_id\n",
    "            node = node.grad_fn\n",
    "            nodename = f'{nodename} ({node.__class__.__name__})'\n",
    "        if hasattr(node, 'variable'):\n",
    "            v = node.variable\n",
    "            vn = names.get(v)\n",
    "            node_id = str(hash(v))\n",
    "            if vn is not None:\n",
    "                nodename = f'{vn} ({nodename})'\n",
    "        g.node(node_id, nodename)\n",
    "        if node in seen:\n",
    "            return node_id\n",
    "        seen.add(node)\n",
    "        for n ,p in node.next_functions:\n",
    "            if n is not None:\n",
    "                other_id = traverse_node(n)\n",
    "                g.edge(other_id, node_id)\n",
    "        return node_id\n",
    "    if tensors is None:\n",
    "        tensors = names.keys()\n",
    "    elif not isinstance(tensors, (list, tuple)):\n",
    "        tensors = [tensors]\n",
    "    for t in tensors:\n",
    "        other_id = traverse_node(t)\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"416pt\" height=\"188pt\"\n",
       " viewBox=\"0.00 0.00 416.03 188.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 184)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-184 412.03,-184 412.03,4 -4,4\"/>\n",
       "<!-- 139887827511952 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887827511952</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"203.69\" cy=\"-18\" rx=\"94.78\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"203.69\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">c (MulBackward0)</text>\n",
       "</g>\n",
       "<!-- 8742989221807 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>8742989221807</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-90\" rx=\"80.69\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">AddBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989221807&#45;&gt;139887827511952 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>8742989221807&#45;&gt;139887827511952</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M126.12,-72.76C139.56,-63.45 156.64,-51.61 171.35,-41.41\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"173.47,-44.21 179.69,-35.63 169.48,-38.45 173.47,-44.21\"/>\n",
       "</g>\n",
       "<!-- 139887827510112 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>139887827510112</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-162\" rx=\"102.88\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">a (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827510112&#45;&gt;8742989221807 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887827510112&#45;&gt;8742989221807</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M102.69,-143.7C102.69,-135.98 102.69,-126.71 102.69,-118.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.19,-118.1 102.69,-108.1 99.19,-118.1 106.19,-118.1\"/>\n",
       "</g>\n",
       "<!-- 139887827512912 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>139887827512912</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"304.69\" cy=\"-90\" rx=\"103.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"304.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">b (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827512912&#45;&gt;139887827511952 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>139887827512912&#45;&gt;139887827511952</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M280.76,-72.41C267.3,-63.08 250.32,-51.32 235.73,-41.2\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"237.67,-38.29 227.45,-35.47 233.68,-44.04 237.67,-38.29\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c44fd00>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True)\n",
    "b = torch.randn(5, requires_grad=True)\n",
    "c = (a + 1) * b\n",
    "ptgraph(c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A common mistake is to accidentally throw away the true leaf. Note the difference between `a` and `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"436pt\" height=\"260pt\"\n",
       " viewBox=\"0.00 0.00 436.18 260.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 256)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-256 432.18,-256 432.18,4 -4,4\"/>\n",
       "<!-- 139887827512112 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887827512112</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"223.84\" cy=\"-18\" rx=\"94.78\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"223.84\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">c (MulBackward0)</text>\n",
       "</g>\n",
       "<!-- 8742989221771 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>8742989221771</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"122.84\" cy=\"-90\" rx=\"80.69\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"122.84\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">AddBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989221771&#45;&gt;139887827512112 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>8742989221771&#45;&gt;139887827512112</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M146.26,-72.76C159.71,-63.45 176.79,-51.61 191.5,-41.41\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"193.61,-44.21 199.84,-35.63 189.63,-38.45 193.61,-44.21\"/>\n",
       "</g>\n",
       "<!-- 139887827512032 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>139887827512032</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"122.84\" cy=\"-162\" rx=\"112.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"122.84\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">a (ToCopyBackward0)</text>\n",
       "</g>\n",
       "<!-- 139887827512032&#45;&gt;8742989221771 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>139887827512032&#45;&gt;8742989221771</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M122.84,-143.7C122.84,-135.98 122.84,-126.71 122.84,-118.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"126.34,-118.1 122.84,-108.1 119.34,-118.1 126.34,-118.1\"/>\n",
       "</g>\n",
       "<!-- 139887827510832 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>139887827510832</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"122.84\" cy=\"-234\" rx=\"122.68\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"122.84\" y=\"-230.3\" font-family=\"Times,serif\" font-size=\"14.00\">pre_a (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827510832&#45;&gt;139887827512032 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887827510832&#45;&gt;139887827512032</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M122.84,-215.7C122.84,-207.98 122.84,-198.71 122.84,-190.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"126.34,-190.1 122.84,-180.1 119.34,-190.1 126.34,-190.1\"/>\n",
       "</g>\n",
       "<!-- 139887827512512 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>139887827512512</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"324.84\" cy=\"-90\" rx=\"103.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"324.84\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">b (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827512512&#45;&gt;139887827512112 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>139887827512512&#45;&gt;139887827512112</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M300.9,-72.41C287.44,-63.08 270.47,-51.32 255.87,-41.2\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"257.82,-38.29 247.6,-35.47 253.83,-44.04 257.82,-38.29\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c44aeb0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pre_a = torch.randn(5, requires_grad=True)\n",
    "a =  pre_a.cuda()\n",
    "b = torch.randn(5, requires_grad=True, device='cuda')\n",
    "c = (a + 1) * b\n",
    "ptgraph(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This would be a repaired version (but, if you can, working directly on the GPU is more efficient)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"416pt\" height=\"188pt\"\n",
       " viewBox=\"0.00 0.00 416.03 188.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 184)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-184 412.03,-184 412.03,4 -4,4\"/>\n",
       "<!-- 139887827509712 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887827509712</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"203.69\" cy=\"-18\" rx=\"94.78\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"203.69\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">c (MulBackward0)</text>\n",
       "</g>\n",
       "<!-- 8742989221726 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>8742989221726</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-90\" rx=\"80.69\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">AddBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989221726&#45;&gt;139887827509712 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>8742989221726&#45;&gt;139887827509712</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M126.12,-72.76C139.56,-63.45 156.64,-51.61 171.35,-41.41\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"173.47,-44.21 179.69,-35.63 169.48,-38.45 173.47,-44.21\"/>\n",
       "</g>\n",
       "<!-- 139887827513232 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>139887827513232</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-162\" rx=\"102.88\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">a (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827513232&#45;&gt;8742989221726 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887827513232&#45;&gt;8742989221726</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M102.69,-143.7C102.69,-135.98 102.69,-126.71 102.69,-118.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.19,-118.1 102.69,-108.1 99.19,-118.1 106.19,-118.1\"/>\n",
       "</g>\n",
       "<!-- 139887827510752 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>139887827510752</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"304.69\" cy=\"-90\" rx=\"103.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"304.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">b (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827510752&#45;&gt;139887827509712 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>139887827510752&#45;&gt;139887827509712</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M280.76,-72.41C267.3,-63.08 250.32,-51.32 235.73,-41.2\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"237.67,-38.29 227.45,-35.47 233.68,-44.04 237.67,-38.29\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c44fd90>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5).cuda().requires_grad_()\n",
    "b = torch.randn(5, requires_grad=True, device='cuda')\n",
    "c = (a + 1) * b\n",
    "ptgraph(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can cut things from autograd with `detach()` (and `detach_()`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"215pt\" height=\"116pt\"\n",
       " viewBox=\"0.00 0.00 214.68 116.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 112)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-112 210.68,-112 210.68,4 -4,4\"/>\n",
       "<!-- 139887827640704 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887827640704</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"103.34\" cy=\"-18\" rx=\"94.78\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"103.34\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">c (MulBackward0)</text>\n",
       "</g>\n",
       "<!-- 139887827640944 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>139887827640944</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"103.34\" cy=\"-90\" rx=\"103.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"103.34\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">b (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827640944&#45;&gt;139887827640704 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887827640944&#45;&gt;139887827640704</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M103.34,-71.7C103.34,-63.98 103.34,-54.71 103.34,-46.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.84,-46.1 103.34,-36.1 99.84,-46.1 106.84,-46.1\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c44adc0>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True).cuda()\n",
    "b = torch.randn(5, requires_grad=True, device='cuda')\n",
    "c = (a + 1).detach() * b\n",
    "ptgraph(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Inplace with autograd can be tricky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([1., 1., 1., 1., 1.]),)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True)\n",
    "b1 = a + 1\n",
    "b2 = b1 + 1\n",
    "\n",
    "b1 += 1\n",
    "\n",
    "torch.autograd.grad(b2.sum(), a) # works\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [5]], which is output 0 of AddBackward0, is at version 1; expected version 0 instead. Hint: enable anomaly detection to find the operation that failed to compute its gradient, with torch.autograd.set_detect_anomaly(True).",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-950f59f473fd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mb1\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# this would need the original b1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mgrad\u001b[0;34m(outputs, inputs, grad_outputs, retain_graph, create_graph, only_inputs, allow_unused)\u001b[0m\n\u001b[1;32m    232\u001b[0m         \u001b[0mretain_graph\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    233\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 234\u001b[0;31m     return Variable._execution_engine.run_backward(\n\u001b[0m\u001b[1;32m    235\u001b[0m         \u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_outputs_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m         inputs, allow_unused, accumulate_grad=False)\n",
      "\u001b[0;31mRuntimeError\u001b[0m: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [5]], which is output 0 of AddBackward0, is at version 1; expected version 0 instead. Hint: enable anomaly detection to find the operation that failed to compute its gradient, with torch.autograd.set_detect_anomaly(True)."
     ]
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True)\n",
    "b1 = a + 1\n",
    "b2 = b1 ** 2\n",
    "b1 += 1\n",
    "\n",
    "torch.autograd.grad(b2.sum(), a) # this would need the original b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "source": [
    "We did not get a TraceBack in Jupyter before PyTorch 1.7 (PR #41116), but now we get too much (the crucial `b2 = b1 ** 2` is there, but off-screen)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-37-fb1eaba42148>:1: UserWarning: Anomaly Detection has been enabled. This mode will increase the runtime and should only be enabled for debugging.\n",
      "  with torch.autograd.detect_anomaly():\n",
      "/usr/local/lib/python3.9/dist-packages/torch/autograd/__init__.py:234: UserWarning: Error detected in PowBackward0. Traceback of forward call that caused the error:\n",
      "  File \"/usr/lib/python3.9/runpy.py\", line 197, in _run_module_as_main\n",
      "    return _run_code(code, main_globals, None,\n",
      "  File \"/usr/lib/python3.9/runpy.py\", line 87, in _run_code\n",
      "    exec(code, run_globals)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel_launcher.py\", line 16, in <module>\n",
      "    app.launch_new_instance()\n",
      "  File \"/usr/lib/python3/dist-packages/traitlets/config/application.py\", line 846, in launch_instance\n",
      "    app.start()\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n",
      "    self.io_loop.start()\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/platform/asyncio.py\", line 199, in start\n",
      "    self.asyncio_loop.run_forever()\n",
      "  File \"/usr/lib/python3.9/asyncio/base_events.py\", line 596, in run_forever\n",
      "    self._run_once()\n",
      "  File \"/usr/lib/python3.9/asyncio/base_events.py\", line 1890, in _run_once\n",
      "    handle._run()\n",
      "  File \"/usr/lib/python3.9/asyncio/events.py\", line 80, in _run\n",
      "    self._context.run(self._callback, *self._args)\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/ioloop.py\", line 688, in <lambda>\n",
      "    lambda f: self._run_callback(functools.partial(callback, future))\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/ioloop.py\", line 741, in _run_callback\n",
      "    ret = callback()\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/gen.py\", line 814, in inner\n",
      "    self.ctx_run(self.run)\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/gen.py\", line 775, in run\n",
      "    yielded = self.gen.send(value)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/kernelbase.py\", line 358, in process_one\n",
      "    yield gen.maybe_future(dispatch(*args))\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/gen.py\", line 234, in wrapper\n",
      "    yielded = ctx_run(next, result)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n",
      "    yield gen.maybe_future(handler(stream, idents, msg))\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/gen.py\", line 234, in wrapper\n",
      "    yielded = ctx_run(next, result)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/kernelbase.py\", line 536, in execute_request\n",
      "    self.do_execute(\n",
      "  File \"/usr/lib/python3/dist-packages/tornado/gen.py\", line 234, in wrapper\n",
      "    yielded = ctx_run(next, result)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n",
      "    res = shell.run_cell(code, store_history=store_history, silent=silent)\n",
      "  File \"/usr/lib/python3/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n",
      "    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/interactiveshell.py\", line 2894, in run_cell\n",
      "    result = self._run_cell(\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/interactiveshell.py\", line 2940, in _run_cell\n",
      "    return runner(coro)\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/async_helpers.py\", line 68, in _pseudo_sync_runner\n",
      "    coro.send(None)\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/interactiveshell.py\", line 3165, in run_cell_async\n",
      "    has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/interactiveshell.py\", line 3357, in run_ast_nodes\n",
      "    if (await self.run_code(code, result,  async_=asy)):\n",
      "  File \"/usr/lib/python3/dist-packages/IPython/core/interactiveshell.py\", line 3437, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"<ipython-input-37-fb1eaba42148>\", line 4, in <module>\n",
      "    b2 = b1 ** 2\n",
      "  File \"/usr/local/lib/python3.9/dist-packages/torch/_tensor.py\", line 30, in wrapped\n",
      "    return f(*args, **kwargs)\n",
      " (Triggered internally at  /home/tv/pytorch/pytorch/torch/csrc/autograd/python_anomaly_mode.cpp:102.)\n",
      "  return Variable._execution_engine.run_backward(\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [5]], which is output 0 of AddBackward0, is at version 1; expected version 0 instead. Hint: the backtrace further above shows the operation that failed to compute its gradient. The variable in question was changed in there or anywhere later. Good luck!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-fb1eaba42148>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mb1\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# this would need the original b1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mgrad\u001b[0;34m(outputs, inputs, grad_outputs, retain_graph, create_graph, only_inputs, allow_unused)\u001b[0m\n\u001b[1;32m    232\u001b[0m         \u001b[0mretain_graph\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    233\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 234\u001b[0;31m     return Variable._execution_engine.run_backward(\n\u001b[0m\u001b[1;32m    235\u001b[0m         \u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_outputs_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m         inputs, allow_unused, accumulate_grad=False)\n",
      "\u001b[0;31mRuntimeError\u001b[0m: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [5]], which is output 0 of AddBackward0, is at version 1; expected version 0 instead. Hint: the backtrace further above shows the operation that failed to compute its gradient. The variable in question was changed in there or anywhere later. Good luck!"
     ]
    }
   ],
   "source": [
    "with torch.autograd.detect_anomaly():\n",
    "    a = torch.randn(5, requires_grad=True)\n",
    "    b1 = a + 1\n",
    "    b2 = b1 ** 2\n",
    "    b1 += 1\n",
    "\n",
    "    torch.autograd.grad(b2.sum(), a) # this would need the original b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "There are some opportunities where inplace is actually very useful. One of my faviourite tricks is to copy things into a preallocated tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"397pt\" height=\"188pt\"\n",
       " viewBox=\"0.00 0.00 397.03 188.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 184)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-184 393.03,-184 393.03,4 -4,4\"/>\n",
       "<!-- 139887827619088 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887827619088</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"193.69\" cy=\"-18\" rx=\"76.09\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"193.69\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">c (CopySlices)</text>\n",
       "</g>\n",
       "<!-- 8742989221852 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>8742989221852</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-90\" rx=\"61.99\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">CopySlices</text>\n",
       "</g>\n",
       "<!-- 8742989221852&#45;&gt;139887827619088 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>8742989221852&#45;&gt;139887827619088</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M123.8,-72.76C135.77,-63.55 150.94,-51.88 164.09,-41.77\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.59,-44.26 172.38,-35.39 162.32,-38.71 166.59,-44.26\"/>\n",
       "</g>\n",
       "<!-- 139887827618048 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>139887827618048</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"102.69\" cy=\"-162\" rx=\"102.88\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"102.69\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">a (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827618048&#45;&gt;8742989221852 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887827618048&#45;&gt;8742989221852</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M102.69,-143.7C102.69,-135.98 102.69,-126.71 102.69,-118.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.19,-118.1 102.69,-108.1 99.19,-118.1 106.19,-118.1\"/>\n",
       "</g>\n",
       "<!-- 139887827619248 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>139887827619248</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"285.69\" cy=\"-90\" rx=\"103.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"285.69\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">b (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887827619248&#45;&gt;139887827619088 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>139887827619248&#45;&gt;139887827619088</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M263.42,-72.05C251.38,-62.89 236.35,-51.46 223.34,-41.56\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"225.2,-38.58 215.12,-35.31 220.96,-44.15 225.2,-38.58\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c44ff40>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True)\n",
    "b = torch.randn(5, requires_grad=True)\n",
    "c = torch.zeros(4, 7)  # padded torch.stack([a,b])\n",
    "c[1, 1:-1] = a\n",
    "c[2, 1:-1] = b\n",
    "c\n",
    "ptgraph(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "gr_a, gr_b = torch.autograd.grad(c.sum(), [a, b])\n",
    "assert (gr_a -1).abs().max().item() < 1e-6 and (gr_b -1).abs().max().item() < 1e-6  # float and \"==\" don't mix well"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inplace Summary\n",
    "\n",
    "\n",
    "There are two main situations where inplace operations cannot be used:\n",
    "\n",
    "- When operating on leaf tensors, the leaf tensor would be moved into the graph, which would be bad.\n",
    "- When the operation before the inplace wants to have its result to compute the backward. Whether this is the case is not easy to tell from the outside, unfortunately.\n",
    "\n",
    "As a corollary, you should avoid using inplace on the inputs of your re-usable module lest in the future use could be in one of the two situations.\n",
    "\n",
    "Later: You might also be less eager to use inplace when planning to use the JIT, as it will fuse pointwise non-inplace operations like ReLU if there are several in a row.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "For validation, inference or other things where the *end user* decides she does not want gradients, there is the `torch.no_grad` context manager.\n",
    "\n",
    "We'll use it below to evaluate models after training.\n",
    "\n",
    "- If you need to use `torch.no_grad()` somewhere where it isn’t because you’re evaluating something that’s written for training, you should ask yourself if you’re doing it wrong.\n",
    "\n",
    "- Using item and detach for things to keep around longer than the next backward is generally a good idea (e.g. when you record loss history, statistics, …), but be careful to not ruin your graph. (Targeted detach is good in nn.Module subclass code, with torch.no_grad() should be needed very rarely.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "It is not true that tensors created in `torch.no_grad` never require grad (as often views are special):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[-1.7303,  2.7394,  2.2591, -0.4502, -2.2576],\n",
       "         [-0.8640, -0.9364,  2.6627, -1.2754, -1.7908],\n",
       "         [ 2.5884,  4.4431, -3.6362,  0.8776,  0.4456],\n",
       "         [ 3.1636,  0.3777,  1.7199, -0.6238,  3.1114],\n",
       "         [-1.8418, -3.2351,  0.7988,  1.0383,  0.6543]]),\n",
       " tensor([[-0.8651,  1.3697],\n",
       "         [-0.4320, -0.4682]], requires_grad=True))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, 5, requires_grad=True)\n",
    "\n",
    "with torch.no_grad():\n",
    "    b = a * 2\n",
    "    c = a[:2, :2]\n",
    "\n",
    "b, c\n",
    "\n",
    "#with torch.inference_mode(): won't track views"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Second derivatives\n",
    "\n",
    "You cannot get Hessians, but you can get Hessian vector products or really derivatives of any scalar function of the gradient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0., 1., 2., 3., 4.], requires_grad=True),\n",
       " tensor([  0.,  12.,  48., 108., 192.]))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.arange(5., requires_grad=True)\n",
    "b = a ** 4\n",
    "gr, = torch.autograd.grad(b.sum(), [a], create_graph=True)\n",
    "hvp, = torch.autograd.grad(gr.sum(), [a])  # what is the vector in HVP?\n",
    "a, hvp # 4 * 3 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "\n",
    "## `backward` as a convenience method\n",
    "\n",
    "Above we used `torch.autograd.grad`. More commonly, you find `loss.backward()`. This is a convenience method for computing the gradient of all leaves `t` and storing the gradient in `t.grad`.\n",
    "In particular, PyTorch's built-in optimizers use these.\n",
    "\n",
    "You can ask for a gradient of an intermediate to be stored by `t.retain_grad()`.\n",
    "\n",
    "My advice: Only use backward to get gradients to then use with the optimizer. Don't use backward with \n",
    "`create_graph`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A fun trick\n",
    "\n",
    "Sometimes, we want the backward to not quite be like the forward. Round obviously has gradient 0, but wouldn't it be sometimes be convenient if..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = torch.randn(5, requires_grad=True)\n",
    "b = a.round()\n",
    "gr, = torch.autograd.grad(b.sum(), [a])\n",
    "gr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "...we can actually do that (not this construction, but the same rounding trick is the gist of \"quantization aware training\", other things like \"gumble softmax\" also work like this):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, tensor([1., 1., 1., 1., 1.]))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def differentiable_round(a, ndigits=None):\n",
    "    if ndigits is None:\n",
    "        b = a.round()\n",
    "    else:\n",
    "        scale = 10 ** ndigits\n",
    "        b = (a * scale).round() / scale\n",
    "    return a + (b - a).detach()  # PyTorch's version of \"cleverly add 0\"\n",
    "c = differentiable_round(a)\n",
    "gr2, = torch.autograd.grad(c.sum(), [a])\n",
    "(c == b).all().item(), gr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Fake quantization training the hard way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "w1 = torch.randn(1, 10, requires_grad=True)\n",
    "b1 = torch.randn(10, requires_grad=True)\n",
    "w2 = torch.randn(10, 1, requires_grad=True)\n",
    "b2 = torch.randn(1, requires_grad=True)\n",
    "params = [w1, b1, w2, b2]\n",
    "\n",
    "\n",
    "for i in range(200):\n",
    "    x = torch.randn(10, 1)\n",
    "    target = torch.sin(2 * x)\n",
    "\n",
    "    xr = differentiable_round(x)\n",
    "    w1r = differentiable_round(w1, 1)\n",
    "    b1r = differentiable_round(b1, 1)\n",
    "    w2r = differentiable_round(w2, 1)\n",
    "    b2r = differentiable_round(b2, 1)\n",
    "    pred = torch.tanh(xr @ w1r + b1r) @ w2r + b2r\n",
    "\n",
    "    loss = ((pred - target) ** 2).sum()\n",
    "\n",
    "    grads = torch.autograd.grad(loss, params)\n",
    "\n",
    "    for p, g in zip(params, grads):\n",
    "        with torch.no_grad():\n",
    "            p -= 1e-2 * g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Did it work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f3a2c3c23d0>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad(): # no gradients here...\n",
    "    w1r = differentiable_round(w1, 1)\n",
    "    b1r = differentiable_round(b1, 1)\n",
    "    w2r = differentiable_round(w2, 1)\n",
    "    b2r = differentiable_round(b2, 1)\n",
    "    x0 = torch.linspace(-2, 2)\n",
    "    final_preds = torch.tanh(x0[:, None] @ w1r + b1r) @ w2r + b2r\n",
    "    gt = torch.sin(2*x0)\n",
    "\n",
    "pyplot.plot(x0, final_preds, label='fit')\n",
    "pyplot.plot(x0, gt, label='ground truth')\n",
    "pyplot.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... a Neural Network (and general Modelling) Library\n",
    "\n",
    "`torch.nn.Module` and subclasses play the central role as Neural Network building blocks.\n",
    "Modules are for bundling neural network *state*, i.e. Parameters, other Buffers, Submodules, with the rules to compute outputs from inputs.\n",
    "- Parameters: wrap in torch.nn.Parameter + assign\n",
    "- Buffers (Tensors noch trained via SGD, e.g. statistics): register_buffer\n",
    "- Submodules: assign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Here is the equivalent of our previous model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[-1.4614,  0.7908,  0.8986, -0.0263,  0.6208, -0.4654,  0.1735,  0.5412,\n",
       "          1.4698,  0.5524]], device='cuda:0', requires_grad=True)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyModel(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.w1 = torch.nn.Parameter(torch.randn(1, 10))\n",
    "        self.b1 = torch.nn.Parameter(torch.randn(10))\n",
    "        self.w2 = torch.nn.Parameter(torch.randn(10, 1))\n",
    "        self.b2 = torch.nn.Parameter(torch.randn(1))\n",
    "  \n",
    "    def forward(self, x):\n",
    "        return torch.tanh(x @ self.w1 + self.b1) @ self.w2 + self.b2\n",
    "\n",
    "model = MyModel()\n",
    "model.to(device=\"cuda\")\n",
    "model.w1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A rich library of pre-made modules under `torch.nn`.\n",
    "- `torch.nn.Linear`, `Conv2d`, `MaxPool2D`, `Tanh`, ...\n",
    "Also loss functions:\n",
    "- `CrossEntropyLoss`, `MSELoss`, `CTCLoss`...\n",
    "\n",
    "Careful: Naming `CrossEntropyLoss` vs. `NLLLoss` etc. is particular to PyTorch. Check the documentation for PyTorch's expectation of whether input have `softmax` / `log_softmax`  / something else applied."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can make our model again with these:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyModel(\n",
       "  (l1): Linear(in_features=1, out_features=10, bias=True)\n",
       "  (l2): Linear(in_features=10, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyModel(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.l1 = torch.nn.Linear(1, 10)\n",
    "        self.l2 = torch.nn.Linear(10, 1)\n",
    "  \n",
    "    def forward(self, x):\n",
    "        x = torch.tanh(self.l1(x))\n",
    "        return self.l2(x)\n",
    "\n",
    "model = MyModel()\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "There also is a `Sequential` class for particularly simple \"chains\" of modules (with only one input/output)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.43.0 (0)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"906pt\" height=\"332pt\"\n",
       " viewBox=\"0.00 0.00 905.62 332.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 328)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-328 901.62,-328 901.62,4 -4,4\"/>\n",
       "<!-- 139887826761504 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>139887826761504</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"472.64\" cy=\"-18\" rx=\"122.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"472.64\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">res (AddmmBackward0)</text>\n",
       "</g>\n",
       "<!-- 139887826763344 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>139887826763344</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"212.64\" cy=\"-90\" rx=\"156.77\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"212.64\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">model:2.bias (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887826763344&#45;&gt;139887826761504 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>139887826763344&#45;&gt;139887826761504</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M270.99,-73.29C311.32,-62.43 365.04,-47.97 406.89,-36.7\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"407.96,-40.04 416.71,-34.06 406.15,-33.28 407.96,-40.04\"/>\n",
       "</g>\n",
       "<!-- 8742989173089 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>8742989173089</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"472.64\" cy=\"-90\" rx=\"85.29\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"472.64\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">TanhBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989173089&#45;&gt;139887826761504 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>8742989173089&#45;&gt;139887826761504</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M472.64,-71.7C472.64,-63.98 472.64,-54.71 472.64,-46.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"476.14,-46.1 472.64,-36.1 469.14,-46.1 476.14,-46.1\"/>\n",
       "</g>\n",
       "<!-- 8742989173125 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>8742989173125</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"443.64\" cy=\"-162\" rx=\"98.28\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"443.64\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">AddmmBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989173125&#45;&gt;8742989173089 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>8742989173125&#45;&gt;8742989173089</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M450.8,-143.7C454.07,-135.81 458.01,-126.3 461.64,-117.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"464.96,-118.68 465.55,-108.1 458.49,-116 464.96,-118.68\"/>\n",
       "</g>\n",
       "<!-- 139887826762384 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>139887826762384</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"156.64\" cy=\"-234\" rx=\"156.77\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"156.64\" y=\"-230.3\" font-family=\"Times,serif\" font-size=\"14.00\">model:0.bias (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887826762384&#45;&gt;8742989173125 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>139887826762384&#45;&gt;8742989173125</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M220.33,-217.46C266.89,-206.11 329.89,-190.74 377.1,-179.23\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"378.04,-182.6 386.92,-176.83 376.38,-175.8 378.04,-182.6\"/>\n",
       "</g>\n",
       "<!-- 139887826763664 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>139887826763664</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"443.64\" cy=\"-234\" rx=\"112.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"443.64\" y=\"-230.3\" font-family=\"Times,serif\" font-size=\"14.00\">inp (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887826763664&#45;&gt;8742989173125 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>139887826763664&#45;&gt;8742989173125</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M443.64,-215.7C443.64,-207.98 443.64,-198.71 443.64,-190.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"447.14,-190.1 443.64,-180.1 440.14,-190.1 447.14,-190.1\"/>\n",
       "</g>\n",
       "<!-- 8742989173173 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>8742989173173</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"642.64\" cy=\"-234\" rx=\"68.49\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"642.64\" y=\"-230.3\" font-family=\"Times,serif\" font-size=\"14.00\">TBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989173173&#45;&gt;8742989173125 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>8742989173173&#45;&gt;8742989173125</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M603.32,-219.17C572.8,-208.44 530.19,-193.45 496.66,-181.65\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"497.61,-178.28 487.02,-178.26 495.29,-184.88 497.61,-178.28\"/>\n",
       "</g>\n",
       "<!-- 139887826761984 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>139887826761984</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"642.64\" cy=\"-306\" rx=\"168.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"642.64\" y=\"-302.3\" font-family=\"Times,serif\" font-size=\"14.00\">model:0.weight (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887826761984&#45;&gt;8742989173173 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>139887826761984&#45;&gt;8742989173173</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M642.64,-287.7C642.64,-279.98 642.64,-270.71 642.64,-262.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"646.14,-262.1 642.64,-252.1 639.14,-262.1 646.14,-262.1\"/>\n",
       "</g>\n",
       "<!-- 8742989173128 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8742989173128</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"700.64\" cy=\"-90\" rx=\"68.49\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"700.64\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\">TBackward0</text>\n",
       "</g>\n",
       "<!-- 8742989173128&#45;&gt;139887826761504 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8742989173128&#45;&gt;139887826761504</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M658.02,-75.92C622.73,-65.08 572.17,-49.56 532.76,-37.46\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"533.59,-34.05 523,-34.46 531.53,-40.74 533.59,-34.05\"/>\n",
       "</g>\n",
       "<!-- 139887826761024 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>139887826761024</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"728.64\" cy=\"-162\" rx=\"168.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"728.64\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\">model:2.weight (AccumulateGrad)</text>\n",
       "</g>\n",
       "<!-- 139887826761024&#45;&gt;8742989173128 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>139887826761024&#45;&gt;8742989173128</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M721.71,-143.7C718.56,-135.81 714.76,-126.3 711.25,-117.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"714.44,-116.09 707.48,-108.1 707.94,-118.69 714.44,-116.09\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f3a2c3f4cd0>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = torch.nn.Sequential(\n",
    "            torch.nn.Linear(1, 10),\n",
    "            torch.nn.Tanh(),\n",
    "            torch.nn.Linear(10, 1))\n",
    "\n",
    "inp = torch.randn(5, 1, requires_grad=True)\n",
    "res = model(inp)\n",
    "ptgraph(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Task: Can you subclass sequential to get a model class?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Loading and Saving models\n",
    "\n",
    "While you can save and load models using `torch.save` and `torch.load`, it is generally not recommended.\n",
    "\n",
    "Instead, save the state dict and upon loading instantiate the model and load the state dict. This is much better for forward compatibility.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.save(model.state_dict(), 'saved_model.pt')\n",
    "sd = torch.load('saved_model.pt')\n",
    "model.load_state_dict(sd)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Some thoughts on functional vs. Module\n",
    "\n",
    "- If you write for re-use, the functional / Module split of PyTorch has turned out to be a good idea.\n",
    "\n",
    "- Use functional for stuff without state (unless you have a quick and dirty Sequential).\n",
    "\n",
    "- Never re-use modules (define one `torch.nn.ReLU` and use it 5 times). It's a trap!\n",
    "\n",
    "  When doing analysis or quantization (when `ReLU` becomes stateful due to quantization params), this will break.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch has ... optimizers\n",
    "\n",
    "In `torch.optim`.\n",
    "\n",
    "- Most common probably: `torch.optim.SGD`, `torch.optim.Adam`, but also `torch.optim.LBFGS` etc.\n",
    "- Schedules for the learning are also available.\n",
    "\n",
    "Pattern:\n",
    "- `loss = ...`\n",
    "- `opt.zero_grad()`\n",
    "- `loss.backward()`\n",
    "- `opt.step()`\n",
    "\n",
    "Optimizers also have a `state_dict` for saving / restoring."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's see that in action with our toy model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "model = torch.nn.Sequential(\n",
    "            torch.nn.Linear(1, 10),\n",
    "            torch.nn.Tanh(),\n",
    "            torch.nn.Linear(10, 1))\n",
    "\n",
    "opt = torch.optim.SGD(model.parameters(), lr=1e-2)\n",
    "\n",
    "for i in range(200):\n",
    "    x = torch.randn(10, 1)    # input  from dataset\n",
    "    target = torch.sin(2 * x) # target from dataset\n",
    "\n",
    "    pred = model(x)\n",
    "    loss = torch.nn.functional.mse_loss(pred, target, reduction='sum')\n",
    "    \n",
    "    opt.zero_grad()\n",
    "    loss.backward()\n",
    "    opt.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    x0 = torch.linspace(-2, 2)\n",
    "    pyplot.plot(x0, model(x0[:, None]).detach(), alpha=0.3)\n",
    "    pyplot.plot(x0, torch.sin(2 * x0), linewidth=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch has ... utilities for data handling\n",
    "\n",
    "PyTorch splits data handling in two parts:\n",
    "- Problem specific (DataSet)\n",
    "- Generic, e.g. Sampling, Batching (DataLoader)\n",
    "\n",
    "User's responsibility: Define `torch.utils.data.DataSet` subclass with\n",
    "- a `__len__` method (how many data points)\n",
    "- a `__getitem__` method to get the `i`th element, returning tuples of numbers and tensors\n",
    "\n",
    "`DataLoader` is more or less universal. In several parallel processes, get items from dataset and assemble\n",
    "them into batches (for numbers, tensors, make tensors, for other things, lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's try that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2976,  1.5696,  0.8601,  0.9776, -0.0787],\n",
      "        [ 1.1655, -0.3452, -0.2399,  2.2645,  1.3088],\n",
      "        [ 1.7672,  2.5784,  3.2223,  3.0295,  2.1929],\n",
      "        [ 9.5243,  5.8201,  5.7739,  6.7126,  7.6045],\n",
      "        [-0.7799, -0.0703,  0.5571,  0.4670, -0.7049],\n",
      "        [ 5.1953,  5.5916,  3.6525,  6.3894,  4.5062],\n",
      "        [ 3.4630,  6.6136,  6.8916,  5.1539,  5.8120],\n",
      "        [ 6.5675,  7.2459,  6.8618,  5.1527,  7.5645]]) tensor([1, 1, 2, 7, 0, 5, 6, 7])\n"
     ]
    }
   ],
   "source": [
    "import torch.utils.data\n",
    "class DS(torch.utils.data.Dataset):\n",
    "    def __init__(self, shape):\n",
    "        self.shape = shape\n",
    "    def __len__(self):\n",
    "        return 100\n",
    "    def __getitem__(self, i):\n",
    "        return (i % 10 + torch.randn(self.shape), i % 10) # observation and label\n",
    "    \n",
    "ds = DS((5,))\n",
    "dl = torch.utils.data.DataLoader(ds, batch_size=8, shuffle=True)\n",
    "\n",
    "for inp, label in dl:\n",
    "    print(inp, label)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "What happened here?\n",
    "\n",
    "The DataLoader provides an iterator and for each iteration\n",
    "\n",
    "- requested elements from the dataset,\n",
    "- took the 1d `5`-tensors and `stack`ed them to a 2d `batchsize x 5` tensor,\n",
    "- took the integers and put them into a 1d `batchsize` tensor.\n",
    "- gives the tuple of input and label to the for loop.\n",
    "\n",
    "**Good to know**: If `batchsize` does not divide `len(ds)`, the last batch will be shorter. This can be troublesome (e.g. batch norm running with a batch size of 1), so you have the `drop_last` optional command to just skip this minibatch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Practical data aquisition\n",
    "\n",
    "Datasets, Dataloaders and utility functions:\n",
    "\n",
    "TorchVision, TorchAudio, TorchIO (medical data)\n",
    "\n",
    "HuggingFace's Transformers for text (at a high level), TorchText, TorchNLP\n",
    "\n",
    "Pretrained models:\n",
    "- Vision: TorchVision, PyTorch Imaging Models (TIMM)\n",
    "- NLP: Transformers library\n",
    "\n",
    "...and on individual projects.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... much more\n",
    "\n",
    "We skipped `torch.distributions`, `distributed`, automatic mixed precision and more PyTorch has to offer. Check out the tutorials on PyTorch.org.\n",
    "\n",
    "## Forums\n",
    "\n",
    "Forums at [discuss.pytorch.org](https://discuss.pytorch.org/) probably are the best source of casual help, with a number of core developers also keeping an eye for the advanced questions. (I'm @tom there.)\n",
    "\n",
    "## Wider Ecosystem\n",
    "\n",
    "Libraries for many classes of models building on PyTorch (not complete)\n",
    "\n",
    "- Immediate \"Satellites\" like TorchVision, TorchAudio, TorchText, TorchServing\n",
    "- Extending capabilities: PyTorch Imaging Models (timm), Transformers, PyTorch-NLP, Graph NNs, Gaussian Processes, Pyro (Probabilistic)\n",
    "- Training helpers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part II: How can we make programs in PyTorch fast?\n",
    "\n",
    "### Model optimization\n",
    "\n",
    "  - Efficient modelling\n",
    "  - Slow things and fast things in GPU computing\n",
    "  - Beyond the model\n",
    "  - Measuring in PyTorch (Benchmarking)\n",
    "  - Fusion and automatic optimization\n",
    "  - Live speedup of a model\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Efficient modelling\n",
    "\n",
    "remember that modelling does have a huge lever regarding efficiency<br/>\n",
    "**if you care about efficiency make your model large but as small as possible**\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "Millions of parameters vs. timeline for the popular transformer models\n",
    "<img src=\"distilbert.png\" width=\"80%\" />\n",
    "        </td>\n",
    "        <td><img src=\"efficientnet_flops.png\" width=\"80%\" /></td>\n",
    "    </tr>\n",
    "    <tr><td>\n",
    "Source: V. Sanh (Huggingface), DistilBERT\n",
    "        </td><td>Source: M. Tan, Q. Le: EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks</td></tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Slow things and fast things in GPU computing\n",
    "\n",
    "The \"what\" typically should be the first optimization target,\n",
    "in terms of overall modelling and also computational algorithms.\n",
    "\n",
    "But when we fix the task (\"what\"), how can we optimize?\n",
    "\n",
    "Conventional wisdom: **Python is slow**\n",
    "\n",
    "- certainly, Python isn't fast (`for` loop vs C++ `for` loop)\n",
    "- in practice, more often than not, Python isn't the bottleneck\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### How PyTorch programs spend their time\n",
    "\n",
    "At a very high level, you can divide time spent into these parts:\n",
    "- Python program flow,\n",
    "- Data \"administrative overhead\" (creating `Tensor` data structures, autograd `Node`s etc.),\n",
    "- Data aquisition (I/O),\n",
    "- Computation roughly as\n",
    "  - fixed overhead (kernel launches etc.),\n",
    "  - reading / writing memory,\n",
    "  - \"real computation\",\n",
    "\n",
    "**Thomas' rule of thumb**: As long as your operands are reasonably large (say 100s of elements, not single elements), Python and Data \"administrative overhead\" probably isn't your main problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Data aquisition and I/O\n",
    "\n",
    "Using `Dataset` / `DataLoader` is simple, but keep in mind that it can greatly impact performance.\n",
    "\n",
    "How do you detect this? If, during training, your GPU is not constantly fully used (shown by `*smi` tools), you have a CPU bottleneck somewhere, and the data loading is one thing to check.\n",
    "\n",
    "- If more cores help, there is the `num_workers` argument to the dataloader.\n",
    "- Fast hardware helps: SSD vs. HDD.\n",
    "- If you can do preprocessing beforehand (no augmentation), try that. (But careful, I/O is often more expensive than processing.)\n",
    "- If you can do preprocessing on the GPU instead (augmentation in particular), do that.\n",
    "- Sometimes it helps to put tensors into _GPU pinned memory_, with the `pin_memory` argument for the DataLoader."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Computation\n",
    "\n",
    "Computation with CPU and GPU includes synchronization\n",
    "- GPU waits for the CPU (i.e. GPU sits idle when it should be used),\n",
    "- CPU waits for the GPU (to get the results) aka synchronization points\n",
    "\n",
    "  - GPU computation is and shold be ansynchronous, but\n",
    "  - Synchronizations can happen because the program needs to know something (e.g. sizes of tensors depending on the input). Often, these are unavoidable.\n",
    "  - Typical sources of spurious synchronizations are too frequent \n",
    "    `.to(device=\"cpu\")`, `.item()`, `.to_list()`, `print`.\n",
    "- in distributed settings synchronization between nodes.\n",
    "\n",
    "Typical indication: GPU utilization is bad. While your program runs, check e.g. `nvidia-smi` (or `rocm-smi`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Your program is more than your model\n",
    "\n",
    "Typical steps:\n",
    "\n",
    "- Data loading / augmentation\n",
    "- Running the models\n",
    "- Processing intermediate results\n",
    "- postprocessing, logging\n",
    "\n",
    "As quite a lot of these do not involve the GPU (before optimization...), again check GPU utilization for first hints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Measurement and benchmarking\n",
    "\n",
    "One of my informal mottos is _It's not optimization until you measure_. \n",
    "\n",
    "When you think about code being slow, it's important to figure out what is slow and why.\n",
    "To my mind, a lot of measurement can be done with very basic tools, e.g. IPython's `%timeit` magic.\n",
    "\n",
    "Important rules when timing:\n",
    "- If we want to time GPU kernels from CPU, we want to be sure to synchronize before taking the start and end times.\n",
    "- Typically, we also want to have some \"warm-up\", i.e. run the measured function\n",
    "  for a few times before timing to avoid measuring one-off overheads.\n",
    "- Always use a mononic clock (`time.perf_counter()` instead of ~~`time.time()`~~).\n",
    "- Try to cover everything of interest (s.t. wall-clock-time ≈ total measured).\n",
    "- Turn off powermanagement and make sure there is no thermal throtteling...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### First practical example from the wild\n",
    "\n",
    "Here is how one might use `%timeit` for a \"microbenchmark\".\n",
    "Here, we change the computation strategy for a given function.\n",
    "\n",
    "Let's take the uniformity loss from [Wang and Isola: Understanding Contrastive Representation Learning through Alignment and Uniformity on the Hypersphere](https://arxiv.org/abs/2005.10242) (a great paper!).\n",
    "\n",
    "The Uniformity loss is defined as a function of the pairwise distances over a largish set of vectors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-3.9382, device='cuda:0', grad_fn=<LogBackward0>)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lunif(x, t=2): # copied from the paper\n",
    "    sq_pdist = torch.pdist(x, p=2).pow(2)\n",
    "    return sq_pdist.mul(-t).exp().mean().log()\n",
    "\n",
    "x = torch.randn(1024, 128, device=\"cuda\")\n",
    "x /= x.norm(p=2, dim=1, keepdim=True).requires_grad_()\n",
    "\n",
    "lunif(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "One would think that the specialised `pdist` function is the right tool for the job.\n",
    "But is it? Let's time it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.99 ms ± 21 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "def totime(fn):\n",
    "    l = fn(x)\n",
    "    g, = torch.autograd.grad(l, x)\n",
    "    torch.cuda.synchronize()\n",
    "\n",
    "totime(lunif) # warmup\n",
    "%timeit totime(lunif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's use $|x-y|^2 = |x|^2 + |y|^2 - 2 <x, y>$ and compare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "627 µs ± 5.08 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "def lunif2(x, t=2):\n",
    "    t=2\n",
    "    xnorm = torch.norm(x, p=2, dim=1).pow(2)\n",
    "    sq_pdist = xnorm[None] + xnorm[:, None] - 2 * torch.mm(x, x.t())\n",
    "    exp = sq_pdist.mul(-t).exp().tril(diagonal=-1)\n",
    "    N = x.size(0)\n",
    "    res = exp.sum().mul(2/(N*N-N)).log()\n",
    "    return res\n",
    "\n",
    "print((lunif2(x.to(torch.double)) - lunif(x.to(torch.double))).item())\n",
    "\n",
    "totime(lunif2)\n",
    "%timeit totime(lunif2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Even though we have stark inefficiencies (like taking tril and taking a copy to do so), this is almost an order of magnitude faster!\n",
    "\n",
    "In older PyTorch l argely due to backward of `pdist` implementation, now the forward is more expensive (it is very hard to beat the well-tuned matrix multiplaction from libraries)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Profiling in PyTorch\n",
    "\n",
    "Manual instrumentation works great, but to get a thorough view, PyTorch also has a profiler.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  \n",
      "                                                   Name    Self CPU %      Self CPU   CPU total %     CPU total  CPU time avg     Self CUDA   Self CUDA %    CUDA total  CUDA time avg    # of Calls  \n",
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  \n",
      "                                              aten::mul         9.99%      10.785ms        16.98%      18.326ms      16.660us       6.548ms        26.74%       6.548ms       5.953us          1100  \n",
      "                                               aten::mm         8.37%       9.039ms        12.30%      13.276ms      44.253us       5.731ms        23.41%       5.731ms      19.103us           300  \n",
      "void at::native::vectorized_elementwise_kernel<4, at...         0.00%       0.000us         0.00%       0.000us       0.000us       4.687ms        19.14%       4.687ms       5.859us           800  \n",
      "                                              aten::sum         4.95%       5.345ms         8.35%       9.013ms      30.043us       2.908ms        11.88%       2.908ms       9.693us           300  \n",
      "void at::native::vectorized_elementwise_kernel<4, at...         0.00%       0.000us         0.00%       0.000us       0.000us       2.225ms         9.09%       2.225ms       5.562us           400  \n",
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  \n",
      "Self CPU time total: 107.957ms\n",
      "Self CUDA time total: 24.485ms\n",
      "\n"
     ]
    }
   ],
   "source": [
    "totime(lunif) # warmup\n",
    "with torch.profiler.profile() as prof:\n",
    "    for i in range(100):\n",
    "        totime(lunif2)\n",
    "\n",
    "print(prof.key_averages().table(sort_by='self_cuda_time_total', row_limit=5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sometimes just the ops is not enough, but we want to know from where they are called"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ---------------------------------------------------------------------------  \n",
      "                                                   Name    Self CPU %      Self CPU   CPU total %     CPU total  CPU time avg     Self CUDA   Self CUDA %    CUDA total  CUDA time avg    # of Calls  Source Location                                                              \n",
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ---------------------------------------------------------------------------  \n",
      "                                               aten::mm         5.48%      10.320ms         8.26%      15.546ms      51.820us       5.782ms        23.56%       5.782ms      19.273us           300  <ipython-input-98-e57378f93fa7>(4): lunif2                                   \n",
      "                                                                                                                                                                                                     <ipython-input-97-94e95eef1b8c>(2): totime                                   \n",
      "                                                                                                                                                                                                                                                                                  \n",
      "void at::native::vectorized_elementwise_kernel<4, at...         0.00%       0.000us         0.00%       0.000us       0.000us       4.695ms        19.13%       4.695ms       5.869us           800                                                                               \n",
      "                                                                                                                                                                                                                                                                                  \n",
      "                                              aten::mul         1.78%       3.356ms         3.13%       5.895ms      19.650us       2.840ms        11.57%       2.840ms       9.467us           300  <ipython-input-98-e57378f93fa7>(5): lunif2                                   \n",
      "                                                                                                                                                                                                     <ipython-input-97-94e95eef1b8c>(2): totime                                   \n",
      "                                                                                                                                                                                                                                                                                  \n",
      "                                              aten::mul         2.14%       4.026ms         3.44%       6.487ms      21.623us       2.485ms        10.12%       2.485ms       8.283us           300  <ipython-input-98-e57378f93fa7>(4): lunif2                                   \n",
      "                                                                                                                                                                                                     <ipython-input-97-94e95eef1b8c>(2): totime                                   \n",
      "                                                                                                                                                                                                                                                                                  \n",
      "void at::native::vectorized_elementwise_kernel<4, at...         0.00%       0.000us         0.00%       0.000us       0.000us       2.225ms         9.06%       2.225ms       5.562us           400                                                                               \n",
      "                                                                                                                                                                                                                                                                                  \n",
      "-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ------------  ---------------------------------------------------------------------------  \n",
      "Self CPU time total: 188.311ms\n",
      "Self CUDA time total: 24.545ms\n",
      "\n"
     ]
    }
   ],
   "source": [
    "totime(lunif2) # warmup\n",
    "with torch.profiler.profile(with_stack=True) as prof:\n",
    "    for i in range(100):\n",
    "        totime(lunif2)\n",
    "\n",
    "print(prof.key_averages(group_by_stack_n=2).table(sort_by='self_cuda_time_total', row_limit=5))"
   ]
  },
  {
   "attachments": {
    "image-3.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Profiler - Export trace to chrome for inspection\n",
    "\n",
    "the web browser has a great viewer for profiling data:\n",
    "![image-3.png](attachment:image-3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof.export_chrome_trace('example_trace.json')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Live speedup of a model\n",
    "\n",
    "We speed up a model I came across last week.\n",
    "I have rearranged the training loop but left computation unchanged.\n",
    "\n",
    "We will be using the [Grapevine leaf dataset](https://www.kaggle.com/maximvlah/grapevine-leaves) (c) 2021 by Maxim Vlah and licensed CC BY-NC-SA 4.0, used with permission here.\n",
    "\n",
    "I cannot emphasize enough that while we will get considerable speedups, assembling and releasing a useful dataset is an awesome accomplishment and the model as provided is completely \"fit for purpose\" as a demo of the dataset. Thank you Maxim!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Summary of our optimization steps\n",
    "\n",
    "Optimization steps (timings from the rehersal, computer is a Ryzen 5950 w. GTX3090):\n",
    "- Measure (`time.perf_counter`, `torch.profiler.profile`). 3 epochs in approx. 67 seconds\n",
    "- Move to SSD. 65 seconds\n",
    "- num_workers 17.5 seconds\n",
    "- move augmentation to GPU 13.5 seconds\n",
    "- pre-scale images 7.6 seconds\n",
    "- load into memory 5.56 seconds\n",
    "- take away sync points 1.5-3 seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Hard Optimization\n",
    "\n",
    "...when your GPU is fully utilized, there might still be optimization potential (similar to the uniformity loss example).\n",
    "\n",
    "Remember that computation is roughly\n",
    "  - fixed overhead (kernel launches etc.),\n",
    "  - reading / writing memory,\n",
    "  - \"real computation\".\n",
    "\n",
    "Now, reading / writing memory typically is much slower than the computation (in registers).\n",
    "But every PyTorch operation loads tensors from memory, processes them, and writes them back.\n",
    "\n",
    "If we can do several operations at once, we can save a lot of time on the memory access!\n",
    "\n",
    "Let's try speeding things up. But if we will define our own kernels, we need to have a way to define the backwards for them, so enter `autograd.Function`s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Own Autograd functions\n",
    "\n",
    "Let's consider $f : \\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ implicitly given by $F(x,f(x))=0$ for some function $F : \\mathbb{R}^n \\times \\mathbb{R}^m \\rightarrow \\mathbb{R}$.\n",
    "\n",
    "For nice (smooth, nondegenerate) functions, the [implicit function theorem](https://en.wikipedia.org/wiki/Implicit_function_theorem)\n",
    "gives us:\n",
    "\n",
    "Given $x,y$ such that $F(x,y) = 0$ there is a neighborhood $U\\ni x$ and a function $f$ such that $f(x)=y$ and $F(x,f(x))=0$. And if $F$ is nice enough, we can also compute the derivative of $f$ at $x$, namely  $\\frac{df}{dx}(x) = - (\\frac{dF}{dy}(x,y))^{-1} \\frac{dF}{dx}(x,y)$.\n",
    "\n",
    "Given $F$ in PyTorch, can we define $f$ and backpropagate through the computation?\n",
    "\n",
    "$\\Rightarrow$ Need to extend autograd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "class Implicit(torch.autograd.Function):  # derive autograd.Function\n",
    "    @staticmethod\n",
    "    def forward(ctx, x, y0, F, max_iter=100):  # Context ctx as special first parameter to static method forward\n",
    "        with torch.enable_grad():\n",
    "            y = y0.clone().detach().requires_grad_()\n",
    "            xv = x.detach()\n",
    "            opt = torch.optim.LBFGS([y], max_iter=max_iter)  # numerical search for y s.t. F(x, y) = 0\n",
    "            def reevaluate():\n",
    "                opt.zero_grad()\n",
    "                z = F(xv,y)**2\n",
    "                z.backward()\n",
    "                return z\n",
    "            opt.step(reevaluate)\n",
    "        ctx._the_function = F                 # save non-tensors\n",
    "        ctx.save_for_backward(x, y)           # safely save tensors\n",
    "        return y\n",
    "    @staticmethod\n",
    "    def backward(ctx, output_grad):          # ouput_grad = dl / dy\n",
    "        x, y = ctx.saved_tensors             # get the saved tensors\n",
    "        F = ctx._the_function                # other arguments\n",
    "        with torch.enable_grad():\n",
    "            xv = x.detach().requires_grad_()\n",
    "            y = y.detach().requires_grad_()\n",
    "            z = F(xv,y)\n",
    "            z.backward()\n",
    "        return -xv.grad/y.grad*output_grad, None, None, None  # return dl / dx and None for all other inputs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's try it on a simple case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.8660], dtype=torch.float64, grad_fn=<ImplicitBackward>) 0.8660254037844386\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(tensor([-0.5774], dtype=torch.float64),\n",
       " tensor([-0.5774], dtype=torch.float64))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def circle(x,y):\n",
    "    return x**2+y**2-1  # 0-set = unit circle\n",
    "\n",
    "x = torch.tensor([0.5], dtype=torch.double, requires_grad=True)\n",
    "y0 = torch.tensor([0.5], dtype=torch.double) # starting value\n",
    "y= Implicit.apply(x, y0, circle)    # this is how to use our new function\n",
    "print (y, (1-0.5**2)**0.5)\n",
    "gr, = torch.autograd.grad(y, x)\n",
    "gr_exp, = torch.autograd.grad((1-x**2)**0.5, [x])\n",
    "gr, gr_exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We could now backpropagate through it, too. And we can focus on the compute for optimization, as we can connect forward and backward now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Back to optimization\n",
    "\n",
    "## Example: Intersection over Union measure\n",
    "\n",
    "\n",
    "<img src=\"iou.svg\" style=\"float: right;\" />\n",
    "\n",
    "...for detection models.\n",
    "\n",
    "Many elementwise operations. Usually PyTorch executes them one by one, reading input from memory and writing back outputs.\n",
    "\n",
    "By fusing this into a single GPU kernel, we can save all that.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def ratio_iou(x1, y1, w1, h1, x2, y2, w2, h2):\n",
    "    xi = torch.max(x1, x2)                                # Intersection (yi similarly)\n",
    "    yi = torch.max(y1, y2)                                # Intersection (yi similarly)\n",
    "    wi = torch.clamp(torch.min(x1+w1, x2+w2) - xi, min=0)\n",
    "    hi = torch.clamp(torch.min(y1+h1, y2+h2) - yi, min=0)\n",
    "    area_i = wi * hi                                      # Area Intersection\n",
    "    area_u = w1 * h1 + w2 * h2 - area_i                   # Area Union\n",
    "    return area_i / torch.clamp(area_u, min=1e-5)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dropping to C++ as a speedup?\n",
    "\n",
    "You heard my rule of thumb (if your operands are 100s of elements, Python overhead is not you main problem), but here we go."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using /home/tv/.cache/torch_extensions/py39_cu113 as PyTorch extensions root...\n",
      "No modifications detected for re-loaded extension module libsuperiou, skipping build step...\n",
      "Loading extension module libsuperiou...\n"
     ]
    }
   ],
   "source": [
    "import torch.utils.cpp_extension\n",
    "\n",
    "csrc = \"\"\"\n",
    "#include <torch/script.h>\n",
    "\n",
    "using namespace torch;\n",
    "\n",
    "Tensor iou_native(const Tensor& x1, const Tensor& y1, const Tensor& w1, const Tensor& h1,\n",
    "                  const Tensor& x2, const Tensor& y2, const Tensor& w2, const Tensor& h2) {\n",
    "\n",
    "    auto xi = torch::max(x1, x2);\n",
    "    auto yi = torch::max(y1, y2);\n",
    "    auto wi = torch::clamp(torch::min(x1+w1, x2+w2) - xi, 0);\n",
    "    auto hi = torch::clamp(torch::min(y1+h1, y2+h2) - yi, 0);\n",
    "    auto area_i = wi * hi;\n",
    "    auto area_u = w1 * h1 + w2 * h2 - area_i;\n",
    "    return area_i / torch::clamp(area_u, 1e-5);\n",
    "}\n",
    "\n",
    "\n",
    "PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {\n",
    "  m.def(\"iou_native\", &iou_native, \"Intersection over union\");\n",
    "}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "super_iou = torch.utils.cpp_extension.load_inline(\"libsuperiou\", csrc, is_python_module=True, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's look at the numbers...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84.5 µs ± 159 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "82 µs ± 100 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "x1, y1, w1, h1, x2, y2, w2, h2 = torch.randn(8, 100, 1000, device='cuda').exp()\n",
    "# check that it works, this is one of the rare places I compare with \"==\"\n",
    "assert (ratio_iou(x1, y1, w1, h1, x2, y2, w2, h2)==super_iou.iou_native(x1, y1, w1, h1, x2, y2, w2, h2)).all().item()\n",
    "\n",
    "def taketime(fn):\n",
    "    _ = fn(x1, y1, w1, h1, x2, y2, w2, h2)\n",
    "    torch.cuda.synchronize()\n",
    "\n",
    "torch.cuda.synchronize()\n",
    "%timeit taketime(ratio_iou)\n",
    "%timeit taketime(super_iou.iou_native)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# but if we do our own CUDA kernels...\n",
    "csrc = \"\"\"\n",
    "#include <torch/extension.h>\n",
    "#include <ATen/Parallel.h>\n",
    "#include <ATen/TensorAccessor.h>\n",
    "\n",
    "using namespace torch;\n",
    "\n",
    "// The cuda kernel is easy enough\n",
    "template<typename scalar_t>\n",
    "__global__ void iou_kernel_gpu(PackedTensorAccessor32<scalar_t, 1> result,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> x1,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> y1,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> w1,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> h1,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> x2,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> y2,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> w2,\n",
    "                          PackedTensorAccessor32<scalar_t, 1> h2\n",
    "                          ) {\n",
    "    int i = threadIdx.x + blockDim.x * blockIdx.x;\n",
    "    if (i >= x1.size(0)) // we might have more threads than work to do in the last block\n",
    "      return;\n",
    "    // This should look very familiar. We could try reading each element only once, but let's keep it simple.\n",
    "    scalar_t xi = max(x1[i], x2[i]);\n",
    "    scalar_t yi = max(y1[i], y2[i]);\n",
    "    scalar_t wi = max(min(x1[i]+w1[i], x2[i]+w2[i]) - xi, static_cast<scalar_t>(0));\n",
    "    scalar_t hi = max(min(y1[i]+h1[i], y2[i]+h2[i]) - yi, static_cast<scalar_t>(0));\n",
    "    scalar_t area_i = wi * hi;\n",
    "    scalar_t area_u = w1[i] * h1[i] + w2[i] * h2[i] - area_i;\n",
    "    result[i] = area_i / max(area_u, static_cast<scalar_t>(0.00001f));\n",
    "}\n",
    "\n",
    "// The CPU kernel is looks similar, we could also just put it in the main function...\n",
    "template<typename scalar_t>\n",
    "void iou_kernel_cpu(int64_t size,\n",
    "                    scalar_t* result,\n",
    "                    scalar_t* x1,\n",
    "                    scalar_t* y1,\n",
    "                    scalar_t* w1,\n",
    "                    scalar_t* h1,\n",
    "                    scalar_t* x2,\n",
    "                    scalar_t* y2,\n",
    "                    scalar_t* w2,\n",
    "                    scalar_t* h2) {\n",
    "\n",
    "    // we use CPU parallelization\n",
    "    constexpr int64_t GRAIN_SIZE = 8192; // minimum grain size for parallel execution\n",
    "    at::parallel_for(0, size, GRAIN_SIZE, [&](int64_t i_begin, int64_t i_end) {\n",
    "        for (int64_t i = i_begin; i < i_end; ++i) {\n",
    "            scalar_t xi = max(x1[i], x2[i]);\n",
    "            scalar_t yi = max(y1[i], y2[i]);\n",
    "            scalar_t wi = max(min(x1[i]+w1[i], x2[i]+w2[i]) - xi, static_cast<scalar_t>(0));\n",
    "            scalar_t hi = max(min(y1[i]+h1[i], y2[i]+h2[i]) - yi, static_cast<scalar_t>(0));\n",
    "            scalar_t area_i = wi * hi;\n",
    "            scalar_t area_u = w1[i] * h1[i] + w2[i] * h2[i] - area_i;\n",
    "            result[i] = area_i / max(area_u, static_cast<scalar_t>(0.00001f));\n",
    "        }\n",
    "    });\n",
    "}\n",
    "\n",
    "\n",
    "torch::Tensor iou_forward(const Tensor& x1, const Tensor& y1, const Tensor& w1, const Tensor& h1,\n",
    "                          const Tensor& x2, const Tensor& y2, const Tensor& w2, const Tensor& h2) {\n",
    "  auto res = torch::empty_like(x1);\n",
    "  for (auto& t : {x1, y1, w1, h1, x2, y2, w2, h2}) {\n",
    "     AT_ASSERTM(t.dim()==1 && t.size(0)==x1.size(0) && t.device()==x1.device() && t.dtype()==x1.dtype(),\n",
    "                \"tensors are not of same shape and kind\");\n",
    "  }\n",
    "  if (x1.is_cuda()) {\n",
    "    dim3 block(512);\n",
    "    dim3 grid((x1.size(0)+511)/512);\n",
    "    AT_DISPATCH_FLOATING_TYPES(x1.type(), \"iou\", [&] {\n",
    "      iou_kernel_gpu<scalar_t><<<grid,block>>>(res.packed_accessor32<scalar_t, 1>(),\n",
    "                              x1.packed_accessor32<scalar_t, 1>(),\n",
    "                              y1.packed_accessor32<scalar_t, 1>(),\n",
    "                              w1.packed_accessor32<scalar_t, 1>(),\n",
    "                              h1.packed_accessor32<scalar_t, 1>(),\n",
    "                              x2.packed_accessor32<scalar_t, 1>(),\n",
    "                              y2.packed_accessor32<scalar_t, 1>(),\n",
    "                              w2.packed_accessor32<scalar_t, 1>(),\n",
    "                              h2.packed_accessor32<scalar_t, 1>());\n",
    "    });\n",
    "  } else {\n",
    "    AT_DISPATCH_FLOATING_TYPES(x1.type(), \"iou\", [&] {\n",
    "      iou_kernel_cpu<scalar_t>(x1.size(0),\n",
    "                              res.data_ptr<scalar_t>(),\n",
    "                              x1.data_ptr<scalar_t>(),\n",
    "                              y1.data_ptr<scalar_t>(),\n",
    "                              w1.data_ptr<scalar_t>(),\n",
    "                              h1.data_ptr<scalar_t>(),\n",
    "                              x2.data_ptr<scalar_t>(),\n",
    "                              y2.data_ptr<scalar_t>(),\n",
    "                              w2.data_ptr<scalar_t>(),\n",
    "                              h2.data_ptr<scalar_t>());\n",
    "    });  \n",
    "  }\n",
    "  return res;\n",
    "}\n",
    "\n",
    "PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {\n",
    "  m.def(\"iou_forward\", &iou_forward, \"Intersection over union\");\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "iou_kernel = torch.utils.cpp_extension.load_inline(\"iou_kernel\", \"\", csrc, is_python_module=True)#, verbose=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ooofff....\n",
    "\n",
    "but it works and now the speed is OK!\n",
    "\n",
    "(By the way: `PackedTensorAccessors` are the closest thing to using tensor indexing in kernels.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "check gpu tensor(1.7881e-07, device='cuda:0')\n",
      "check cpu tensor(0.)\n",
      "15.3 µs ± 138 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "84.7 µs ± 110 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "x1, y1, w1, h1, x2, y2, w2, h2 = [t.view(-1) for t in [x1, y1, w1, h1, x2, y2, w2, h2]]\n",
    "\n",
    "print (\"check gpu\", (ratio_iou(x1, y1, w1, h1, x2, y2, w2, h2)-iou_kernel.iou_forward(x1, y1, w1, h1, x2, y2, w2, h2)).abs().max())\n",
    "print (\"check cpu\", (ratio_iou(x1, y1, w1, h1, x2, y2, w2, h2).cpu()\n",
    "                     -iou_kernel.iou_forward(x1.cpu(), y1.cpu(), w1.cpu(), h1.cpu(),\n",
    "                                             x2.cpu(), y2.cpu(), w2.cpu(), h2.cpu())).abs().max())\n",
    "\n",
    "\n",
    "torch.cuda.synchronize()\n",
    "%timeit taketime(iou_kernel.iou_forward)\n",
    "%timeit taketime(ratio_iou)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now homework! Do the backward... a lot of work, you say?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Holistic Optimizations - JIT fusers\n",
    "\n",
    "So currently the fuser is a hotspot of development, look at the competition. We'll use the default `fuser1` here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function fuser in module torch.jit._fuser:\n",
      "\n",
      "fuser(name)\n",
      "    A context manager that facilitates switching between\n",
      "    backend fusers.\n",
      "    \n",
      "    Valid names:\n",
      "    * ``fuser0`` - enables only legacy fuser\n",
      "    * ``fuser1`` - enables only NNC\n",
      "    * ``fuser2`` - enables only nvFuser\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(torch.jit.fuser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intersection over Union with the JIT\n",
    "\n",
    "\n",
    "Can we have this easier?\n",
    "Many elementwise operations. Usually PyTorch executes them one by one, reading input from memory and writing back outputs.\n",
    "\n",
    "We can let PyTorch fuse these into a single GPU kernel, we can save all that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "@torch.jit.script\n",
    "def ratio_iou_scripted(x1, y1, w1, h1, x2, y2, w2, h2):\n",
    "    xi = torch.max(x1, x2)                                # Intersection (yi similarly)\n",
    "    yi = torch.max(y1, y2)                                # Intersection (yi similarly)\n",
    "    wi = torch.clamp(torch.min(x1+w1, x2+w2) - xi, min=0)\n",
    "    hi = torch.clamp(torch.min(y1+h1, y2+h2) - yi, min=0)\n",
    "    area_i = wi * hi                                      # Area Intersection\n",
    "    area_u = w1 * h1 + w2 * h2 - wi * hi                  # Area Union\n",
    "    return area_i / torch.clamp(area_u, min=1e-5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This gives us a good speedup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "85.8 µs ± 123 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "13.6 µs ± 180 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "x1, y1, w1, h1, x2, y2, w2, h2 = torch.randn(8, 100, 1000, device='cuda').exp()\n",
    "\n",
    "def take_time(fn):\n",
    "    _ = fn(x1, y1, w1, h1, x2, y2, w2, h2)\n",
    "    torch.cuda.synchronize()\n",
    "\n",
    "take_time(ratio_iou) # warmup\n",
    "%timeit take_time(ratio_iou)\n",
    "\n",
    "take_time(ratio_iou_scripted)\n",
    "take_time(ratio_iou_scripted)\n",
    "%timeit take_time(ratio_iou_scripted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can see in the graph specialised for the inputs which operations are fused:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "graph(%x1.1 : Tensor,\n",
       "      %y1.1 : Tensor,\n",
       "      %w1.1 : Tensor,\n",
       "      %h1.1 : Tensor,\n",
       "      %x2.1 : Tensor,\n",
       "      %y2.1 : Tensor,\n",
       "      %w2.1 : Tensor,\n",
       "      %h2.1 : Tensor):\n",
       "  %8 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %9 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %10 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %11 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %12 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %13 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %14 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %15 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), %16 : bool = prim::TypeCheck[types=[Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0), Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0)]](%w2.1, %h2.1, %w1.1, %h1.1, %y2.1, %y1.1, %x2.1, %x1.1)\n",
       "  %17 : Tensor = prim::If(%16)\n",
       "    block0():\n",
       "      %18 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = prim::TensorExprGroup_0(%8, %9, %10, %11, %12, %13, %14, %15)\n",
       "      -> (%18)\n",
       "    block1():\n",
       "      %19 : Function = prim::Constant[name=\"fallback_function\", fallback=1]()\n",
       "      %20 : (Tensor) = prim::CallFunction(%19, %w2.1, %h2.1, %w1.1, %h1.1, %y2.1, %y1.1, %x2.1, %x1.1)\n",
       "      %21 : Tensor = prim::TupleUnpack(%20)\n",
       "      -> (%21)\n",
       "  return (%17)\n",
       "with prim::TensorExprGroup_0 = graph(%w2.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %h2.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %w1.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %h1.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %y2.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %y1.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %x2.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0),\n",
       "      %x1.1 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0)):\n",
       "  %8 : float = prim::Constant[value=1.0000000000000001e-05]()\n",
       "  %9 : NoneType = prim::Constant()\n",
       "  %10 : int = prim::Constant[value=0]()\n",
       "  %11 : int = prim::Constant[value=1]()\n",
       "  %xi.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::max(%x1.1, %x2.1) # <ipython-input-5-5fb00890f03c>:2:9\n",
       "  %yi.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::max(%y1.1, %y2.1) # <ipython-input-5-5fb00890f03c>:3:9\n",
       "  %14 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::add(%x1.1, %w1.1, %11) # <ipython-input-5-5fb00890f03c>:4:31\n",
       "  %15 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::add(%x2.1, %w2.1, %11) # <ipython-input-5-5fb00890f03c>:4:38\n",
       "  %16 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::min(%14, %15) # <ipython-input-5-5fb00890f03c>:4:21\n",
       "  %17 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::sub(%16, %xi.2, %11) # <ipython-input-5-5fb00890f03c>:4:21\n",
       "  %wi.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::clamp(%17, %10, %9) # <ipython-input-5-5fb00890f03c>:4:9\n",
       "  %19 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::add(%y1.1, %h1.1, %11) # <ipython-input-5-5fb00890f03c>:5:31\n",
       "  %20 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::add(%y2.1, %h2.1, %11) # <ipython-input-5-5fb00890f03c>:5:38\n",
       "  %21 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::min(%19, %20) # <ipython-input-5-5fb00890f03c>:5:21\n",
       "  %22 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::sub(%21, %yi.2, %11) # <ipython-input-5-5fb00890f03c>:5:21\n",
       "  %hi.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::clamp(%22, %10, %9) # <ipython-input-5-5fb00890f03c>:5:9\n",
       "  %area_i.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::mul(%wi.2, %hi.2) # <ipython-input-5-5fb00890f03c>:6:13\n",
       "  %25 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::mul(%w1.1, %h1.1) # <ipython-input-5-5fb00890f03c>:7:13\n",
       "  %26 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::mul(%w2.1, %h2.1) # <ipython-input-5-5fb00890f03c>:7:23\n",
       "  %27 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::add(%25, %26, %11) # <ipython-input-5-5fb00890f03c>:7:13\n",
       "  %area_u.2 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::sub(%27, %area_i.2, %11) # <ipython-input-5-5fb00890f03c>:7:13\n",
       "  %29 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::clamp(%area_u.2, %8, %9) # <ipython-input-5-5fb00890f03c>:8:20\n",
       "  %30 : Float(100, 1000, strides=[1000, 1], requires_grad=0, device=cuda:0) = aten::div(%area_i.2, %29) # <ipython-input-5-5fb00890f03c>:8:11\n",
       "  return (%30)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratio_iou_scripted.graph_for(x1, y1, w1, h1, x2, y2, w2, h2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Other optimization options\n",
    "\n",
    "We can export to optimized or optimization frameworks\n",
    "  - ONNXRuntime\n",
    "  - Apache TVM\n",
    "  - TensorRT/TRTorch\n",
    "\n",
    "these share some properties:\n",
    "- work best for inference, but increasingly also for training,\n",
    "- often use the JIT representation (TorchScript) as format, with ONNXRuntime using ONNX as an additional step,\n",
    "- there is a push into integrating optimized parts back into PyTorch.\n",
    " \n",
    "Other option: manually implement kernels\n",
    " - a lot of work,\n",
    " - sometimes the most realistic option when you have very complex algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# TVM Live-Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part III: After training our model, are we done?\n",
    "\n",
    "### Aspects of deployment and the model lifecycle\n",
    "\n",
    "  - The PyTorch JIT for export\n",
    "  - Keeping an eye on your model: Drift detection\n",
    "    - Why, what, how\n",
    "    - Better drift detection\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More PyTorch JIT\n",
    "\n",
    "\n",
    "So if we have our model in PyTorch. Can we export it?\n",
    "\n",
    "This is where the PyTorch Just-In-Time compiler comes into play. It provides a graphical representation \n",
    "called _TorchScript_  (used somewhat synonymously for the language and the representation).\n",
    "\n",
    "There are two main ways to get a TorchScript graph:\n",
    "- scripting and\n",
    "- tracing.\n",
    "\n",
    "We'll look at these in some detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scripting\n",
    "\n",
    "Scripting compiles (mostly) a subset of Python.\n",
    "It takes the Python source code and transforms it. \n",
    "\"Here is what the function should do\", just like normal programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "@torch.jit.script\n",
    "def fn(x):\n",
    "    return x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<torch.jit.ScriptFunction at 0x7f65d43b2220>,\n",
       " graph(%x.1 : Tensor):\n",
       "   %2 : int = prim::Constant[value=2]() # <ipython-input-57-6dcc6c3c1c8e>:3:15\n",
       "   %3 : Tensor = aten::mul(%x.1, %2) # <ipython-input-57-6dcc6c3c1c8e>:3:11\n",
       "   return (%3))"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn, fn.graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tracing\n",
    "\n",
    "Tracing runs the code and observers the calls into PyTorch with some sample input.\n",
    "\"Watch me, now you know how to do the same.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "graph(%x : Float(5:1)):\n",
      "  %1 : Long() = prim::Constant[value={2}]() # <ipython-input-59-7d43d0af2e80>:2:0\n",
      "  %2 : Float(5:1) = aten::mul(%x, %1) # <ipython-input-59-7d43d0af2e80>:2:0\n",
      "  return (%2)\n",
      " def fn(x: Tensor) -> Tensor:\n",
      "  return torch.mul(x, CONSTANTS.c0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def fn(x):\n",
    "    return x * 2\n",
    "fn = torch.jit.trace(fn, [torch.randn(5)])\n",
    "\n",
    "print(fn.graph, fn.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "N.B.: The specialization for the Tensor shape isn't relevant here and will be erased e.g. during saving of the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### TorchScript\n",
    "\n",
    "One important difference between TorchScript and Python is that in TorchScript everything is typed. Important\n",
    "types are\n",
    "- `bool`, `int`, `long`, `double` for numbers (int = 32 bit integer, long = 64 bit integer)\n",
    "- `Tensor` for tensors (of arbitrary shape, dtype, ...)\n",
    "- `List[T]` a list with elements fo type T (one of the above)\n",
    "- Tuples are of fixed size with arbitrary but fixed element type, so e.g. `Tuple(Tensor, int)`.\n",
    "- `Optional[T]` for things that can be `None`\n",
    "\n",
    "`None` always is of type `Optional[T]` for some specific `T` (except in the rarest circumstances).\n",
    "\n",
    "PyTorch will mostly infer the intermediate and return types, but you need to annotate any non-Tensor inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tracing vs. Scripting\n",
    "\n",
    "Scripting will process all code but may not understand all. This means it captures all constructs (like control flow) it understands, but it will fail if it doesn't understand something.\n",
    "\n",
    "Tracing doesn't see anything not calling into PyTorch and will happily ignore that (e.g. control flow). This is also the reason why it will loudly complain if you have non-tensor inputs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def fn(x):\n",
    "    for i in range(x.dim()):\n",
    "        x = x * x\n",
    "    return x\n",
    "\n",
    "script_fn = torch.jit.script(fn)\n",
    "trace_fn = torch.jit.trace(fn, [torch.randn(5, 5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def fn(x: Tensor) -> Tensor:\n",
      "  x0 = x\n",
      "  for i in range(torch.dim(x)):\n",
      "    x0 = torch.mul(x0, x0)\n",
      "  return x0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(script_fn.code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def fn(x: Tensor) -> Tensor:\n",
      "  x0 = torch.mul(x, x)\n",
      "  return torch.mul(x0, x0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(trace_fn.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracing and Scripting Modules\n",
    "\n",
    "But our models often are not functions. What now?\n",
    "\n",
    "With tracing, we can work just like with functions. We get a `ScriptModule` subclass that behaves much like a\n",
    "`Module` with parameters, state dict etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.jit._trace.TopLevelTracedModule,\n",
       " Sequential(\n",
       "   original_name=Sequential\n",
       "   (0): Linear(original_name=Linear)\n",
       "   (1): Tanh(original_name=Tanh)\n",
       "   (2): Linear(original_name=Linear)\n",
       " ))"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traced_model = torch.jit.trace(model, [torch.randn(8, 1)])\n",
    "type(traced_model), traced_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Saving is a bit different, here we include the model on purpose:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.8112],\n",
       "        [ 0.3232],\n",
       "        [ 0.7830],\n",
       "        [-0.8254],\n",
       "        [ 0.7857],\n",
       "        [-0.3138],\n",
       "        [-0.7612],\n",
       "        [ 0.5701]], grad_fn=<DifferentiableGraphBackward>)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traced_model.save('./traced_model.pt')\n",
    "loaded_model = torch.jit.load('./traced_model.pt')\n",
    "\n",
    "loaded_model(torch.randn(8,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Scripting Modules\n",
    "\n",
    "Scripting modules is ... a bit tricky. We don't script the class in its entirety but instead take an instance (in particular past `__init__`) and process its data members and methods (the latters work like script functions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def forward(self,\n",
      "    input: Tensor) -> Tensor:\n",
      "  _0 = getattr(self, \"0\")\n",
      "  _1 = getattr(self, \"1\")\n",
      "  _2 = getattr(self, \"2\")\n",
      "  input0 = (_0).forward(input, )\n",
      "  input1 = (_1).forward(input0, )\n",
      "  return (_2).forward(input1, )\n",
      "\n"
     ]
    }
   ],
   "source": [
    "scripted_model = torch.jit.script(model)\n",
    "print(scripted_model.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can also look at the graph including submodules, but it gets unwieldy rather fast:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "graph(%self : __torch__.torch.nn.modules.container.___torch_mangle_13.Sequential,\n",
       "      %input.1 : Tensor):\n",
       "  %2 : __torch__.torch.nn.modules.linear.___torch_mangle_10.Linear = prim::GetAttr[name=\"0\"](%self)\n",
       "  %3 : __torch__.torch.nn.modules.activation.___torch_mangle_11.Tanh = prim::GetAttr[name=\"1\"](%self)\n",
       "  %4 : __torch__.torch.nn.modules.linear.___torch_mangle_12.Linear = prim::GetAttr[name=\"2\"](%self)\n",
       "  %8 : int = prim::Constant[value=1]()\n",
       "  %9 : int = prim::Constant[value=2]() # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:22\n",
       "  %10 : Tensor = prim::GetAttr[name=\"weight\"](%2)\n",
       "  %11 : Tensor = prim::GetAttr[name=\"bias\"](%2)\n",
       "  %12 : int = aten::dim(%input.1) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:7\n",
       "  %13 : bool = aten::eq(%12, %9) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:7\n",
       "  %input.3 : Tensor = prim::If(%13) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:4\n",
       "    block0():\n",
       "      %15 : Tensor = aten::t(%10) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1674:39\n",
       "      %ret.2 : Tensor = aten::addmm(%11, %input.1, %15, %8, %8) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1674:14\n",
       "      -> (%ret.2)\n",
       "    block1():\n",
       "      %17 : Tensor = aten::t(%10) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1676:30\n",
       "      %output.2 : Tensor = aten::matmul(%input.1, %17) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1676:17\n",
       "      %output.4 : Tensor = aten::add_(%output.2, %11, %8) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1678:12\n",
       "      -> (%output.4)\n",
       "  %input.5 : Tensor = aten::tanh(%input.3) # /usr/local/lib/python3.8/dist-packages/torch/nn/modules/activation.py:350:15\n",
       "  %21 : int = prim::Constant[value=1]()\n",
       "  %22 : int = prim::Constant[value=2]() # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:22\n",
       "  %23 : Tensor = prim::GetAttr[name=\"weight\"](%4)\n",
       "  %24 : Tensor = prim::GetAttr[name=\"bias\"](%4)\n",
       "  %25 : int = aten::dim(%input.5) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:7\n",
       "  %26 : bool = aten::eq(%25, %22) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:7\n",
       "  %input.7 : Tensor = prim::If(%26) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1672:4\n",
       "    block0():\n",
       "      %28 : Tensor = aten::t(%23) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1674:39\n",
       "      %ret.1 : Tensor = aten::addmm(%24, %input.5, %28, %21, %21) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1674:14\n",
       "      -> (%ret.1)\n",
       "    block1():\n",
       "      %30 : Tensor = aten::t(%23) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1676:30\n",
       "      %output.1 : Tensor = aten::matmul(%input.5, %30) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1676:17\n",
       "      %output.3 : Tensor = aten::add_(%output.1, %24, %21) # /usr/local/lib/python3.8/dist-packages/torch/nn/functional.py:1678:12\n",
       "      -> (%output.3)\n",
       "  return (%input.7)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scripted_model.forward.inlined_graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What can you do with scripted modules?\n",
    "\n",
    "- Run them as is, bypassing Python.\n",
    "  - not as much speedup as often is expected (maybe 5%-10% for some models I tested),\n",
    "  - but - sometimes crucially - it avoids the dreaded Python Global Interpreter Lock (GIL), so it is useful e.g.\n",
    "    for multithreaded things like serving PyTorch models.\n",
    "- Export and run in C++ / Mobile / ..., export to other frameworks like [TVM](https://tvm.ai/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTorch is ... Pythonic, but not Python only\n",
    "\n",
    "\n",
    "<img src=\"Ch15_F4_PyTorch_calling_pytorch.svg\" style=\"float: right;\"/>\n",
    "\n",
    "When we looked at _PyTorch is functions_, we actually conflated PyTorch the interface and PyTorch the backend.\n",
    "\n",
    "The JIT was another way of accessing the backend.\n",
    "\n",
    "Looking closer, we have `libtorch` (the C++-implemented autograd-enabled backend) calling down into `ATen` for tensor operations and there the dispatching to ATen's own kernels or libraries.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Beyond Python\n",
    "\n",
    "\n",
    "<table>\n",
    "    <tr><td>\n",
    "We can also run our JITed models from C++ in a few lines of code or on mobile.\n",
    "\n",
    "The picture shows a CycleGAN running on PyTorch Mobile (from Chapter 15 of our book, just like the PyTorch sketch above).\n",
    "\n",
    "We also cover C++ there, but not now.\n",
    "        </td>\n",
    "        <td><img src=\"Ch15_F5_PyTorch_zebra_app.png\" width=\"40%\"/></td></tr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img alt=\"Thank you\" src=\"thank_you.svg\" width=80% /></center>\n",
    "\n",
    "<center><img alt=\"Your questions and comments\" src=\"your_questions_and_comments.svg\" width=80%/></center>\n",
    "\n",
    "[Graves style Handwriting in PyTorch](https://github.com/t-vi/pytorch-tvmisc/blob/master/misc/graves_handwriting_generation.ipynb)\n",
    "\n",
    "# Contact: Thomas Viehmann, <https://lernapparat.de/>,  <tv@mathinf.eu>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "rise": {
   "header": "<img id='mathinf-logo-header' src='mathinf_logo.png' />",
   "theme": "white",
   "transition": "off"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}