numba.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:58:34.458150Z",
     "start_time": "2023-06-29T17:58:34.453193Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Why do we use Python?\n",
    "\n",
    "+ Readability and simplicity\n",
    "+ Rapid development and protyping\n",
    "+ Rich ecosystem of libraries and frameworks\n",
    "+ Large and helpful community\n",
    "\n",
    "### What are we missing?\n",
    "\n",
    "+ Speed?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Cython](figures/Numba-Logo-Blog.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numba"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " You have some code... you want to make it run fast "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How Numba works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:59:47.747360Z",
     "start_time": "2023-06-29T17:59:47.741466Z"
    }
   },
   "outputs": [],
   "source": [
    "def integrate(a, b, n):\n",
    "    s = 0.0\n",
    "    dx = (b - a) / n\n",
    "    for i in range(n):\n",
    "        x = a + (i + 0.5) * dx\n",
    "        y = x ** 4 - 3 * x\n",
    "        s += y * dx\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:00:16.431958Z",
     "start_time": "2023-06-29T18:00:16.425824Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "b = 2\n",
    "n = 1_000_000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:00:19.631024Z",
     "start_time": "2023-06-29T18:00:16.776799Z"
    }
   },
   "outputs": [],
   "source": [
    "# Measure execution time\n",
    "\n",
    "plaintime = %timeit -o integrate(a, b, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:00:23.087734Z",
     "start_time": "2023-06-29T18:00:23.081506Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#Add Numba decorator here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:59:55.946936Z",
     "start_time": "2023-06-29T17:59:55.555772Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# First thing: test correctness\n",
    "\n",
    "np.testing.assert_almost_equal(integrate(a, b, n), integrate_numba(a, b, n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:00:23.087734Z",
     "start_time": "2023-06-29T18:00:23.081506Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Redo definition\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:00:23.819795Z",
     "start_time": "2023-06-29T18:00:23.552980Z"
    }
   },
   "outputs": [],
   "source": [
    "# Measure execution time\n",
    "\n",
    "jittedtime = %timeit -o -r 1 -n 1 integrate_numba(a, b, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:59:55.963343Z",
     "start_time": "2023-06-29T17:59:55.950152Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "plaintime.best / jittedtime.best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test timing again\n",
    "\n",
    "jittedtime = %timeit -o integrate_numba(a, b, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:59:55.963343Z",
     "start_time": "2023-06-29T17:59:55.950152Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "plaintime.best / jittedtime.best"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<font size = 6>Why is there a slow run? </font>\n",
    "\n",
    "Numba has to compile your function for the argument types given before it executes the machine code version of your function. This takes time. \n",
    "\n",
    "However, once the compilation has taken place Numba caches the machine code version of your function for the particular types of datatypes presented. \n",
    "\n",
    "If it is called again, it can reuse the cached version, if it sees the same datatypes, instead of having to compile again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate_numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define function again to start with a clean slate\n",
    "\n",
    "@numba.njit\n",
    "def numba_integrate(a, b, n):\n",
    "    s = 0.0\n",
    "    dx = (b - a) / n\n",
    "    for i in range(n):\n",
    "        x = a + (i + 0.5) * dx\n",
    "        y = x ** 4 - 3 * x\n",
    "        s += y * dx\n",
    "    return s \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:01:10.031279Z",
     "start_time": "2023-06-29T18:01:10.024157Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "numba_integrate.signatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numba_integrate(0, 2, 1_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numba_integrate.signatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:01:14.719680Z",
     "start_time": "2023-06-29T18:01:14.703708Z"
    }
   },
   "outputs": [],
   "source": [
    "numba_integrate(0.0j, 2.0j, 1_000_000.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numba_integrate.signatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T18:01:08.142000Z",
     "start_time": "2023-06-29T18:01:07.600523Z"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@numba.njit\n",
    "def numba_integrate(a, b, n):\n",
    "    s = 0.0\n",
    "    dx = (b - a) / n\n",
    "    for i in range(n):\n",
    "        x = a + (i + 0.5) * dx\n",
    "        y = x ** 4 - 3 * x\n",
    "        s += y * dx\n",
    "    return s          \n",
    "\n",
    "# COMPILATION TIME!\n",
    "start = time.perf_counter()\n",
    "numba_integrate(a, b, n)\n",
    "end = time.perf_counter()\n",
    "print(f\"Elapsed (with compilation) = {end - start:.4f} s\")\n",
    "\n",
    "# NOW THE FUNCTION IS COMPILED, RE-TIME IT EXECUTING FROM CACHE\n",
    "for i in range(5):\n",
    "    start = time.perf_counter()\n",
    "    numba_integrate(a, b, n)\n",
    "    end = time.perf_counter()\n",
    "    print(f\"Elapsed (cached)           = {end - start:.4f} s\")\n",
    "\n",
    "# Original function\n",
    "start = time.perf_counter()\n",
    "numba_integrate.py_func(a, b, n)\n",
    "end = time.perf_counter()\n",
    "print(f\"Elapsed (python code)      = {end - start:.4f} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<font size=8> **Hands on exercise** <font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function ```estimate_pi``` calculates the value of $pi$\n",
    "\n",
    "Notice that the greater the value of n, the better is the estimate of $pi$\n",
    "\n",
    "You task is to:\n",
    "+ Use time or timeit to benchmark the speed up in execution of the function for different *n* with and without numba\n",
    "+ Plot the difference in time for different *n* with and without numba\n",
    "+ Take a photo of the screen with the plot and post it to the telegram group\n",
    "\n",
    "**(Ensure that the numba function is compiled before timing the function)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:54:24.101663Z",
     "start_time": "2023-06-29T17:54:24.074656Z"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# This function takes n as input which is the number of total points within the square\n",
    "# It then estimates how many of those points are within the circle\n",
    "# value of pi = 4 * numberofpointsincircle/numberofpointsinsquare\n",
    "\n",
    "def estimate_pi(n):\n",
    "    np.random.seed(1234)\n",
    "    count_inside_circle = 0\n",
    "    for _ in range(n): # Numba likes loops and numpy functions\n",
    "        x, y  = [np.random.uniform(-1, 1),\n",
    "                 np.random.uniform(-1, 1)]\n",
    "        \n",
    "        if x**2 + y**2 <= 1:\n",
    "            count_inside_circle += 1\n",
    "    \n",
    "    pi_estimate = 4 * count_inside_circle / n #Numba likes math\n",
    "    return pi_estimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:54:38.680486Z",
     "start_time": "2023-06-29T17:54:24.109212Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "n = [1, 10, 1000, 10000, 100_000, 1_000_000]\n",
    "for i in n:\n",
    "    pi_estimate = estimate_pi(i)\n",
    "    print(f'Number of runs {i}, Estimated \\N{GREEK CAPITAL LETTER PI}: {pi_estimate:0.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit estimate_pi(1_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:54:54.086704Z",
     "start_time": "2023-06-29T17:54:54.081905Z"
    }
   },
   "outputs": [],
   "source": [
    "## Your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-29T17:54:38.680486Z",
     "start_time": "2023-06-29T17:54:24.109212Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "n = [1, 10, 1000, 10000, 100_000, 1_000_000]\n",
    "for i in n:\n",
    "    pi_estimate = estimate_pi(i)\n",
    "    print(f'Number of runs {i}, Estimated \\N{GREEK CAPITAL LETTER PI}: {pi_estimate:0.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit estimate_pi(1_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One possible solution: %load 0-numba-pi/solution.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What can you use numba on?\n",
    "\n",
    "If your code is numerically orientated (does a lot of math), uses NumPy a lot and/or has a lot of loops, then Numba is often a good choice.\n",
    "\n",
    "* Functions with loops\n",
    "* Functions with arithmetic operations\n",
    "* Functions with logical operations\n",
    "* Functions using numpy\n",
    "* njit-ed functions calling other njit-ed funtions\n",
    "\n",
    "***OK***: tuples, strings\n",
    "\n",
    "***Not good***: objects, Python lists, python dicts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> @njit stands for @jit(nopython=True) and it means that numba should throw an exception instead of falling back to the python version, in cases where it cannot generate the optimized version."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What does numba *not* do? : Choose wisely!\n",
    "* Magically make individual numpy functions faster, or speed up code that just has nice array operations\n",
    "* Convert arbitrary python data types\n",
    "* Translate entire programs\n",
    "* Compile third party libraries\n",
    "* Numba cannot help speed up programs that are not CPU-bound"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Compiled code vs Interpreted Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/program_life_python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/program_life.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/program_life_compiler.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/program_with_dll.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  },
  "rise": {
   "scroll": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}