01_intro/seminar_pytorch_vs_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"static/pytorch-vs-numpy-logo.png\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch vs. NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`NumPy` is the fundamental package for **scientific computing** in Python. It provides a **multidimensional array** object (and other) for fast operations on arrays, including mathematical, logical, shape manipulation, etc. We hope you're familiar with NumPy. If you feel some gaps in knowledge check out [this tutorial](https://docs.scipy.org/doc/numpy-1.15.0/user/quickstart.html).\n",
    "\n",
    "\n",
    "Today we'll explore **PyTorch** library. PyTorch is also a scientific computing package (like NumPy), but it has two awesome features:\n",
    "- Automatic differentiation (very useful for deep learning)\n",
    "- GPU support for calculations\n",
    "\n",
    "\n",
    "Actually PyTorch has great features. Later on we'll use them to build neural networks, but for now let's consider it just like a scientific computing package. Let's start with installation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch is pretty easy to install:\n",
    "1. Go to [pytorch.org](https://pytorch.org) and scroll down to **\"Quick start locally\"** section.\n",
    "2. Choose options suitable for you. E.g.:\n",
    "    - PyTorch Build: **Stable (1.0)**\n",
    "    - Your OS: **Mac**\n",
    "    - Package: **Pip**\n",
    "    - Language: **Python 3.7** (check *your* python version via terminal `$ python3 --version`)\n",
    "    - CUDA: **None** (if you don't have GPU)\n",
    "3. Just run given command from termial. E.g.: `$ pip3 install torch torchvision`.\n",
    "4. PyTorch is quite big (especially CUDA versions), so you can have a cup of coffee while it's downloading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lifehack**: you can run termial commands directly from notebooks providing `!` in the beginning of the command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip3 install torch torchvision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verify proper installation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0.1\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy installation is much easier:\n",
    "1. Run `$ pip3 install numpy`\n",
    "2. That's it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in /Users/maxim/code/git/fintech/learning-deep-learning/dl_pytorch/lib/python3.6/site-packages (1.16.1)\r\n"
     ]
    }
   ],
   "source": [
    "!pip3 install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verify proper installation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.16.1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning PyTorch like robots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We all love **machine learning**, so let's try to study PyTorch in a *supervised learning* manner. Here're some pairs of examples for NumPy and corresponding PyTorch:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_numpy = \n",
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]\n",
      " [7. 8. 9.]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_numpy = np.array([\n",
    "    [1.0, 2.0, 3.0],\n",
    "    [4.0, 5.0, 6.0],\n",
    "    [7.0, 8.0, 9.0]\n",
    "])\n",
    "\n",
    "print(\"x_numpy = \\n{}\\n\".format(x_numpy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_torch = \n",
      "tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.],\n",
      "        [7., 8., 9.]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_torch = torch.tensor([\n",
    "    [1.0, 2.0, 3.0],\n",
    "    [4.0, 5.0, 6.0],\n",
    "    [7.0, 8.0, 9.0]\n",
    "])\n",
    "\n",
    "print(\"x_torch = \\n{}\\n\".format(x_torch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_numpy[0, 0] = \n",
      "1.0\n",
      "\n",
      "x_numpy[:, 0] = \n",
      "[1. 4. 7.]\n",
      "\n",
      "x_numpy[:2, 1:3] = \n",
      "[[2. 3.]\n",
      " [5. 6.]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"x_numpy[0, 0] = \\n{}\\n\".format(x_numpy[0, 0]))\n",
    "print(\"x_numpy[:, 0] = \\n{}\\n\".format(x_numpy[:, 0]))\n",
    "print(\"x_numpy[:2, 1:3] = \\n{}\\n\".format(x_numpy[:2, 1:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_torch[0, 0] = \n",
      "1.0\n",
      "\n",
      "x_torch[:, 0] = \n",
      "tensor([1., 4., 7.])\n",
      "\n",
      "x_torch[:2, 1:3] = \n",
      "tensor([[2., 3.],\n",
      "        [5., 6.]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"x_torch[0, 0] = \\n{}\\n\".format(x_torch[0, 0]))\n",
    "print(\"x_torch[:, 0] = \\n{}\\n\".format(x_torch[:, 0]))\n",
    "print(\"x_torch[:2, 1:3] = \\n{}\\n\".format(x_torch[:2, 1:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_numpy ** 2 = \n",
      "[[ 1.  4.  9.]\n",
      " [16. 25. 36.]\n",
      " [49. 64. 81.]]\n",
      "\n",
      "np.cos(x_numpy) = \n",
      "[[ 0.54030231 -0.41614684 -0.9899925 ]\n",
      " [-0.65364362  0.28366219  0.96017029]\n",
      " [ 0.75390225 -0.14550003 -0.91113026]]\n",
      "\n",
      "x_numpy.mean(axis=0) = \n",
      "[4. 5. 6.]\n",
      "\n",
      "x_numpy.T = \n",
      "[[1. 4. 7.]\n",
      " [2. 5. 8.]\n",
      " [3. 6. 9.]]\n",
      "\n",
      "x_numpy.reshape(1, -1) = \n",
      "[[1. 2. 3. 4. 5. 6. 7. 8. 9.]]\n",
      "\n",
      "x_numpy.flatten() = \n",
      "[1. 2. 3. 4. 5. 6. 7. 8. 9.]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"x_numpy ** 2 = \\n{}\\n\".format(x_numpy ** 2))\n",
    "print(\"np.cos(x_numpy) = \\n{}\\n\".format(np.cos(x_numpy)))\n",
    "print(\"x_numpy.mean(axis=0) = \\n{}\\n\".format(x_numpy.mean(axis=0)))\n",
    "print(\"x_numpy.T = \\n{}\\n\".format(x_numpy.T))\n",
    "print(\"x_numpy.reshape(1, -1) = \\n{}\\n\".format(x_numpy.reshape(1, -1)))\n",
    "print(\"x_numpy.flatten() = \\n{}\\n\".format(x_numpy.flatten()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_torch ** 2 = \n",
      "tensor([[ 1.,  4.,  9.],\n",
      "        [16., 25., 36.],\n",
      "        [49., 64., 81.]])\n",
      "\n",
      "np.cos(x_torch) = \n",
      "tensor([[ 0.5403, -0.4161, -0.9900],\n",
      "        [-0.6536,  0.2837,  0.9602],\n",
      "        [ 0.7539, -0.1455, -0.9111]])\n",
      "\n",
      "x_torch.mean(dim=0) = \n",
      "tensor([4., 5., 6.])\n",
      "\n",
      "x_torch.t() = \n",
      "tensor([[1., 4., 7.],\n",
      "        [2., 5., 8.],\n",
      "        [3., 6., 9.]])\n",
      "\n",
      "x_torch.reshape(1, -1) = \n",
      "tensor([[1., 2., 3., 4., 5., 6., 7., 8., 9.]])\n",
      "\n",
      "x_torch.flatten() = \n",
      "tensor([1., 2., 3., 4., 5., 6., 7., 8., 9.])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"x_torch ** 2 = \\n{}\\n\".format(x_torch ** 2))\n",
    "print(\"np.cos(x_torch) = \\n{}\\n\".format(torch.cos(x_torch)))\n",
    "print(\"x_torch.mean(dim=0) = \\n{}\\n\".format(x_torch.mean(dim=0)))\n",
    "print(\"x_torch.t() = \\n{}\\n\".format(x_torch.t()))\n",
    "print(\"x_torch.reshape(1, -1) = \\n{}\\n\".format(x_torch.reshape(1, -1)))\n",
    "print(\"x_torch.flatten() = \\n{}\\n\".format(x_torch.flatten()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.arange(3) = \n",
      "[0 1 2]\n",
      "\n",
      "np.linspace(0.0, 1.0, num=9).reshape(3, 3) = \n",
      "[[0.    0.125 0.25 ]\n",
      " [0.375 0.5   0.625]\n",
      " [0.75  0.875 1.   ]]\n",
      "\n",
      "np.ones() = \n",
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n",
      "\n",
      "np.random.rand(3, 2) = \n",
      "[[0.11869941 0.41829124]\n",
      " [0.62781172 0.51216541]\n",
      " [0.17296895 0.70589378]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"np.arange(3) = \\n{}\\n\".format(np.arange(3)))\n",
    "print(\"np.linspace(0.0, 1.0, num=9).reshape(3, 3) = \\n{}\\n\".format(np.linspace(0.0, 1.0, num=9).reshape(3, 3)))\n",
    "print(\"np.ones() = \\n{}\\n\".format(np.ones((2, 5))))\n",
    "print(\"np.random.rand(3, 2) = \\n{}\\n\".format(np.random.rand(3, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.arange(3) = \n",
      "tensor([0, 1, 2])\n",
      "\n",
      "torch.linspace(0.0, 1.0, steps=9).reshape(3, 3) = \n",
      "tensor([[0.0000, 0.1250, 0.2500],\n",
      "        [0.3750, 0.5000, 0.6250],\n",
      "        [0.7500, 0.8750, 1.0000]])\n",
      "\n",
      "torch.ones() = \n",
      "tensor([[1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.]])\n",
      "\n",
      "torch.random.rand(3, 2) = \n",
      "tensor([[0.8423, 0.4411],\n",
      "        [0.6192, 0.1923],\n",
      "        [0.8298, 0.6167]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"torch.arange(3) = \\n{}\\n\".format(torch.arange(3)))\n",
    "print(\"torch.linspace(0.0, 1.0, steps=9).reshape(3, 3) = \\n{}\\n\".format(torch.linspace(0.0, 1.0, steps=9).reshape(3, 3)))\n",
    "print(\"torch.ones() = \\n{}\\n\".format(torch.ones((2, 5))))\n",
    "print(\"torch.random.rand(3, 2) = \\n{}\\n\".format(torch.rand(3, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 arrays/tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = \n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n",
      "y = \n",
      "[[0.    0.125 0.25 ]\n",
      " [0.375 0.5   0.625]\n",
      " [0.75  0.875 1.   ]]\n",
      "\n",
      "x * y = \n",
      "[[0.    0.125 0.5  ]\n",
      " [1.125 2.    3.125]\n",
      " [4.5   6.125 8.   ]]\n",
      "\n",
      "x.dot(y) = \n",
      "[[ 1.875  2.25   2.625]\n",
      " [ 5.25   6.75   8.25 ]\n",
      " [ 8.625 11.25  13.875]]\n",
      "\n",
      "np.concatenate([x, y], axis=1) = \n",
      "[[0.    1.    2.    0.    0.125 0.25 ]\n",
      " [3.    4.    5.    0.375 0.5   0.625]\n",
      " [6.    7.    8.    0.75  0.875 1.   ]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_numpy = np.arange(0, 9).reshape(3, 3)\n",
    "y_numpy = np.linspace(0.0, 1.0, num=9).reshape(3, 3)\n",
    "\n",
    "print(\"x = \\n{}\\n\".format(x_numpy))\n",
    "print(\"y = \\n{}\\n\".format(y_numpy))\n",
    "print(\"x * y = \\n{}\\n\".format(x_numpy * y_numpy))\n",
    "print(\"x.dot(y) = \\n{}\\n\".format(x_numpy.dot(y_numpy)))\n",
    "print(\"np.concatenate([x, y], axis=1) = \\n{}\\n\".format(np.concatenate([x_numpy, y_numpy], axis=1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = \n",
      "tensor([[0., 1., 2.],\n",
      "        [3., 4., 5.],\n",
      "        [6., 7., 8.]])\n",
      "\n",
      "y = \n",
      "tensor([[0.0000, 0.1250, 0.2500],\n",
      "        [0.3750, 0.5000, 0.6250],\n",
      "        [0.7500, 0.8750, 1.0000]])\n",
      "\n",
      "x * y = \n",
      "tensor([[0.0000, 0.1250, 0.5000],\n",
      "        [1.1250, 2.0000, 3.1250],\n",
      "        [4.5000, 6.1250, 8.0000]])\n",
      "\n",
      "x.mm(y) = \n",
      "tensor([[ 1.8750,  2.2500,  2.6250],\n",
      "        [ 5.2500,  6.7500,  8.2500],\n",
      "        [ 8.6250, 11.2500, 13.8750]])\n",
      "\n",
      "torch.cat([x, y], axis=1) = \n",
      "tensor([[0.0000, 1.0000, 2.0000, 0.0000, 0.1250, 0.2500],\n",
      "        [3.0000, 4.0000, 5.0000, 0.3750, 0.5000, 0.6250],\n",
      "        [6.0000, 7.0000, 8.0000, 0.7500, 0.8750, 1.0000]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_torch = torch.arange(0, 9).reshape(3, 3).type(torch.float)\n",
    "y_torch = torch.linspace(0.0, 1.0, steps=9).reshape(3, 3)\n",
    "\n",
    "print(\"x = \\n{}\\n\".format(x_torch))\n",
    "print(\"y = \\n{}\\n\".format(y_torch))\n",
    "print(\"x * y = \\n{}\\n\".format(x_torch * y_torch))\n",
    "print(\"x.mm(y) = \\n{}\\n\".format(x_torch.mm(y_torch)))\n",
    "print(\"torch.cat([x, y], axis=1) = \\n{}\\n\".format(torch.cat([x_torch, y_torch], dim=1)))\n",
    "# print(\" = \\n{}\\n\".format())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are differences?\n",
    "<img src=\"static/spiderman-meme.jpg\" width=500px align=\"center\"/>\n",
    "\n",
    "On the first sight PyTorch is about replacing `np.` with `torch.`. In most cases it's really true, but there are some more *key* differences:\n",
    "\n",
    "- by default NumPy creates float arrays with float64 dtype; PyTorch's default dtype is float32\n",
    "- `axis` in NumPy [`x.mean(axis=0)`] vs. `dim` in PyTorch [`x.mean(dim=0)`]\n",
    "- some functions' naming [e.g. `np.concatenate` vs. `torch.cat`]\n",
    "\n",
    "All these differences can be easily googled or found in awesome [PyTorch docs](https://pytorch.org/docs/stable/index.html). Checkout [this repository](https://github.com/wkentaro/pytorch-for-numpy-users) where all differences are listed in a table. If you still have questions, you can ask them on [PyTorch forum](https://discuss.pytorch.org) (it's alive and questions are frequently answered).\n",
    "\n",
    "So now you can ask: **why the hell should I use PyTorch instead of NumPy?** Actually PyTorch has some wonderful features, but we'll discuss them a bit later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A bit more examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy -> PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_torch = \n",
      "tensor([[0, 1, 2],\n",
      "        [3, 4, 5],\n",
      "        [6, 7, 8]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_numpy = np.arange(9).reshape(3, 3)\n",
    "x_torch = torch.from_numpy(x_numpy)\n",
    "\n",
    "print(\"x_torch = \\n{}\\n\".format(x_torch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch -> NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_numpy = \n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_torch = torch.arange(9).reshape(3, 3)\n",
    "x_numpy = x_torch.numpy()\n",
    "\n",
    "print(\"x_numpy = \\n{}\\n\".format(x_numpy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inplace operations. In PyTorch you can peform inplace operations (no copying). Many tensor methods have their inplace twins with `_` symbol in the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[before] x = tensor([0., 1., 2., 3., 4.])\n",
      "[after]  x = tensor([0.0000, 1.0000, 1.4142, 1.7321, 2.0000])\n"
     ]
    }
   ],
   "source": [
    "x = torch.arange(5).type(torch.float)\n",
    "print(\"[before] x = {}\".format(x))\n",
    "\n",
    "x.sqrt_()\n",
    "print(\"[after]  x = {}\".format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[before] x = tensor([0., 1., 2., 3., 4.])\n",
      "[after]  x = tensor([0., 0., 0., 0., 0.])\n"
     ]
    }
   ],
   "source": [
    "x = torch.arange(5).type(torch.float)\n",
    "print(\"[before] x = {}\".format(x))\n",
    "\n",
    "x.zero_()\n",
    "print(\"[after]  x = {}\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Task 1 (1 point).** Drawing with PyTorch\n",
    "\n",
    "Implement this function and plot it using matplotlib:\n",
    "\n",
    "$$\n",
    "\\begin{cases}\n",
    "x = 16 \\sin^3(t) \\\\\n",
    "y = 13\\cos(t) - 5\\cos(2t) - 2\\cos(3t) - \\cos(4t) \\\\\n",
    "\\end{cases}\n",
    ",~ t \\in [0, 2\\pi]\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pylab as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = torch.linspace(0.0, 2 * np.pi, 100)\n",
    "\n",
    "x = 16 * torch.sin(t)**3\n",
    "y = 13 * torch.cos(t) - 5 * torch.cos(2*t) - 2 * torch.cos(3*t) - torch.cos(4 * t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x.numpy(), y.numpy(), c='red');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic differentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most important feature of PyTorch is that it can **differentiate (almost) any expression written** in PyTorch.\n",
    "\n",
    "For example you have function $f(x) = x^2$. You want to calculate partial detivative $\\frac{\\partial f}{\\partial x}$. PyTorch allows you to do it in 3 lines! Look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "df/dx = 4.0\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor(2.0, requires_grad=True)  # tells PyTorch that we'll need gradient of this tensor\n",
    "f_x = x ** 2  # run our function\n",
    "f_x.backward()  # calculate gradient\n",
    "\n",
    "print(\"df/dx = {}\".format(x.grad))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The salt is that $f(x)$ can be any (almost) any function you want (e.g. your neural network). It totally looks like magic. More on PyTorch automatic differentiation read [here](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple linear regression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.datasets import load_boston\n",
    "boston = load_boston()\n",
    "\n",
    "plt.scatter(boston.data[:, -1], boston.target)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. _boston_dataset:\n",
      "\n",
      "Boston house prices dataset\n",
      "---------------------------\n",
      "\n",
      "**Data Set Characteristics:**  \n",
      "\n",
      "    :Number of Instances: 506 \n",
      "\n",
      "    :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.\n",
      "\n",
      "    :Attribute Information (in order):\n",
      "        - CRIM     per capita crime rate by town\n",
      "        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.\n",
      "        - INDUS    proportion of non-retail business acres per town\n",
      "        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)\n",
      "        - NOX      nitric oxides concentration (parts per 10 million)\n",
      "        - RM       average number of rooms per dwelling\n",
      "        - AGE      proportion of owner-occupied units built prior to 1940\n",
      "        - DIS      weighted distances to five Boston employment centres\n",
      "        - RAD      index of accessibility to radial highways\n",
      "        - TAX      full-value property-tax rate per $10,000\n",
      "        - PTRATIO  pupil-teacher ratio by town\n",
      "        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town\n",
      "        - LSTAT    % lower status of the population\n",
      "        - MEDV     Median value of owner-occupied homes in $1000's\n",
      "\n",
      "    :Missing Attribute Values: None\n",
      "\n",
      "    :Creator: Harrison, D. and Rubinfeld, D.L.\n",
      "\n",
      "This is a copy of UCI ML housing dataset.\n",
      "https://archive.ics.uci.edu/ml/machine-learning-databases/housing/\n",
      "\n",
      "\n",
      "This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.\n",
      "\n",
      "The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic\n",
      "prices and the demand for clean air', J. Environ. Economics & Management,\n",
      "vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics\n",
      "...', Wiley, 1980.   N.B. Various transformations are used in the table on\n",
      "pages 244-261 of the latter.\n",
      "\n",
      "The Boston house-price data has been used in many machine learning papers that address regression\n",
      "problems.   \n",
      "     \n",
      ".. topic:: References\n",
      "\n",
      "   - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.\n",
      "   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(boston.DESCR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert data to torch tensors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.from_numpy(boston.data[:, -1]).type(torch.float)\n",
    "x = (x - x.mean()) / x.std()  # normalization\n",
    "\n",
    "y = torch.from_numpy(boston.target).type(torch.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1-dimensional linear regression is formulated like this:\n",
    "$$\\normalsize y^{pred} = wx + b$$\n",
    "where $x$ - is a feature, $w, b$ - model parameters (weight and bias), and $y^{pred}$ - model's prediction.\n",
    "\n",
    "As a loss function we'll use **Mean Square Error** (MSE):\n",
    "$$MSE(y, y^{pred}) = \\frac{1}{N}\\sum_{i=0}^{N-1}(y_{i} - y_{i}^{pred}) ^ 2$$\n",
    "where $N$ - is a length of training set.\n",
    "\n",
    "To train our model, we'll use **Gradient Descent** (GD):\n",
    "$$\\normalsize w_{i} = w_{i - 1} - \\eta \\frac{\\partial loss}{\\partial w_{i - 1}}$$\n",
    "\n",
    "$$\\normalsize b_{i} = b_{i - 1} - \\eta \\frac{\\partial loss}{\\partial b_{i - 1}}$$\n",
    "where $\\eta$ - is a learning rate.\n",
    "\n",
    "But we're not going to calculate this partial derivative by hand. PyTorch will do it for us!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Declare model's parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = torch.tensor(1.0, requires_grad=True)\n",
    "b = torch.tensor(0.0, requires_grad=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 38.75\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "from IPython.display import clear_output\n",
    "\n",
    "lr = 0.01\n",
    "n_iters = 200\n",
    "\n",
    "losses = []\n",
    "\n",
    "for i in range(n_iters):\n",
    "    # forward pass\n",
    "    y_pred = w * x + b\n",
    "    \n",
    "    # calculate loss\n",
    "    loss = torch.mean((y - y_pred) ** 2)\n",
    "    losses.append(loss.item())\n",
    "    \n",
    "    # calculate gradients\n",
    "    loss.backward()\n",
    "    \n",
    "    # make gradient step\n",
    "    w.data = w.data - lr * w.grad.detach()  # detaching tensor from computational graph\n",
    "    b.data = b.data - lr * b.grad.detach()  #\n",
    "    \n",
    "    # zero gradients (otherwise they'll accumulate)\n",
    "    w.grad.zero_()\n",
    "    b.grad.zero_()\n",
    "\n",
    "    # visualization\n",
    "    if i % 10 == 0:\n",
    "        clear_output(True)\n",
    "        \n",
    "        print(\"loss: {:.04}\".format(loss.item()))\n",
    "        \n",
    "        # training set\n",
    "        plt.scatter(x.numpy(), y.numpy())\n",
    "        \n",
    "        # our predictions\n",
    "        plt.scatter(x.numpy(), y_pred.detach().numpy(), color='red')\n",
    "        \n",
    "        plt.xlabel(\"x\")\n",
    "        plt.ylabel(\"y\")\n",
    "        plt.show()\n",
    "    \n",
    "        \n",
    "plt.plot(losses)\n",
    "plt.xlabel(\"iters\")\n",
    "plt.ylabel(\"loss\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2 (1 point). Linear regression with polynomial features\n",
    "\n",
    "As you can see above simple linear regression doesn't fit data well. Let's add polynomial features:\n",
    "$$\\normalsize y^{pred} = \\sum_{i=0}^{D-1}w_{i}x^{i}$$\n",
    "\n",
    "To get total score for this task:\n",
    " - choose any $D$ you want and make loss **< 30.0**.\n",
    " - answer the question: \"why don't we have bias (b) here\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Потому что bias == $w_{0}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Declare model's parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = 4\n",
    "w = torch.rand(dim, 1, requires_grad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8798],\n",
       "        [0.2149],\n",
       "        [0.9384],\n",
       "        [0.6188]], requires_grad=True)"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([506])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_poly = torch.tensor([v**i for v in x for i in range(dim)]).reshape(-1, dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x_poly = torch.cat([x.reshape(-1, 1)**i for i in range(dim)], dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.0000, -1.0745,  1.1545, -1.2406],\n",
       "        [ 1.0000, -0.4920,  0.2420, -0.1191],\n",
       "        [ 1.0000, -1.2075,  1.4581, -1.7607],\n",
       "        ...,\n",
       "        [ 1.0000, -0.9821,  0.9645, -0.9472],\n",
       "        [ 1.0000, -0.8644,  0.7473, -0.6460],\n",
       "        [ 1.0000, -0.6684,  0.4468, -0.2986]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([4, 1]), torch.Size([506, 4]))"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.shape, x_poly.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([506, 1])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 28.89\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "from IPython.display import clear_output\n",
    "\n",
    "lr = 0.01\n",
    "n_iters = 1000\n",
    "\n",
    "losses = []\n",
    "\n",
    "for i in range(n_iters):\n",
    "    # forward pass\n",
    "    \n",
    "    y_pred = x_poly.mm(w)\n",
    "    \n",
    "    # calculate loss\n",
    "    loss = torch.mean((y - y_pred[:, 0]) ** 2)\n",
    "    losses.append(loss.item())\n",
    "    \n",
    "    # calculate gradients\n",
    "    loss.backward()\n",
    "    \n",
    "    # make gradient step\n",
    "    w.data = w.data - lr * w.grad.detach()  # detaching tensor from computational graph\n",
    "    \n",
    "    # zero gradients (otherwise they'll accumulate)\n",
    "    w.grad.zero_()\n",
    "\n",
    "    # visualization\n",
    "    if i % 10 == 0:\n",
    "        clear_output(True)\n",
    "        \n",
    "        print(\"loss: {:.04}\".format(loss.item()))\n",
    "        \n",
    "        # training set\n",
    "        plt.scatter(x.numpy(), y.numpy())\n",
    "        \n",
    "        # our predictions\n",
    "        plt.scatter(x.numpy(), y_pred.detach().numpy(), color='red')\n",
    "        \n",
    "        plt.xlabel(\"x\")\n",
    "        plt.ylabel(\"y\")\n",
    "        plt.show()\n",
    "    \n",
    "        \n",
    "plt.plot(losses)\n",
    "plt.xlabel(\"iters\")\n",
    "plt.ylabel(\"loss\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3 (2 points). Earthquake"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Big earthquake happened! Seismic sensors fixed heatmap of underground activity. You can find this map on the path `./data/earthquake-heatmap.npy`.\n",
    "Read earthquake heatmap and draw it with matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape: (256, 256)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x1233cf2e8>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "earthquake_heatmap = np.load('data/earthquake-heatmap.npy') # your code here (use np.load)\n",
    "\n",
    "shape = earthquake_heatmap.shape\n",
    "print(\"shape: {}\".format(shape))\n",
    "\n",
    "plt.imshow(earthquake_heatmap)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your task is to find coordinates of **earthquake epicenter** and **radius of seismic activity**.\n",
    "\n",
    "Possibly, your first thoughts will be: \"Hmm, epicenter I'll find by applying argmax for both dimensions. For radius I can write for-loop and... blablabla\". Such methods are okay, but we'll apply more **SCIENTIFIC** (actually not) method here. Scheme of proposed method is below.\n",
    "\n",
    "\n",
    "<img src=\"static/earthquake-method.png\" align=\"center\"/>\n",
    "\n",
    "We'll fit 2D gaussian to our earthquake heatmap.\n",
    "\n",
    "Overall algorithm is like this:\n",
    "1. generate 2D gaussian heatmap for current $\\mu$ and $\\sigma$ \n",
    "2. calculate per-pixel MSE of generated heatmap and earthquake heatmap\n",
    "3. calculate partial derivatives $\\frac{\\partial{loss}}{\\partial{\\mu}}$, $\\frac{\\partial{loss}}{\\partial{\\sigma}}$ and make gradient descent step to minimize loss\n",
    "4. go to step (1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To generate heatmap we'll need Probability Dense Function (PDF) of independent 2D normal distribution:\n",
    "\n",
    "$$p(x_1, x_2) = \\frac{1}{2\\pi \\sigma_1 \\sigma_2}\\exp\\left[{-\\frac{(x_1 - \\mu_1)^2}{2\\sigma_1^2} - \\frac{(x_2 - \\mu_2)^2}{2\\sigma_2^2}}\\right]$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement missing parts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gaussian_2d_pdf(coords, mu, sigma):\n",
    "    \"\"\"Independent 2D normal distribution PDF\n",
    "    \n",
    "    Args:\n",
    "        coords (tensor of shape (N, 2)): coordinates, where to calculate function\n",
    "        mu (tensor of shape (2,)): mu values\n",
    "        sigma (tensor of shape (2,)): sigma values\n",
    "        \n",
    "    \"\"\"\n",
    "    normalization = 2 * np.pi * sigma[0] * sigma[1] # your code here\n",
    "    exp = torch.exp(-torch.sum((coords - mu)**2 / (2 * sigma ** 2), 1))\n",
    "#     exp = torch.exp(\n",
    "#         -(coords[:, 0] - mu[0])**2 / (2 * sigma[0] ** 2) \n",
    "#         -(coords[:, 1] - mu[1])**2 / (2 * sigma[1] ** 2)\n",
    "#     )\n",
    "    return exp / normalization\n",
    "\n",
    "\n",
    "def draw_heatmap(mu, sigma, shape):\n",
    "    xx, yy = torch.meshgrid(torch.arange(shape[0]), torch.arange(shape[1]))\n",
    "    grid = torch.stack([xx, yy], dim=-1).type(torch.float32)\n",
    "    grid = grid.reshape((-1, 2))\n",
    "    \n",
    "    heatmap = gaussian_2d_pdf(grid, mu, sigma)\n",
    "    heatmap = heatmap.reshape(*shape)\n",
    "    \n",
    "    heatmap = (heatmap - heatmap.mean()) / heatmap.std()\n",
    "\n",
    "    return heatmap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate heatmap with any $\\mu$ and $\\sigma$; shape same as earthquake heatmap: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(256, 256)"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([196.0190, 224.3689], requires_grad=True),\n",
       " tensor([10.0396, 40.2688], requires_grad=True))"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mu, sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x128df79b0>"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mu = torch.tensor([100, 50], dtype=torch.float32)\n",
    "sigma = torch.tensor([100, 100], dtype=torch.float32)\n",
    "\n",
    "heatmap = draw_heatmap(mu, sigma, shape)\n",
    "\n",
    "plt.imshow(heatmap.numpy())\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define parameters of your model (initialize them with reasonable values):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu = torch.tensor([220, 120], dtype=torch.float32, requires_grad=True)\n",
    "sigma = torch.tensor([100, 100], dtype=torch.float32, requires_grad=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build optimization loop and fit `mu` and `sigma`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 1.092\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "from IPython.display import clear_output\n",
    "\n",
    "lr = 100\n",
    "n_iters = 1000\n",
    "# earthquake_heatmap = torch.from_numpy(earthquake_heatmap)\n",
    "\n",
    "losses = []\n",
    "\n",
    "for i in range(n_iters):\n",
    "    # forward pass\n",
    "    \n",
    "    heatmap = draw_heatmap(mu, sigma, shape)\n",
    "    \n",
    "    # calculate loss\n",
    "    loss = torch.mean((earthquake_heatmap - heatmap)**2)\n",
    "    losses.append(loss.item())\n",
    "    \n",
    "    # calculate gradients\n",
    "    loss.backward()\n",
    "    \n",
    "    # make gradient step\n",
    "    mu.data = mu.data - lr * mu.grad.detach()  # detaching tensor from computational graph\n",
    "    sigma.data = sigma.data - lr * sigma.grad.detach()  # detaching tensor from computational graph\n",
    "    \n",
    "    # zero gradients (otherwise they'll accumulate)\n",
    "    mu.grad.zero_()\n",
    "    sigma.grad.zero_()\n",
    "\n",
    "    # visualization\n",
    "    if i % 10 == 0:\n",
    "        clear_output(True)\n",
    "        \n",
    "        print(\"loss: {:.04}\".format(loss.item()))\n",
    "        \n",
    "        # training set\n",
    "        plt.imshow(earthquake_heatmap.numpy())\n",
    "        plt.colorbar()\n",
    "        plt.show()\n",
    "        \n",
    "        # our predictions\n",
    "        plt.imshow(heatmap.detach().numpy())\n",
    "        plt.colorbar()\n",
    "        plt.show()\n",
    "    \n",
    "        \n",
    "plt.plot(losses)\n",
    "plt.xlabel(\"iters\")\n",
    "plt.ylabel(\"loss\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips:\n",
    "- Plot your map and loss curve every n-th iteration\n",
    "- Tune learning rate\n",
    "- Try different initializations of $\\mu$ and $\\sigma$\n",
    "- Play with different number of iterations\n",
    "- Try Mean Absolute Error (MAE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}