ansible/files/materials/0-Lecture.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ssanderson/.virtualenvs/fonc/lib/python3.5/site-packages/fortranmagic.py:147: UserWarning: get_ipython_cache_dir has moved to the IPython.paths module since IPython 4.0.\n",
      "  self._lib_dir = os.path.join(get_ipython_cache_dir(), 'fortran')\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "$.getScript(\"https://raw.github.com/marijnh/CodeMirror/master/mode/fortran/fortran.js\", function () {\n",
       "IPython.config.cell_magic_highlight['magic_fortran'] = {'reg':[/^%%fortran/]};});\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%load_ext fortranmagic\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "mpl.rc('figure', figsize=(12, 7))\n",
    "\n",
    "ran_the_first_cell = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "  <h1>Foundations of Numerical Computing</h1>\n",
    "  <h3>Scott Sanderson (GitHub: [@ssanderson](https://github.com/ssanderson), Twitter: [@scottbsanderson](https://twitter.com/scottbsanderson) )</h3>\n",
    "  <h3>Materials: [https://github.com/ssanderson/foundations-of-numerical-computing](https://github.com/ssanderson/foundations-of-numerical-computing)</h3>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# About Me:\n",
    "\n",
    "- Senior Engineer at [Quantopian](www.quantopian.com)\n",
    "- I build tools for strangers on the internet to write quantitative trading strategies in Python.\n",
    "- Most of those tools are built on top of numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction\n",
    "\n",
    "The goal of this tutorial is help you effectively solve numerically-intensive problems in Python.\n",
    "\n",
    "In practice, doing numerical programming in Python means using [`numpy`](http://www.numpy.org/) (or a library built on top of `numpy`).\n",
    "\n",
    "Using `numpy` effectively requires changing the way that you think about and solve problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Warm Up: Finding Functions and Documentation in Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Review: Python Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "assert ran_the_first_cell, \"You need to run the first cell!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'two', 3.0, 4, 5j, 'six']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 'two', 3.0, 4, 5j, \"six\"]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first: 1\n",
      "second: two\n"
     ]
    }
   ],
   "source": [
    "# Lists can be indexed like C-style arrays.\n",
    "first = l[0]\n",
    "second = l[1]\n",
    "print(\"first:\", first)\n",
    "print(\"second:\", second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last: six\n",
      "second to last: 5j\n"
     ]
    }
   ],
   "source": [
    "# Negative indexing gives elements relative to the end of the list.\n",
    "last = l[-1]\n",
    "penultimate = l[-2]\n",
    "print(\"last:\", last)\n",
    "print(\"second to last:\", penultimate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['two', 3.0]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lists can also be sliced, which makes a copy of elements between \n",
    "# start (inclusive) and stop (exclusive)\n",
    "l = [1, 'two', 3.0, 4, 5j, \"six\"]\n",
    "sublist = l[1:3]\n",
    "sublist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Three: [1, 'two', 3.0]\n",
      "After Three: [4, 5j, 'six']\n"
     ]
    }
   ],
   "source": [
    "# l[:N] is equivalent to l[0:N].\n",
    "first_three = l[:3]\n",
    "print(\"First Three:\", first_three)\n",
    "\n",
    "# l[3:] is equivalent to l[3:len(l)].\n",
    "after_three = l[3:]\n",
    "print(\"After Three:\", after_three)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 'd', 'f']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# There's also a third parameter, \"step\", which gets every Nth element.\n",
    "l = ['a', 'b', 'c', 'd', 'e', 'f', 'g','h']\n",
    "l[1:7:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: [1, 2, 3, 4, 5]\n",
      "After: [1, 2, 3, 4, 5, 'six']\n"
     ]
    }
   ],
   "source": [
    "# Lists can be grown efficiently (in O(1) amortized time).\n",
    "l = [1, 2, 3, 4, 5]\n",
    "\n",
    "print(\"Before:\", l)\n",
    "\n",
    "l.append('six')\n",
    "print(\"After:\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprehensions let us perform elementwise computations.\n",
    "l = [1, 2, 3, 4, 5]\n",
    "[x * 2 for x in l]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Review of Review: Python Lists\n",
    "\n",
    "- Zero-indexed sequence of values.\n",
    "- Can hold values of different types in a single list.\n",
    "- Slicing syntax: `l[start:stop:step]` copies elements at regular intervals from `start` to `stop`.\n",
    "- Efficient (`O(1)`) appends and removes from end.\n",
    "- Comprehension syntax: `[f(x) for x in l if cond(x)]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img src=\"images/pacino.gif\" alt=\"Drawing\" style=\"width: 100%;\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Numerical Programming in Pure Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Suppose we have some matrices...\n",
    "a = [[1, 2, 3],\n",
    "     [2, 3, 4],\n",
    "     [5, 6, 7],\n",
    "     [1, 1, 1]]\n",
    "\n",
    "b = [[1, 2, 3, 4],\n",
    "     [2, 3, 4, 5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 8, 11, 14], [8, 13, 18, 23], [17, 28, 39, 50], [3, 5, 7, 9]]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def matmul(A, B):\n",
    "    \"\"\"Multiply matrix A by matrix B.\"\"\"\n",
    "    \n",
    "    rows_out = len(A)\n",
    "    cols_out = len(B[0])\n",
    "    out = [[0 for col in range(cols_out)] for row in range(rows_out)]\n",
    "    \n",
    "    for i in range(rows_out):\n",
    "        for j in range(cols_out):\n",
    "            for k in range(len(B)):\n",
    "                out[i][j] += A[i][k] * B[k][j]\n",
    "    return out\n",
    "\n",
    "matmul(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"images/gross.gif\" alt=\"Drawing\" style=\"width: 50%;\"/></center>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 23 µs, sys: 15 µs, total: 38 µs\n",
      "Wall time: 42.9 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[5, 8, 11, 14], [8, 13, 18, 23], [17, 28, 39, 50], [3, 5, 7, 9]]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "matmul(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0.2556594131922857, 0.5808554744836325, 0.01601689680241003],\n",
       " [0.5603496796153556, 0.6305687799297003, 0.8699113554817012]]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "def random_matrix(m, n):\n",
    "    out = []\n",
    "    for row in range(m):\n",
    "        out.append([random.random() for _ in range(n)])\n",
    "    return out\n",
    "\n",
    "randm = random_matrix(2, 3)\n",
    "randm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.14 s, sys: 10.1 ms, total: 4.15 s\n",
      "Wall time: 4.15 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "randa = random_matrix(500, 100)\n",
    "randb = random_matrix(100, 500)\n",
    "x = matmul(randa, randb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Maybe that's as good as we can do?  Let's try a simpler case.\n",
    "def python_dot_product(xs, ys):\n",
    "    return sum(x * y for x, y in zip(xs, ys))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%fortran\n",
    "subroutine fortran_dot_product(xs, ys, result)\n",
    "    double precision, intent(in) :: xs(:)\n",
    "    double precision, intent(in) :: ys(:)\n",
    "    double precision, intent(out) :: result\n",
    "    \n",
    "    result = sum(xs * ys)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list_data = [float(i) for i in range(100000)]\n",
    "array_data = np.array(list_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 8.47 ms, sys: 65 µs, total: 8.53 ms\n",
      "Wall time: 8.5 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "333328333350000.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "python_dot_product(list_data, list_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 124 µs, sys: 16 µs, total: 140 µs\n",
      "Wall time: 144 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "333328333350000.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "fortran_dot_product(array_data, array_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img src=\"images/sloth.gif\" alt=\"Drawing\" style=\"width: 1080px;\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why is the Python Version so Much Slower?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, (4+0j), 9.0, 'fourfourfourfour']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dynamic typing.\n",
    "def multiply_elementwise(xs, ys):\n",
    "    return [x * y for x, y in zip(xs, ys)]\n",
    "\n",
    "multiply_elementwise([1, 2, 3, 4], [1, 2 + 0j, 3.0, 'four'])\n",
    "#[type(x) for x in _]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1           0 LOAD_NAME                0 (a)\n",
      "              3 LOAD_NAME                1 (b)\n",
      "              6 LOAD_NAME                2 (c)\n",
      "              9 BINARY_MULTIPLY\n",
      "             10 BINARY_ADD\n",
      "             11 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "# Interpretation overhead.\n",
    "source_code = 'a + b * c'\n",
    "bytecode = compile(source_code, '', 'eval')\n",
    "import dis; dis.dis(bytecode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Review: Why is the Python Version so Slow?\n",
    "- Dynamic typing means that every single operation requires dispatching on the input type.\n",
    "- Having an interpreter means that every instruction is fetched and dispatched at runtime.\n",
    "- Other overheads:\n",
    "  - Arbitrary-size integers.\n",
    "  - Reference-counted garbage collection."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> This is the paradox that we have to work with when we're doing scientific or numerically-intensive Python. What makes Python fast for development -- this high-level, interpreted, and dynamically-typed aspect of the language -- is exactly what makes it slow for code execution.\n",
    "\n",
    "- Jake VanderPlas, [*Losing Your Loops: Fast Numerical Computing with NumPy*](https://www.youtube.com/watch?v=EEUXKG97YRw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What Do We Do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"images/runaway.gif\" alt=\"Drawing\" style=\"width: 50%;\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"images/thisisfine.gif\" alt=\"Drawing\" style=\"width: 1080px;\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Normal Python is slow for numerical computation because it performs dynamic dispatch on every operation we perform..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- ...but often, we just want to do the same thing over and over in a loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- If we don't need Python's dynamicism, can we find a way to not pay (much) for it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- **Idea:** Dispatch **once per operation** instead of **once per element**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data: [1 2 3 4 5 6 7 8]\n",
      "===========\n",
      "DType: int64\n",
      "Shape: (8,)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "data = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "print(\"Data:\", data)\n",
    "print(\"===========\")\n",
    "print(\"DType:\", data.dtype)\n",
    "print(\"Shape:\", data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy provides operators that \"vectorize\" over the entire array.\n",
    "data + data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 43 µs, sys: 6 µs, total: 49 µs\n",
      "Wall time: 51.5 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "204"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "# Naive dot product\n",
    "(data * data).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 22 µs, sys: 3 µs, total: 25 µs\n",
      "Wall time: 28.1 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "204"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "# Built-in dot product.\n",
    "data.dot(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 23 µs, sys: 0 ns, total: 23 µs\n",
      "Wall time: 18.6 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "204.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "fortran_dot_product(data, data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'foo'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-1ae73c964fd5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Numpy won't allow us to write a string into an int array.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"foo\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'foo'"
     ]
    }
   ],
   "source": [
    "# Numpy won't allow us to write a string into an int array.\n",
    "data[0] = \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# We also can't grow an array once it's created.\n",
    "data.append(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# We **can** reshape an array as long as the number of elements doesn't change.\n",
    "reshaped = data.reshape(4, 2)\n",
    "reshaped"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Numpy arrays are:\n",
    "\n",
    "- Fixed-type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Size-immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Multi-dimensional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Fast\\*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\\* If you use them correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercises - Measuring Performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Numpy Toolbox - Overview\n",
    "\n",
    "Numpy can be fast because it allows us to specify operations to perform against an entire array.\n",
    "\n",
    "We can break down the tools provided by numpy into a few categories:\n",
    "\n",
    "1. Array Creation and Reshaping\n",
    "2. Universal Functions (UFuncs)\n",
    "3. Selection\n",
    "4. Reductions\n",
    "5. Broadcasting\n",
    "\n",
    "Taken together, these operations form an expressive toolbox that can solve a diverse set of problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating Arrays\n",
    "\n",
    "- `np.array`: Construct an array from a list of Python objects.\n",
    "- `np.arange`: Numpy equivalent of the `range` function.\n",
    "- `np.linspace`: Create an array from evenly-spaced points between two values.\n",
    "- `np.random`: Randomly-generated values from various distributions.\n",
    "- `np.full`/`np.ones`/`np.zeros`: Create an array of a given shape with a constant value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating Arrays (cont'd)\n",
    "\n",
    "- `np.eye`/`np.identity`/`np.diag`: Arrays with values on the diagonal. Useful for linear algebra.\n",
    "- `np.load`/`np.save`: Load and save values from disk.\n",
    "- `pandas.read_csv`: Read values from a CSV. Returns a [`pandas.DataFrame`](https://pandas.pydata.org/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Reshaping Arrays\n",
    "\n",
    "Once we've created an array, the next step is often to **reshape** the array to have the dimensions we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(16)\n",
    "data.reshape(4, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Transpose\n",
    "\n",
    "A particularly common way to reshape arrays is to swap a pair of dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data:\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "data.T:\n",
      " [[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n"
     ]
    }
   ],
   "source": [
    "data = np.arange(12).reshape(3, 4)\n",
    "print(\"data:\\n\", data)\n",
    "print(\"data.T:\\n\", data.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Exercise  - Creating and Reshaping Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Numpy Toolbox - Universal Functions\n",
    "\n",
    "Universal functions (ufuncs) are functions that can be applied across one or more arrays of the same shape.\n",
    "\n",
    "They come in two main varieties:\n",
    "\n",
    "- **Unary UFuncs** apply a 1-argument function to every element of an array.\n",
    "- **Binary UFuncs** apply a 2-argument function to corresponding elements from two arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(1, 16).reshape(3, 5)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 1.41421356, 1.73205081, 2.        , 2.23606798],\n",
       "       [2.44948974, 2.64575131, 2.82842712, 3.        , 3.16227766],\n",
       "       [3.31662479, 3.46410162, 3.60555128, 3.74165739, 3.87298335]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unary functions.\n",
    "np.sqrt(data)\n",
    "#np.log(data)\n",
    "#np.sin(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6,  8, 10],\n",
       "       [12, 14, 16, 18, 20],\n",
       "       [22, 24, 26, 28, 30]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Binary operators.\n",
    "data + data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False,  True, False, False],\n",
       "       [ True, False, False,  True, False],\n",
       "       [False,  True, False, False,  True]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison operations\n",
    "(data % 3) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False],\n",
       "       [ True, False, False, False, False],\n",
       "       [False,  True, False, False, False]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean combinators.\n",
    "((data % 2) == 0) & ((data % 3) == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 55, 130, 205],\n",
       "       [130, 330, 530],\n",
       "       [205, 530, 855]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as of python 3.5, @ is matrix-multiply\n",
    "data @ data.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## UFunc Functions\n",
    "\n",
    "All binary operator ufuncs have a normal function version:\n",
    "\n",
    "- `+`,`-`,`*`,`/` are the same as `add`, `subtract`, `multiply`, `divide`\n",
    "- `&`, `|`, `^`, `~` are the same as `bitwise_and`, `bitwise_or`, `bitwise_xor`, `bitwise_not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Binary ufuncs are equipped with methods that implement common algorithms in terms of the ufunc.\n",
    "\n",
    "- `reduce` computes a summary by inserting the binary operator between each element.\n",
    "- `accumulate` is like `reduce`, but it outputs the intermediate values.\n",
    "- `outer` computes the binary operator on every pair of elements from two arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -5,   1,   2,  -2,  -1,   1],\n",
       "       [ -5,   5, -10,   6,  -9,   2],\n",
       "       [ -3,   3,  -4,   8,  -5,   8]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = (np.random.RandomState(1).randint(-10, 10, 18).reshape(3, 6))\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -5,   1,   2,  -2,  -1,   1],\n",
       "       [-10,   6,  -8,   4, -10,   3],\n",
       "       [-13,   9, -12,  12, -15,  11]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.accumulate(data, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# UFuncs Review\n",
    "\n",
    "- UFuncs provide efficient elementwise operations applied across one or more arrays.\n",
    "- Arithmetic Operators (`+`, `*`, `/`)\n",
    "- Comparisons (`==`, `>`, `!=`)\n",
    "- Boolean Operators (`&`, `|`, `^`)\n",
    "- Trigonometric Functions (`sin`, `cos`)\n",
    "- Transcendental Functions (`exp`, `log`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# UFuncs Review (cont'd)\n",
    "\n",
    "- UFunc Methods\n",
    "  - `reduce`\n",
    "  - `accumulate`\n",
    "  - `outer`\n",
    "  - `at` and `reduceat` (less common)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# UFunc Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Solving Problems with Numpy: Selections\n",
    "\n",
    "When working with numpy, we often find that we need to operate on only a subset of our data.\n",
    "\n",
    "Numpy arrays support the same set of rich slicing operations as Python lists, and they extend those semantics to support:\n",
    "\n",
    "1. Selection of multiple indices.\n",
    "2. Selection by boolean predicates.\n",
    "3. Multiple dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.34185385, 0.64251645, 0.86575984, 0.98468459,\n",
       "       0.98496101, 0.8665558 , 0.64373604, 0.34335012, 0.00159265])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sines = np.sin(np.linspace(0, 3.14, 10))\n",
    "cosines = np.cos(np.linspace(0, 3.14, 10))\n",
    "sines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing works with the same semantics as Python lists.\n",
    "sines[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.34185385, 0.64251645])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sines[:3]  # First three elements  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.98496101, 0.8665558 , 0.64373604, 0.34335012, 0.00159265])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sines[5:]  # Elements from 5 on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.64251645, 0.98468459, 0.8665558 , 0.34335012])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sines[::2]  # Every other element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sines:\n",
      " [0.         0.34185385 0.64251645 0.86575984 0.98468459 0.98496101\n",
      " 0.8665558  0.64373604 0.34335012 0.00159265]\n",
      "\n",
      "sines > 0.5:\n",
      " [False False  True  True  True  True  True  True False False]\n",
      "\n",
      "sines[sines > 0.5]:\n",
      " [0.64251645 0.86575984 0.98468459 0.98496101 0.8665558  0.64373604]\n"
     ]
    }
   ],
   "source": [
    "# More interesting: we can index with boolean arrays to filter by a predicate.\n",
    "print(\"sines:\\n\", sines)\n",
    "print(\"\\nsines > 0.5:\\n\", sines > 0.5)\n",
    "print(\"\\nsines[sines > 0.5]:\\n\", sines[sines > 0.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.34185385 0.64251645 0.86575984 0.98468459 0.98496101\n",
      " 0.8665558  0.64373604 0.34335012 0.00159265]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.98468459, 0.64373604])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We index with lists/arrays of integers to select values at those indices.\n",
    "print(sines)\n",
    "sines[[0, 4, 7]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Index arrays are often used for sorting one or more arrays.\n",
    "unsorted_data = np.array([1, 3, 2, 12, -1, 5, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 0, 2, 6, 1, 5, 3])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort_indices = np.argsort(unsorted_data)\n",
    "sort_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  1,  2,  2,  3,  5, 12])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unsorted_data[sort_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "prices = np.array([12, 6, 10, 5, 6])\n",
    "tickers = np.array(['A', 'B', 'C', 'D', 'E'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['D', 'B', 'E', 'C', 'A'], dtype='<U1')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort assets by price by using the permutation that would sort market caps on ``assets``.\n",
    "sorter = np.argsort(prices)\n",
    "tickers[sorter]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On multi-dimensional arrays, we can slice along each axis independently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(25).reshape(5, 5)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1]             # Get the second row.\n",
    "#data[:2, :2]       # Get the first two rows and first two columns.\n",
    "#data[:2, [0, -1]]  # Get the first two rows, first/last columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[(data[:, 0] % 2) == 0]  # Rows where the first column is divisible by two."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Another common way to \"select\" data is to use `np.where` as a vectorized if-statement.\n",
    "\n",
    "`np.where` takes three arguments: a boolean mask, an array of values to use for True locations, and an array of values to use for False locations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5.  , -3.75, -2.5 ],\n",
       "       [-1.25,  0.  ,  1.25],\n",
       "       [ 2.5 ,  3.75,  5.  ]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.linspace(-5, 5, 9).reshape(3, 3)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.  ,  3.75,  2.5 ],\n",
       "       [ 1.25, -0.  ,  1.25],\n",
       "       [ 2.5 ,  3.75,  5.  ]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can implement a simple abs() function by selecting the data when the data > 0, and -data otherwise.\n",
    "np.where(data > 0, data, -data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Selections Review\n",
    "\n",
    "- Basic slicing operations work on Numpy arrays the same way they do on lists.\n",
    "- Multidimensional arrays can apply selections independently along different axes.\n",
    "- Indexing with a scalar removes a dimension.\n",
    "- Indexing with slices, boolean arrays, index lists keep dimension unchanged.\n",
    "  - Slice selects across axis with same rules as Python list.\n",
    "  - Boolean array filters to coordinates where indexer is True.\n",
    "  - Index list selects each corresponding index.\n",
    "- `np.where` is like a vectorized if-statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Selections Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reductions\n",
    "\n",
    "Another common class of operations in numpy is to \"summarize\" our data along a particular axis.\n",
    "\n",
    "Examples of common \"summaries\" are:\n",
    "\n",
    "- Minimum/Maximum\n",
    "- Location of Minimum/Maximum (`argmin`/`argmax`)\n",
    "- Sum/Product\n",
    "- Statistical Moments (mean, variance, skew, kurtosis)\n",
    "\n",
    "When we have a multidimensional array, we "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$Var(X) = \\frac{1}{N}\\sum_{i=1}^N (x_i - \\bar{x})^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def variance(x):\n",
    "    return ((x - x.mean()) ** 2).sum() / len(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.912291315830511"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs = np.random.standard_normal(1000)\n",
    "variance(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.912291315830511"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- ...we can do more interesting things with multi-dimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(30).reshape(3, 10)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.5"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19.])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.5, 14.5, 24.5])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Reductions Review\n",
    "\n",
    "- Reductions allow us to perform efficient aggregations over arrays.\n",
    "- We can do aggregations over an entire array, or along a given axis.\n",
    "- There are many built-in reductions:\n",
    "  - `np.mean`\n",
    "  - `np.var`\n",
    "  - `np.median`\n",
    "  - `np.count_nonzero`\n",
    "  - `np.min`\n",
    "  - `np.max`\n",
    "  - ... many more in packages like `scipy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Reductions Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Broadcasting\n",
    "\n",
    "When working with multi-dimensional data, we often encounter situations where we have two \"compatible\" arrays of different dimensions, and we want to perform an operation on both arrays. NumPy's [broadcasting](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) system defines a set of rules that make this possible in a natural and intuitive way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Array Scalar Broadcasting\n",
    "\n",
    "We've already seen one example of broadcasting in action: combining arrays with scalars.\n",
    "\n",
    "Whenever you call a function that expects two arrays of the same shape, you can replace one of the arrays with a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "data = np.eye(3)\n",
    "print(data)\n",
    "#print(data * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Broadcasting with \"Smaller\" Arrays\n",
    "\n",
    "Another common pattern where broadcasting is useful occurs when you have an N-dimensional array, and a \"smaller\" array whose dimensions are a subset of the larger array. \n",
    "\n",
    "A common way to create such an array is to apply one of the reductions we saw earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 1, 3, 3, 0],\n",
       "       [1, 1, 1, 3, 2, 1],\n",
       "       [4, 3, 0, 2, 4, 4]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "data = rng.randint(-1, 5, (3, 6))\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data:\n",
      "[[2 3 1 3 3 0]\n",
      " [1 1 1 3 2 1]\n",
      " [4 3 0 2 4 4]]\n",
      "\n",
      "Mean:\n",
      "[2.33333333 2.33333333 0.66666667 2.66666667 3.         1.66666667]\n",
      "\n",
      "Data - Mean:\n",
      "[[-0.33333333  0.66666667  0.33333333  0.33333333  0.         -1.66666667]\n",
      " [-1.33333333 -1.33333333  0.33333333  0.33333333 -1.         -0.66666667]\n",
      " [ 1.66666667  0.66666667 -0.66666667 -0.66666667  1.          2.33333333]]\n"
     ]
    }
   ],
   "source": [
    "# Subtract the mean of each column the values in the column. \n",
    "# This is a common operation when fitting statistical models.\n",
    "print(\"Data:\\n\", data, sep='')\n",
    "print(\"\\nMean:\\n\", data.mean(axis=0), sep='')\n",
    "print(\"\\nData - Mean:\\n\", data - data.mean(axis=0), sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row:\n",
      "[1 2 3 4]\n",
      "Column:\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "row = np.array([1, 2, 3, 4])\n",
    "column = np.array([[1], [2], [3]])\n",
    "print(\"Row:\\n\", row, sep='')\n",
    "print(\"Column:\\n\", column, sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4, 5],\n",
       "       [3, 4, 5, 6],\n",
       "       [4, 5, 6, 7]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row + column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Broadcasting Rules\n",
    "\n",
    "Given arrays `x` and `y`:\n",
    "\n",
    "1. If either array has a smaller dimension, make the dimensions match by padding 1s to the shape of the smaller array.\n",
    "2. Iterate pairwise over the shapes of both arrays. At each coordinate:\n",
    "   - If the sizes of the arrays match, do nothing.\n",
    "   - If exactly one of the arrays has a dimension of size 1, make the dimensions match by \"tiling\" the smaller array along the current dimension.\n",
    "   - If the arrays have unequal dimensions and neither is equal to 1, raise an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Broadcasting Visualized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"images/broadcasting.png\" alt=\"Drawing\" style=\"width: 60%;\"/></center>\n",
    "\n",
    "<h5>Source: http://www.scipy-lectures.org/_images/numpy_broadcasting.png</h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Adding Extra Dimensions for Broadcasting\n",
    "\n",
    "Sometimes we have two one-dimensional arrays, and we want to combine them via broadcasting into a two-dimensional array.\n",
    "\n",
    "When that happens, we can use `np.newaxis` to insert extra dimensions of size into an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5. , -2.5,  0. ,  2.5,  5. ])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.linspace(-5, 5, 5)\n",
    "x\n",
    "#x[:, np.newaxis]\n",
    "#x + x[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Using `newaxis` often provides an easier alternative to `np.meshgrid` when doing 2D plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x shape: (100,) y shape: (100, 1) x + y shape (100, 100)\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(-5, 5, 100)\n",
    "y = x[:, np.newaxis]\n",
    "print(\"x shape:\", x.shape, \"y shape:\", y.shape, \"x + y shape\", (x + y).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.sin(x) + np.cos(y));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Broadcasting Review\n",
    "\n",
    "- Numpy operations can work on arrays of different dimensions as long as the arrays' shapes are still \"compatible\".\n",
    "- Broadcasting works by \"tiling\" the smaller array along the missing dimension.\n",
    "- The result of a broadcasted operation is always at least as large in each dimension as the largest array in that dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Broadcasting Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Peeking Under the Hood: Strided Memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from numpy.lib.stride_tricks import as_strided\n",
    "\n",
    "data = np.arange(12).reshape(3, 4)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "first_row = data[0]\n",
    "#first_row[0] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "===========\n",
      "DType: int64\n",
      "Shape: (3, 4)\n",
      "Strides: (32, 8)\n",
      "Data: b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x03\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x06\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x07\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x08\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n"
     ]
    }
   ],
   "source": [
    "print(data)\n",
    "print(\"===========\")\n",
    "print(\"DType:\", data.dtype)\n",
    "print(\"Shape:\", data.shape)\n",
    "print(\"Strides:\", data.strides)\n",
    "print(\"Data:\", data.data.tobytes())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Numerical algorithms are slow in pure Python because the overhead of interpretation and dynamic dispatch dominates our runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Numpy solves this problem by:\n",
    "  1. Imposing additional restrictions on the contents of arrays.\n",
    "  2. Moving the inner loops of our algorithms into compiled C code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Using Numpy effectively requires reworking an algorithms to use vectorized operations instead of for-loops, but the resulting solutions are often shorert, clearer, and faster than the pure Python equivalent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Review (cont'd)\n",
    "\n",
    "**UFuncs**, **Selections**, **Reductions** are your core toolbox for construction algorithms with NumPy. \n",
    "\n",
    "**Broadcasting** allows you to naturally generalize algorithms over multiple dimensions. \n",
    "\n",
    "**Strided Memory** is an efficient and flexible underlying representation for arrays, but it can cause confusion when arrays are updated in place."
   ]
  }
 ],
 "metadata": {
  "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.5.2"
  },
  "livereveal": {
   "start_slideshow_at": "selected"
  },
  "name": "Main.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}