{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning and Statistics for Physicists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Material for a [UC Irvine](https://uci.edu/) course offered by the [Department of Physics and Astronomy](https://www.physics.uci.edu/).\n",
    "\n",
    "Content is maintained on [github](github.com/dkirkby/MachineLearningStatistics) and distributed under a [BSD3 license](https://opensource.org/licenses/BSD-3-Clause).\n",
    "\n",
    "##### ► [View table of contents](Contents.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor Computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most practical algorithms of ML can be decomposed into small steps where the calculations are expressed with linear algebra, i.e., linear combinations of scalars, vectors and matrices.\n",
    "\n",
    "For example, a neural network can be built from layers that each calculate\n",
    "$$\n",
    "\\mathbf{x}_\\text{out} = \\max(0, W \\mathbf{x}_\\text{in} + \\mathbf{b}) \\; ,\n",
    "$$\n",
    "where $W$ is a matrix, and boldface symbols represent vectors. In typical applications, $\\mathbf{x}_\\text{out}$ and $\\mathbf{x}_\\text{in}$ are derived from **data** while $W$ and $\\mathbf{b}$ are considered **model parameters**. (This expression is not strictly linear: why?)\n",
    "\n",
    "The python numeric and list types can represent arbitrary scalars, vectors, and matrices, but are designed for flexibility instead of efficiency.\n",
    "\n",
    "Numpy is instead optimized for the special case where all list elements are numeric values of the same type, which can be organized and accessed very efficiently in memory, with a specialized array type with lots of nice features. One downside of this approach is that most of builtin math functions are duplicated (e.g., `math.sin` and `np.sin`) to work with numpy arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**EXERCISE:** Complete the function below using numpy to evaluate the neural-network layer defined above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "def xout(W, xin, b):\n",
    "    return np.maximum(0, W.dot(xin) + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def xout(W, xin, b):\n",
    "    # Add your solution here\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Terminology"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We frequently use $\\mathbf{r} = (x, y, z)$ in physics to represent an *arbitrary* position in three (continuous) dimensions.\n",
    "\n",
    "In numpy, we cannot represent an *arbitrary* position but can easily represent a *specific* position, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "rvec = np.array([0.1, -0.2, 0.3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, `rvec` has only one (discrete) dimension, which we use to access its three array elements with indices 0,1,2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1, -0.2, 0.3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rvec[0], rvec[1], rvec[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we use the term **dimension** differently in these two cases!\n",
    "\n",
    "All numpy arrays have a `shape` property that specifies the range of indices allowed for each of their (discrete) dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rvec.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rvec.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare with a matrix represented in numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.identity(3)\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.0)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[1, 0], matrix[1, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy supports arrays with any (finite) number of (discrete) dimensions. The general name for these arrays is a **tensor** (so, scalars, vectors and matrices are tensors). For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "tensor = np.ones((2, 3, 4))\n",
    "print(tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 1.0)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor[0, 0, 0], tensor[1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensors are used in physics also: for example, the tensor expression $g^{il} \\Gamma^m_{ki} x^k$ arises in [contravariant derivatives in General Relativity](https://en.wikipedia.org/wiki/Christoffel_symbols#Covariant_derivatives_of_tensors). What are the **dimensions** of $g$, $\\Gamma$ and $x$ in this expression?  Note that numpy tensors do not make any distinction between upper or lower indices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numpy dimension is sometimes also referred to as the **rank**, but note that [array rank](https://en.wikipedia.org/wiki/Rank_(computer_programming)) is similar to but subtly different from [linear algebra rank](https://en.wikipedia.org/wiki/Rank_(linear_algebra))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fundamental Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tensor Creation\n",
    "\n",
    "The most common ways you will create new arrays are:\n",
    "- Filled with a simple sequence of constant values\n",
    "- Filled with (reproducible) random values\n",
    "- Calculated as a mathematical function of existing arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Regular sequence of values\n",
    "shape = (3, 4)\n",
    "c1 = np.zeros(shape)\n",
    "c2 = np.ones(shape)\n",
    "c3 = np.full(shape, -1)\n",
    "c4 = np.arange(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reproducible \"random\" numbers\n",
    "gen = np.random.RandomState(seed=123)\n",
    "r1 = gen.uniform(size=shape)\n",
    "r2 = gen.normal(loc=-1, scale=2, size=shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculated as function of existing array.\n",
    "f1 = r1 * np.sin(r2) ** c3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the values contained within a tensors have the same [data type](https://docs.scipy.org/doc/numpy-1.15.0/user/basics.types.html), which you can inspect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dtype('float64'), dtype('int64'))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1.dtype, c4.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**EXERCISE:** Try to guess the `dtype` of `c3`, `r2` and `f1`, then check your answer.  Deep learning often uses smaller (32 or 16 bit) float data types: what advantages and disadvantages might this have?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "**SOLUTION:** The `zeros` and `ones` functions default to `float64`, but `full` uses the type of the provided constant value. Integers are automatically promoted to floats in mixed expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dtype('int64'), dtype('float64'), dtype('float64'))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c3.dtype, r2.dtype, f1.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "Smaller floats allow more efficient use of limited (GPU) memory and faster calculations, at the cost of some accuracy. Since the training of a deep neural network is inherently noisy, this is generally a good tradeoff."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tensor Reshaping\n",
    "\n",
    "It is often useful to [reshape](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.reshape.html) a tensor without changing its total size, which can be done very efficiently since the layout of the tensor values in memory does not need to be changed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c4.reshape(c1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**EXERCISE:** Predict the result of `c4.reshape(2, 3, 2)` then check your answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true,
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c4.reshape(2, 3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tensor Broadcasting\n",
    "\n",
    "The real power of tensor computing comes from expressions like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add one to each element.\n",
    "c4 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 2., 3.],\n",
       "       [0., 1., 2., 3.],\n",
       "       [0., 1., 2., 3.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Scale each column of the 3x4 ones matrix by a different value.\n",
    "np.ones(shape=(3, 4)) * np.arange(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are not surprising in these examples, but something non-trivial is going on behind the scenes to make this work since we are combining tensors with different shapes. This is called [broadcasting](https://docs.scipy.org/doc/numpy-1.15.0/user/basics.broadcasting.html) and has specific rules for how to handle less obvious cases.\n",
    "\n",
    "Broadcasting serves two purposes:\n",
    " - It allows more compact and easier to understand \"vectorized\" expressions, where loops over elements in each dimension are implicit.\n",
    " - It enables automatic optimizations to take advantage of the available hardware, since explicit python loops are generally a bottleneck.\n",
    " \n",
    "Not all expressions can be automatically broadcast, even if they seem to make sense.  For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "operands could not be broadcast together with shapes (3,4) (3,) \n"
     ]
    }
   ],
   "source": [
    "# Scale each row of the 3x4 ones matrix by a different value.\n",
    "try:\n",
    "    np.ones(shape=(3, 4)) * np.arange(3)\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you can usually reshape the inputs to get the desired result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=(3, 4)) * np.arange(3).reshape(3, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful trick is to use `keepdims=True` with reducing functions, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3. 3. 3. 3.]\n",
      "[[3.]\n",
      " [3.]\n",
      " [3.]\n",
      " [3.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.ones((4, 3)).sum(axis=1))\n",
    "print(np.ones((4, 3)).sum(axis=1, keepdims=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To experiment with broadcasting rules, define a function to try broadcasting two arbitrary tensor shapes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def broadcast(shape1, shape2):\n",
    "    array1 = np.ones(shape1)\n",
    "    array2 = np.ones(shape2)\n",
    "    try:\n",
    "        array12 = array1 + array2\n",
    "        print('shapes {} {} broadcast to {}'.format(shape1, shape2, array12.shape))\n",
    "    except ValueError as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shapes (1, 3) (3,) broadcast to (1, 3)\n"
     ]
    }
   ],
   "source": [
    "broadcast((1, 3), (3,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "operands could not be broadcast together with shapes (1,2) (3,) \n"
     ]
    }
   ],
   "source": [
    "broadcast((1, 2), (3,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**EXERCISE:** Predict the results of the following then check your answers:\n",
    "```\n",
    "broadcast((3, 1, 2), (3, 2))\n",
    "broadcast((2, 1, 3), (3, 2))\n",
    "broadcast((3,), (2, 1))\n",
    "broadcast((3,), (1, 2))\n",
    "broadcast((3,), (1, 3))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shapes (3, 1, 2) (3, 2) broadcast to (3, 3, 2)\n",
      "operands could not be broadcast together with shapes (2,1,3) (3,2) \n",
      "shapes (3,) (2, 1) broadcast to (2, 3)\n",
      "operands could not be broadcast together with shapes (3,) (1,2) \n",
      "shapes (3,) (1, 3) broadcast to (1, 3)\n"
     ]
    }
   ],
   "source": [
    "broadcast((3, 1, 2), (3, 2))\n",
    "broadcast((2, 1, 3), (3, 2))\n",
    "broadcast((3,), (2, 1))\n",
    "broadcast((3,), (1, 2))\n",
    "broadcast((3,), (1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor Frameworks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy\n",
    "\n",
    "Numpy is an example of a framework for tensor computing that is widely supported and requires no special hardware. However, it still offers significant performance improvements by eliminating explicit python loops and using memory efficiently.\n",
    "\n",
    "For example, let's calculate the opening angle separation between two unit vectors, each specified with (lat, lon) angles in radians (or RA,DEC for astronomers, as implemented [here](https://desisurvey.readthedocs.io/en/latest/api.html#desisurvey.utils.separation_matrix)). The [Haversine formula](https://en.wikipedia.org/wiki/Haversine_formula) is a good way to calculate this quantity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate a large number of random unit vectors for benchmarking (are these uniformly distributed on the sphere?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def generate(N, seed=123):\n",
    "    gen = np.random.RandomState(seed=123)\n",
    "    lats = gen.uniform(low=-np.pi / 2, high=+np.pi / 2, size=N)\n",
    "    lons = gen.uniform(low=0, high=2 * np.pi, size=N)\n",
    "    plt.plot(lons, lats, '.')\n",
    "    return lats, lons\n",
    "\n",
    "lats, lons = generate(N=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use explicit python loops to calculate the (square) matrix of separation angles between all pairs of unit vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separation_matrix_loops():\n",
    "    # Allocate memory for the matrix.\n",
    "    N = len(lats)\n",
    "    matrix = np.empty((N, N))\n",
    "    for i, (lat1, lon1) in enumerate(zip(lats, lons)):\n",
    "        for j, (lat2, lon2) in enumerate(zip(lats, lons)):\n",
    "            # Evaluate the Haversine formula for matrix element [i, j].\n",
    "            matrix[i, j] = 2 * np.arcsin(np.sqrt(\n",
    "                np.sin(0.5 * (lat2 - lat1)) ** 2 +\n",
    "                np.cos(lat1) * np.cos(lat2) * np.sin(0.5 * (lon2 - lon1)) ** 2))\n",
    "    return matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 8.72 s, sys: 39.2 ms, total: 8.76 s\n",
      "Wall time: 8.79 s\n"
     ]
    }
   ],
   "source": [
    "%time S1 = separation_matrix_loops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now calculate the same separations using numpy implicit loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separation_matrix_numpy():\n",
    "    lat1, lat2 = lats, lats.reshape(-1, 1)\n",
    "    lon1, lon2 = lons, lons.reshape(-1, 1)\n",
    "    return 2 * np.arcsin(np.sqrt(\n",
    "        np.sin(0.5 * (lat2 - lat1)) ** 2 +\n",
    "        np.cos(lat1) * np.cos(lat2) * np.sin(0.5 * (lon2 - lon1)) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 56.8 ms, sys: 16.1 ms, total: 72.9 ms\n",
      "Wall time: 71.7 ms\n"
     ]
    }
   ],
   "source": [
    "%time S2 = separation_matrix_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that both calculations give the same results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(S1, S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this is so much faster, increase the amount of computation (and memory) 100x for a better benchmark:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lats, lons = generate(N=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.26 s, sys: 1.57 s, total: 6.83 s\n",
      "Wall time: 6.85 s\n"
     ]
    }
   ],
   "source": [
    "%time S2 = separation_matrix_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore using implicit numpy loops speeds up the calculation by a factor of about 6.8 / 0.02 = 340. Since we are using the efficient numpy arrays in both cases, the speed up is entirely due to the loops!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other Frameworks: PyTorch and TensorFlow\n",
    "\n",
    "Machine learning relies heavily on frameworks that copy the successful numpy design for tensor computing, while adding some important new features:\n",
    " - Automatic hardware acceleration.\n",
    " - Automatic calculation of derivatives.\n",
    " - Efficient deployment to other platforms (mobile, cloud).\n",
    " \n",
    "Unlike numpy, the default type in these frameworks is usually a 32-bit float, rather than a 64-bit float.\n",
    "\n",
    "The two most popular tensor computing frameworks for machine learning today are [PyTorch](https://pytorch.org/) and [TensorFlow](https://www.tensorflow.org/). Both are large open-source projects, primarily developed by facebook (pytorch) and google (tensorflow). These frameworks were originally quite different, with pytorch preferred for research and tensorflow preferred for large-scale deployment, but they are gradually converging towards similar a feature set.\n",
    "\n",
    "Below, we repeat our calculation of the separation matrix with both of these frameworks. You will notice that the new features come with some additional complexity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PyTorch Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu.\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else \"cpu\"\n",
    "print(f'Using device: {device}.')\n",
    "lons_pt = torch.tensor(lons, device=device)\n",
    "lats_pt = torch.tensor(lats, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separation_matrix_torch():\n",
    "    lat1, lat2 = lats_pt, lats_pt.reshape(-1, 1)\n",
    "    lon1, lon2 = lons_pt, lons_pt.reshape(-1, 1)\n",
    "    return 2 * torch.asin(torch.sqrt(\n",
    "        torch.sin(0.5 * (lat2 - lat1)) ** 2 +\n",
    "        torch.cos(lat1) * torch.cos(lat2) * torch.sin(0.5 * (lon2 - lon1)) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.98 s, sys: 5.5 s, total: 10.5 s\n",
      "Wall time: 2.35 s\n"
     ]
    }
   ],
   "source": [
    "%time S3 = separation_matrix_torch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(S2, S3.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TensorFlow Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: CPU:0.\n"
     ]
    }
   ],
   "source": [
    "device = 'GPU:0' if tf.config.list_physical_devices('GPU') else 'CPU:0'\n",
    "print(f'Using device: {device}.')\n",
    "with tf.device(device):\n",
    "    lons_tf = tf.constant(lons)\n",
    "    lats_tf = tf.constant(lats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separation_matrix_tensorflow():\n",
    "    lat1, lat2 = lats_tf, tf.reshape(lats_tf, [-1, 1])\n",
    "    lon1, lon2 = lons_tf, tf.reshape(lons_tf, [-1, 1])\n",
    "    return 2 * tf.asin(tf.sqrt(\n",
    "        tf.sin(0.5 * (lat2 - lat1)) ** 2 +\n",
    "        tf.cos(lat1) * tf.cos(lat2) * tf.sin(0.5 * (lon2 - lon1)) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20.4 s, sys: 9.31 s, total: 29.7 s\n",
      "Wall time: 3.54 s\n"
     ]
    }
   ],
   "source": [
    "%time S4 = separation_matrix_tensorflow()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(S2, S4.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Hardware Acceleration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensor computing can be sped up significantly (10-100x) using hardware that is optimized to perform tensor computing by distributing simple calculations (\"kernels\") across many independent processors (\"cores\") running in parallel.\n",
    "\n",
    "The original driver for such hardware was to accelerate the 3D geometry calculations required to render real time 3D graphics, leading to the first [Graphics Processing Units (GPUs)](https://en.wikipedia.org/wiki/Graphics_processing_unit) in the 1990s.  More recently, GPUs have been adopted for purely numerical calculations, with no display attached, leading to the development of specialized programming languages such as [CUDA](https://en.wikipedia.org/wiki/CUDA) and [OpenCL](https://en.wikipedia.org/wiki/OpenCL).\n",
    "\n",
    "Currently, one vendor (Nvidia) dominates the use of GPUs for ML with its proprietary CUDA language.  Google has also introduced an even more specialized [TPU](https://en.wikipedia.org/wiki/Tensor_processing_unit) architecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table below shows some benchmarks for the separation matrix problem, running on different hardware with different frameworks.  The speed ups obtained using PyTorch and TensorFlow with a GPU are typical. The two frameworks provide comparable GPU performance overall, but can differ on specific problems.\n",
    "\n",
    "\n",
    "| Test       | Laptop |Server(GPU) | Collab(CPU) | Collab(GPU) |\n",
    "|------------|--------|------------|-------------|-------------|\n",
    "| numpy      | 2.08s  | 1.17s      | 10.5s       | 10.3s       |\n",
    "| torch      | 7.32s  | 48.7ms     | ---         | ---         |\n",
    "| tensorflow | ---    | ---        | 9.11s       | 246ms       | \n",
    "| ratio      | 3.5    | 1 / 24     | 0.87        | 1 / 41      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To benefit from this hardware, you can either add a GPU to a linux server, or use a cloud computing platform.\n",
    "\n",
    "Cloud computing is the easiest way to get started.  There are some free options, but generally you have to \"pay as you go\" to do a useful amount of work. Some good starting points are:\n",
    " - [Google Collaboratory](https://colab.research.google.com/): free research tool with a jupyter notebook front end.\n",
    " - [PaperSpace](https://www.paperspace.com/): reasonably priced and simple to get started.\n",
    " - [Amazon Web Services](https://aws.amazon.com/ec2/): free to try, very flexible and relatively complex.\n",
    " - [Google Cloud](https://cloud.google.com/): comparable to AWS.\n",
    " \n",
    "**Note: this is not a complete list, and pricing and capabilities are rapidly changing.**\n",
    "\n",
    "If you are considering building your own GPU server, start [here](http://timdettmers.com/2018/11/05/which-gpu-for-deep-learning/). A single server can host 4 GPUs. Here is a single water-cooled [RTX 2080 Ti](https://www.nvidia.com/en-us/geforce/graphics-cards/rtx-2080-ti/) GPU installed in my office:\n",
    "\n",
    "![GPU server](img/TensorComputing/GPU-server.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatic Derivatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to hardware acceleration, a key feature of tensor computing frameworks for ML is their ability to automate the calculation of derivatives, which then enable efficient and accurate gradient-based optimization algorithms.\n",
    "\n",
    "In general, a derivate can be implemented in software three ways:\n",
    " - Analytically (using paper or mathematica) then copied into code: this is the most efficient and accurate but least generalizable.\n",
    " - Numerically, with [finite difference equations](https://en.wikipedia.org/wiki/Finite_difference): this is the least efficient and accurate, but most generalizable.\n",
    " - [Automatically](https://en.wikipedia.org/wiki/Automatic_differentiation): a hybrid approach where a small set of primitive functions (sin, cos, log, ...) are handled analytically, then the derivatives of expressions using these primitives are computed on the fly using the chain rule, product rule, etc. This is efficient and accurate, but requires that expressions are built entirely from primitives that support AD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a concrete example calculate the (un-normalized) Gaussian distribution\n",
    "$$\n",
    "y(x) = e^{-x^2}\n",
    "$$\n",
    "in PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.linspace(-5, 5, 20, requires_grad=True)\n",
    "y = torch.exp(-x ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1.3888e-11, 2.0328e-09, 1.7098e-07, 8.2640e-06, 2.2952e-04, 3.6632e-03,\n",
       "        3.3596e-02, 1.7705e-01, 5.3619e-01, 9.3309e-01, 9.3309e-01, 5.3619e-01,\n",
       "        1.7705e-01, 3.3596e-02, 3.6632e-03, 2.2952e-04, 8.2640e-06, 1.7098e-07,\n",
       "        2.0328e-09, 1.3888e-11], grad_fn=<ExpBackward>)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We specify `requires_grad=True` to enable AD for all tensors that depend on `x` (so just `y` in this case). To calculate partial derivatives (\"gradients\") of `y` wrt `x`, use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "y.backward(torch.ones_like(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tensor `x.grad` now contains $y'(x)$ at each value of `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 1.3888e-10,  1.8188e-08,  1.3498e-06,  5.6543e-05,  1.3288e-03,\n",
       "         1.7352e-02,  1.2377e-01,  4.6593e-01,  8.4661e-01,  4.9110e-01,\n",
       "        -4.9110e-01, -8.4661e-01, -4.6593e-01, -1.2377e-01, -1.7352e-02,\n",
       "        -1.3288e-03, -5.6543e-05, -1.3498e-06, -1.8188e-08, -1.3888e-10])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_n = x.detach().numpy()\n",
    "yp_n = x.grad.detach().numpy()\n",
    "y_n = y.detach().numpy()\n",
    "plt.plot(x_n, y_n, 'o--', label='$y(x)$')\n",
    "plt.plot(x_n, yp_n, 'o:', label='$y^\\prime(x)$')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these derivatives are calculated to full machine precision and not affected by the coarse spacing in $x$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Jax](https://github.com/google/jax) is a relatively new framework for automatic differentiation (developed by google but independent of tensorflow) that relies on \"just-in-time\" compilation and is designed for ML research."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Higher-Level APIs for Tensor Computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although TensorFlow and PyTorch are both similar to numpy, they have different APIs so you are forced to choose one to take advantage of their unique features.  However, for many calculations they are interchangeable, and a new ecosystem of higher-level APIs is growing to support this.  For example, check out:\n",
    " - [Tensorly](http://tensorly.org/stable/index.html): \"*Tensor learning in python*\". Includes powerful [decomposition](https://arxiv.org/abs/1711.10781) (generalized PCA) and regression algorithms.\n",
    " - [einops](https://github.com/arogozhnikov/einops): \"*Deep learning operations reinvented*\". Supports compact expressions for complex indexing operations ([np.einsum](https://docs.scipy.org/doc/numpy/reference/generated/numpy.einsum.html) on steroids).\n",
    " \n",
    "Neither of these packages are included in the MLS conda environment, but I encourage you to experiment with them if you want to write framework-independent tensor code."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}