EXTRA8_Numba_CUDA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1scb_lxG2iIg"
   },
   "source": [
    "# Introduction CUDA (python) with Numba\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "go4UrRwduSRN"
   },
   "source": [
    "Welcome to this notebook about Numba !!\n",
    "\n",
    "Numba is a Python compiler, specifically for numerical functions and allows you to accelerate your applications with high performance functions written directly in Python.\n",
    "\n",
    "Numba generates machine code optimized from pure Python code using LLVM. With a couple of simple changes, our Python code (function-oriented) can be optimized \"just-in-time\" to obtain a performance similar to that of C, C ++, without having to change the language.\n",
    "\n",
    "## What is Numba?\n",
    "Numba is a compiler that allows you to accelerate Python code (numerical functions) for both CPU and GPU:\n",
    "\n",
    "1. **Function Compiler:** Numba compiles Python functions, not whole applications or parts of it. Basically, Numba is another Python module to improve the performance of our functions.\n",
    "\n",
    "2. **Just-in-time:** (Dynamic translation) Numba translates the bytecode (intermediate code more abstract than the machine code) to machine code immediately before its execution to improve the execution speed.\n",
    "\n",
    "3. **Numerically-focused:** Numba is focused on numerical data, such as `int`, `float`, `complex`. For now, there are limitations to use it with string data.\n",
    "\n",
    "Numba is not the only way to program in CUDA, it is usually programmed in C / C ++ directly for it. But Numba allows you to program directly in Python and optimize it for both CPU and GPU with few changes in our code. In relation to Python, there are other alternatives such as pyCUDA, here is a comparison between them:\n",
    "\n",
    "\n",
    "**CUDA C/C++:**\n",
    "1. It is the most common and flexible way to program in CUDA\n",
    "2. Accelerate applications in C, C ++.\n",
    "\n",
    "**pyCUDA**\n",
    "1. It is the most efficient CUDA form for Python\n",
    "2. It requires programming C in our Python code and, in general, many code modifications.\n",
    "\n",
    "<img src=\"https://images.slideplayer.com/16/5007566/slides/slide_50.jpg\" alt=\"drawing\" width=\"500\"/>\n",
    "\n",
    "**Numba**\n",
    "1. Less efficient than pyCUDA\n",
    "2. It allows you to write your code in Python and optimize it with few modifications\n",
    "3. It also optimizes the Python code for CPU\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nRMa0IN521Zp"
   },
   "source": [
    "## Goals\n",
    "\n",
    "The objectives of this talk are the following:\n",
    "* Use Numba to compile functions on the CPU\n",
    "* Understand how Numba works\n",
    "* Accelerate Numpy ufuncs in GPU\n",
    "* Write Kernels using Numba (Next Webinar)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AyeMg7YtKzOO"
   },
   "outputs": [],
   "source": [
    "import numba\n",
    "from numba import jit\n",
    "import numpy as np\n",
    "import math\n",
    "import random\n",
    "\n",
    "random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RArZFg9hLOEu"
   },
   "source": [
    "# First steps: Compile for the CPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4UENgZmvwBYt"
   },
   "source": [
    "Numba, apart from being able to speed up the functions in the GPU, can be used to optimize functions in the CPU. To do this, Python decorators (function modifiers) are used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "H8qzc9bXLFac"
   },
   "outputs": [],
   "source": [
    "@jit\n",
    "def hypot(x, y):\n",
    "  return math.sqrt(x*x + y*y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ByJY3cjaLnD8"
   },
   "source": [
    "Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C5FejWESLRZY",
    "outputId": "508478fe-cf92-4ac5-8aac-a0e25ee6a2fe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numba function\n",
    "hypot(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pulEHjdHMBOl"
   },
   "source": [
    "Numba saves the original implementation of the function in `.py_func`, we can execute it and see the response times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PTp1koUELn_x",
    "outputId": "336398db-2988-4e08-e6d7-96bbc28e5c23"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python function\n",
    "hypot.py_func(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iumy4ssVMNRW"
   },
   "source": [
    "#### Benchmarking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "en07FhWYMVaI"
   },
   "source": [
    "Naturally, it is important to measure the performance of our code, check if Numba really works well and observe the difference between Python implementation and Numba implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lxvY52gOMIOv",
    "outputId": "5ffedca3-c1c7-4733-83ca-9b9ae952490b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 32.16 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "1000000 loops, best of 3: 204 ns per loop\n"
     ]
    }
   ],
   "source": [
    "# Python function\n",
    "%timeit hypot.py_func(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Hi4GrMjZMQcM",
    "outputId": "b6751d7d-1aa8-47e7-818c-b49c929b79e0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 23.99 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "1000000 loops, best of 3: 197 ns per loop\n"
     ]
    }
   ],
   "source": [
    "# Numba function\n",
    "%timeit hypot(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cam4dsk-Q2rm"
   },
   "source": [
    "The library `math` already includes the `hypot` function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9IETitbFP2RY",
    "outputId": "27fbe845-d177-4e8e-e98d-f5241d07b03a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 106.52 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "10000000 loops, best of 3: 109 ns per loop\n"
     ]
    }
   ],
   "source": [
    "# math function\n",
    "%timeit math.hypot(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4Fx0XS4-RyA-"
   },
   "source": [
    "The `math.hypot` function is even faster than Numba!! This is because Numba introduces a certain overhead to each function call, which is larger than the Python function call overhead, very fast functions (like the previous one) will be affected by this.\n",
    "\n",
    "(However, if you call a Numba function from another, there is very little overhead, sometimes even zero if the compiler integrates the function into the other. In short, check if the functions are really accelerating with Numba).\n",
    "\n",
    "https://numba.pydata.org/numba-doc/dev/user/performance-tips.html#performance-tips\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xIS7wkemc2iW"
   },
   "source": [
    "### Numba Specialization by Dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D-cYYpQKdbiY"
   },
   "source": [
    "This function clamps values to zero if they are below a particular threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "j7jYdx2tc2EP"
   },
   "outputs": [],
   "source": [
    "@jit(nopython=True)\n",
    "def zero_th(x, th):\n",
    "    # Create array copy\n",
    "    out = np.empty_like(x)\n",
    "    for i in range(out.shape[0]):\n",
    "        if np.abs(x[i]) > th:\n",
    "            out[i] = x[i]\n",
    "        else:\n",
    "            out[i] = 0\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "igKG2XmodxH1",
    "outputId": "9c7ba963-7d4f-4153-a9b9-213fe49bd4b0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      " [0.         0.02040816 0.04081633 0.06122449 0.08163265 0.10204082\n",
      " 0.12244898 0.14285714 0.16326531 0.18367347 0.20408163 0.2244898\n",
      " 0.24489796 0.26530612 0.28571429 0.30612245 0.32653061 0.34693878\n",
      " 0.36734694 0.3877551  0.40816327 0.42857143 0.44897959 0.46938776\n",
      " 0.48979592 0.51020408 0.53061224 0.55102041 0.57142857 0.59183673\n",
      " 0.6122449  0.63265306 0.65306122 0.67346939 0.69387755 0.71428571\n",
      " 0.73469388 0.75510204 0.7755102  0.79591837 0.81632653 0.83673469\n",
      " 0.85714286 0.87755102 0.89795918 0.91836735 0.93877551 0.95918367\n",
      " 0.97959184 1.        ]\n",
      "\n",
      "Result: \n",
      " [0.         0.         0.         0.         0.         0.\n",
      " 0.         0.         0.         0.         0.         0.\n",
      " 0.         0.         0.         0.30612245 0.32653061 0.34693878\n",
      " 0.36734694 0.3877551  0.40816327 0.42857143 0.44897959 0.46938776\n",
      " 0.48979592 0.51020408 0.53061224 0.55102041 0.57142857 0.59183673\n",
      " 0.6122449  0.63265306 0.65306122 0.67346939 0.69387755 0.71428571\n",
      " 0.73469388 0.75510204 0.7755102  0.79591837 0.81632653 0.83673469\n",
      " 0.85714286 0.87755102 0.89795918 0.91836735 0.93877551 0.95918367\n",
      " 0.97959184 1.        ]\n"
     ]
    }
   ],
   "source": [
    "array = np.linspace(0, 1, 50)\n",
    "res = zero_th(array, 0.3)\n",
    "\n",
    "print(\"Original: \\n\", array)\n",
    "print(\"\\nResult: \\n\", res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aOAJQORJeW_O"
   },
   "source": [
    "Now let's benchmark some different kinds of array inputs:\n",
    "\n",
    "\n",
    "*   int64\n",
    "*   float32\n",
    "*   float32 with a stride (elements not contiguous in memory)\n",
    "\n",
    "\n",
    "#### Wait...One second...Contiguous in memory?\n",
    "Consider the 2D array `arr = np.arange(12).reshape(3,4)`.\n",
    "\n",
    "<img src=\"https://drive.google.com/uc?id=1r1elV7-GqxG2x5L1sTdDrp9-aU-zHvNS\" width=\"120\">\n",
    "\n",
    "In the computer's memory, the values of `arr` are stored like this (contiguous):\n",
    "\n",
    "<img src=\"https://drive.google.com/uc?id=1ZPzwP1zlOzbiRP9QK1VndDRDYX72UAw-\" width=\"300\">\n",
    "\n",
    "For this reason, row-wise operations are usually faster than column-wise operations:\n",
    "\n",
    "```\n",
    "np.sum(arr, axis=1) # sum the rows\n",
    "```\n",
    "is slightly faster than:\n",
    "```\n",
    " np.sum(arr, axis=0) # sum the columns\n",
    "```\n",
    "\n",
    "Take a look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HZY_aTIKnzi2",
    "outputId": "b2a2b966-a908-48c8-ac5d-92d9be732bac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 34.81 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 4.04 µs per loop\n",
      "The slowest run took 9.26 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 4.09 µs per loop\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(12).reshape(3,4)\n",
    "%timeit np.sum(arr, axis=1)\n",
    "%timeit np.sum(arr, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ClssV16Fn2Nb"
   },
   "source": [
    "In order to get a NON-contiguous array, we have to transpose the rows  `arr.T`:\n",
    "\n",
    "<img src=\"https://drive.google.com/uc?id=1WMjUkus3HkyomYY7Spu8lGyAktww7mAB\" width=\"120\">\n",
    "\n",
    "In the computer's memory, the values of `arr.T` are stored like this (no-contiguous):\n",
    "\n",
    "<img src=\"https://drive.google.com/uc?id=1E4qt7IdUoujzuVtDbdXICMeEw8aDA0hv\" width=\"300\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cQAjo9CleWf0"
   },
   "outputs": [],
   "source": [
    "# Create 3 arrays\n",
    "n = 10000\n",
    "\n",
    "# int16\n",
    "a_int16 = np.arange(n).astype(np.int16)\n",
    "# float32\n",
    "a_float32 = np.linspace(0, 1, n, dtype=np.float32)\n",
    "# float32\n",
    "a_float32_strided = np.linspace(0, 1, 2*n, dtype=np.float32)[::2]  # The transpose of 1d array is the same array, we take the even numbers to create the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RS1Fr-XAoVam",
    "outputId": "634b0cde-4777-4c02-d2b1-a1252f2809f8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 21623.95 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 5.76 µs per loop\n",
      "The slowest run took 22669.18 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 5.26 µs per loop\n",
      "The slowest run took 7433.10 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 12.7 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit zero_th(a_int16, 1600)\n",
    "%timeit zero_th(a_float32, 0.3)\n",
    "%timeit zero_th(a_float32_strided, 0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_i_LS-D0lxyP",
    "outputId": "b7a4eb2a-2303-42a3-d359-288d7124a1d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(a_float32_strided.flags['C_CONTIGUOUS'])\n",
    "\n",
    "# Convert into Contiguous\n",
    "a_float32_strided_cont = np.ascontiguousarray(a_float32_strided, dtype=np.float32)\n",
    "print(a_float32_strided_cont.flags['C_CONTIGUOUS'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2GMSCgPxohql"
   },
   "source": [
    "Benchmarking: A pure NumPy implementation - Numba has achieved a speed improvement through a combination of specialization and elimination of temporary arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2mT9wljDod_i"
   },
   "outputs": [],
   "source": [
    "def np_zero_th(x, th):\n",
    "    return np.where(np.abs(x) > th, x, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "53cjovV5ofv4",
    "outputId": "0f957bcf-86cb-45cb-f5d8-e3cbd0fa7157"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 166.49 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "10000 loops, best of 3: 21.4 µs per loop\n",
      "The slowest run took 41.32 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 17.1 µs per loop\n",
      "The slowest run took 19.36 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "10000 loops, best of 3: 33.5 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit np_zero_th(a_int16, 1600)\n",
    "%timeit np_zero_th(a_float32, 0.3)\n",
    "%timeit np_zero_th(a_float32_strided, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YUggI3DFRcZw"
   },
   "source": [
    "## How does Numba work?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xOTX9QBqRq1s"
   },
   "source": [
    "When we initialize the `hypot` or the `zero_th` function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pJ77D2_NR_lb"
   },
   "source": [
    "![Image of Yaktocat](https://github.com/ContinuumIO/gtc2018-numba/raw/99e73d72b5c05e0d469b1e08574ea97d8ceb0800/img/numba_flowchart.png)\n",
    "\n",
    "__IR__ Intermediate Representations\n",
    "\n",
    "__Bytecode Analysis__ Intermediate code more abstract than machine code\n",
    "\n",
    "__LLVM__ Low Level Virtual Machine, infrastructure to develop compilers\n",
    "\n",
    "__NVVM__ It is an IR compiler based on LLVM, it is designed to represent GPU kernels\n",
    "\n",
    "![Image of Yaktocat](https://media.giphy.com/media/3oKIPxVeeVSRDdZqSY/giphy.gif)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3jyU_kUISZGc"
   },
   "source": [
    "We can inspect the process for the `hypot` using `.inspect_types ()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mwMCVe2ZHxgC"
   },
   "source": [
    "Each line of python is preceded by several lines of **Numba IR code**. The most useful is to see the type annotations that show us how Numba treats the variables, for example, in \"pyobject\" it is indicating that Numba does not know the `np.sin` function and that he should call it from Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FT4xNrZmKw81",
    "outputId": "850f3f77-7c60-4a4f-f99e-ce2bf26859c0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo_np (int64,)\n",
      "--------------------------------------------------------------------------------\n",
      "# File: <ipython-input-21-02574ac7ba04>\n",
      "# --- LINE 1 --- \n",
      "\n",
      "@jit\n",
      "\n",
      "# --- LINE 2 --- \n",
      "\n",
      "def foo_np(x):\n",
      "\n",
      "  # --- LINE 3 --- \n",
      "  # label 0\n",
      "  #   x = arg(0, name=x)  :: int64\n",
      "  #   $0.1 = global(np: <module 'numpy' from '/usr/local/lib/python3.6/dist-packages/numpy/__init__.py'>)  :: Module(<module 'numpy' from '/usr/local/lib/python3.6/dist-packages/numpy/__init__.py'>)\n",
      "  #   $0.2 = getattr(value=$0.1, attr=sin)  :: Function(<ufunc 'sin'>)\n",
      "  #   del $0.1\n",
      "  #   $0.4 = call $0.2(x, func=$0.2, args=[Var(x, <ipython-input-21-02574ac7ba04>:3)], kws=(), vararg=None)  :: (int64,) -> float64\n",
      "  #   del x\n",
      "  #   del $0.2\n",
      "  #   $0.5 = cast(value=$0.4)  :: float64\n",
      "  #   del $0.4\n",
      "  #   return $0.5\n",
      "\n",
      "  return np.sin(x)\n",
      "\n",
      "\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "@jit\n",
    "def foo_np(x):\n",
    "  return np.sin(x)\n",
    "\n",
    "foo_np(2)\n",
    "foo_np.inspect_types()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oEeX8HcBUl8e"
   },
   "source": [
    "#### Example: Creating fractals\n",
    "\n",
    "In simpler words, a fractal is a never-ending pattern. Fractals are infinitely complex patterns that are self-similar across different scales. They are created by repeating a simple process over and over in an ongoing feedback loop.\n",
    "\n",
    "With the following iterative method:\n",
    "\n",
    ">$z_{n+1} = z_{n} + c$\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/2/21/Mandel_zoom_00_mandelbrot_set.jpg\" height=220>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 304
    },
    "id": "eCk6YwGhSq0E",
    "outputId": "1cd70b8e-0b82-48a9-d9f3-e3f5d3235952"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loop, best of 3: 4.57 s per loop\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3d8ab057f0>"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Without Numba\n",
    "from matplotlib.pylab import imshow, ion\n",
    "\n",
    "def mandel(x, y, max_iters):\n",
    "    i = 0\n",
    "    c = complex(x,y)\n",
    "    z = 0.0j\n",
    "    for i in range(max_iters):\n",
    "        z = z*z + c\n",
    "        if (z.real*z.real + z.imag*z.imag) >= 4:\n",
    "            return i\n",
    "\n",
    "    return 255\n",
    "\n",
    "def create_fractal(min_x, max_x, min_y, max_y, image, iters):\n",
    "    height = image.shape[0]\n",
    "    width = image.shape[1]\n",
    "\n",
    "    pixel_size_x = (max_x - min_x) / width\n",
    "    pixel_size_y = (max_y - min_y) / height\n",
    "    for x in range(width):\n",
    "        real = min_x + x * pixel_size_x\n",
    "        for y in range(height):\n",
    "            imag = min_y + y * pixel_size_y\n",
    "            color = mandel(real, imag, iters)\n",
    "            image[y, x] = color\n",
    "\n",
    "    return image\n",
    "\n",
    "image = np.zeros((500 * 2, 750 * 2), dtype=np.uint8)\n",
    "%timeit create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)\n",
    "img = create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)\n",
    "imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 321
    },
    "id": "mi4mtpQAU-EW",
    "outputId": "3c2e7b26-95bf-41c2-9e2d-383dd2ae9ca8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 4.61 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "1 loop, best of 3: 57.1 ms per loop\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3d8a55a588>"
      ]
     },
     "execution_count": 23,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# With Numba\n",
    "from matplotlib.pylab import imshow, ion\n",
    "\n",
    "@jit\n",
    "def mandel(x, y, max_iters):\n",
    "    \"\"\"\n",
    "    Given the real and imaginary parts of a complex number,\n",
    "    determine if it is a candidate for membership in the Mandelbrot\n",
    "    set given a fixed number of iterations.\n",
    "    \"\"\"\n",
    "    i = 0\n",
    "    c = complex(x,y)\n",
    "    z = 0.0j\n",
    "    for i in range(max_iters):\n",
    "        z = z*z + c\n",
    "        if (z.real*z.real + z.imag*z.imag) >= 4:\n",
    "            return i\n",
    "\n",
    "    return 255\n",
    "\n",
    "@jit\n",
    "def create_fractal(min_x, max_x, min_y, max_y, image, iters):\n",
    "    height = image.shape[0]\n",
    "    width = image.shape[1]\n",
    "\n",
    "    pixel_size_x = (max_x - min_x) / width\n",
    "    pixel_size_y = (max_y - min_y) / height\n",
    "    for x in range(width):\n",
    "        real = min_x + x * pixel_size_x\n",
    "        for y in range(height):\n",
    "            imag = min_y + y * pixel_size_y\n",
    "            color = mandel(real, imag, iters)\n",
    "            image[y, x] = color\n",
    "\n",
    "    return image\n",
    "\n",
    "image = np.zeros((500 * 2, 750 * 2), dtype=np.uint8)\n",
    "%timeit create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)\n",
    "img = create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)\n",
    "imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hTk_5CSnAaXx"
   },
   "source": [
    "#### Example: Montecarlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pCu6yi_7AZLE"
   },
   "outputs": [],
   "source": [
    "import matplotlib.patches as patches\n",
    "import matplotlib.pyplot as plt\n",
    "from random import randint\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "vwwRc0AMAv9N",
    "outputId": "4ae26c0f-bfdd-4226-db96-02996bbc0a9d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-5.0, 45.0)"
      ]
     },
     "execution_count": 25,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rad = 20\n",
    "center = (rad, rad)\n",
    "\n",
    "width = rad*2\n",
    "height = rad*2\n",
    "lims = (-5, 45)\n",
    "\n",
    "\n",
    "fig1 = plt.figure(figsize=(8, 6), dpi=80)\n",
    "ax1 = fig1.add_subplot(111, aspect='equal')\n",
    "ax1.add_patch(\n",
    "    patches.Rectangle((0,0), width, height, edgecolor ='green', linewidth = 3,\n",
    "                      fill=False))\n",
    "ax1.add_patch(\n",
    "    patches.Circle(center, rad, color = 'skyblue', fill=True))\n",
    "plt.ylim(lims)\n",
    "plt.xlim(lims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "gCVcL2F10Y0Y",
    "outputId": "d5cd6942-91fc-4577-9d07-4a1202df3a09"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f3d8a4839b0>]"
      ]
     },
     "execution_count": 26,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "x = random.randrange(rad*2)\n",
    "y = random.randrange(rad*2)\n",
    "\n",
    "fig1 = plt.figure(figsize=(8, 6), dpi=80)\n",
    "ax1 = fig1.add_subplot(111, aspect='equal')\n",
    "ax1.add_patch(\n",
    "    patches.Rectangle((0,0), width, height, edgecolor ='green', linewidth = 3,\n",
    "                      fill=False))\n",
    "ax1.add_patch(\n",
    "    patches.Circle(center, rad, color = 'skyblue', fill=True))\n",
    "plt.ylim(lims)\n",
    "plt.xlim(lims)\n",
    "plt.plot(x, y, 'o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Gs-AGDlpA1sy",
    "outputId": "683ec31d-ec28-4766-fd7a-6e87d56ce460"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loop, best of 3: 2.44 s per loop\n",
      "Inside points:  89999075\n"
     ]
    }
   ],
   "source": [
    "iterations = 100000000\n",
    "\n",
    "# Device function\n",
    "@jit\n",
    "def iteration():\n",
    "  inside = 0\n",
    "\n",
    "  for _ in range(iterations):\n",
    "    x = random.randrange(rad*2)\n",
    "    y = random.randrange(rad*2)\n",
    "\n",
    "    b = (x - center[0])^2 + (y - center[1])^2 < rad^2\n",
    "\n",
    "    if b:\n",
    "      inside += 1\n",
    "  return inside\n",
    "\n",
    "%timeit iteration()\n",
    "pt_inside = iteration()\n",
    "\n",
    "print('Inside points: ', pt_inside)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AYVGSiDQB5vq"
   },
   "source": [
    "Without Numba:\n",
    "\n",
    "  - iterations = 100000000 -> 175 sg\n",
    "\n",
    "\"Montecarlo in Cuda\" -> https://gist.github.com/akiross/17e722c5bea92bd2c310324eac643df6\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZBxfyk-wBsmE",
    "outputId": "187591c8-0e72-4cbd-ef97-6560a3760fd4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside points:  89999075\n",
      "Outside points:  10000925\n"
     ]
    }
   ],
   "source": [
    "print('Inside points: ', pt_inside)\n",
    "print('Outside points: ', iterations - pt_inside)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pQKdOgt1Buyr"
   },
   "source": [
    "$$SuperficieCuadrado = 4  \\cdot r ^ 2$$\n",
    "\n",
    "$$SuperficieCírculo = \\pi \\cdot r ^ 2$$\n",
    "\n",
    "$$\\frac{SuperficieCirculo}{SuperficieCuadrado}=\\frac{\\pi}{4}$$\n",
    "\n",
    "Therefore, if we have done 100 iterations and 70 are within the circle, we can approximate the value of $ \\pi $ using the following relationship:\n",
    "\n",
    "$$\\frac{70 }{100}=\\frac{\\pi}{4} \\rightarrow  \\pi = 4 \\cdot \\frac{70}{100} \\approx 2.8\t$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VErvVLelBxja",
    "outputId": "9d5a630c-374a-4242-8c80-95cc3e6a8f07"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.599963\n"
     ]
    }
   ],
   "source": [
    "pi_value = 4 * pt_inside / iterations\n",
    "print(pi_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m-qM3QzWWEgT"
   },
   "source": [
    "## Errors  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h1W1fitbWbaN"
   },
   "source": [
    "We have said that Numba only works for numeric functions, although Numba compiles and runs any Python code, there are some types of data that it cannot compile yet (such as dictionaries) and it also makes no sense to compile them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "it63OfaL7ZS-",
    "outputId": "535f3750-b1a9-4b68-eb09-dd7e7a249415"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Res 245\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-30-f88e7b585a51>:1: NumbaWarning: \n",
      "Compilation is falling back to object mode WITH looplifting enabled because Function \"dictionary\" failed type inference due to: non-precise type pyobject\n",
      "[1] During: typing of argument at <ipython-input-30-f88e7b585a51> (3)\n",
      "\n",
      "File \"<ipython-input-30-f88e7b585a51>\", line 3:\n",
      "def dictionary(dict_test):\n",
      "  return dict_test['house']\n",
      "  ^\n",
      "\n",
      "  @jit\n",
      "/usr/local/lib/python3.6/dist-packages/numba/object_mode_passes.py:178: NumbaWarning: Function \"dictionary\" was compiled in object mode without forceobj=True.\n",
      "\n",
      "File \"<ipython-input-30-f88e7b585a51>\", line 2:\n",
      "@jit\n",
      "def dictionary(dict_test):\n",
      "^\n",
      "\n",
      "  state.func_ir.loc))\n",
      "/usr/local/lib/python3.6/dist-packages/numba/object_mode_passes.py:188: NumbaDeprecationWarning: \n",
      "Fall-back from the nopython compilation path to the object mode compilation path has been detected, this is deprecated behaviour.\n",
      "\n",
      "For more information visit http://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit\n",
      "\n",
      "File \"<ipython-input-30-f88e7b585a51>\", line 2:\n",
      "@jit\n",
      "def dictionary(dict_test):\n",
      "^\n",
      "\n",
      "  state.func_ir.loc))\n"
     ]
    }
   ],
   "source": [
    "@jit\n",
    "def dictionary(dict_test):\n",
    "  return dict_test['house']\n",
    "\n",
    "res = dictionary({'house': 245, 'car': 350})\n",
    "print(\"Res\", res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ohbDlv4Jf044"
   },
   "source": [
    "The `njit` function is equivalent to `jit(nopython = True)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-j5_ugY3gTb4"
   },
   "source": [
    "# Numba for GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "000-ybOwgc3S"
   },
   "source": [
    "There are two ways to program in GPU using Numba:\n",
    "\n",
    "__1.__   ufuncs/gufuncs\n",
    "\n",
    "__2.__  CUDA Python Kernels (Next webinar)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6xUV88VBkGtq",
    "outputId": "0e477551-9784-4cbf-988d-bc9d25c17510"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "nvidia-cuda-toolkit is already the newest version (9.1.85-3ubuntu1).\n",
      "You might want to run 'apt --fix-broken install' to correct these.\n",
      "The following packages have unmet dependencies:\n",
      " nvidia-cuda-toolkit : Depends: nvidia-cuda-dev (= 9.1.85-3ubuntu1) but it is not going to be installed\n",
      "E: Unmet dependencies. Try 'apt --fix-broken install' with no packages (or specify a solution).\n",
      "Requirement already satisfied: numba in /usr/local/lib/python3.6/dist-packages (0.48.0)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from numba) (50.3.2)\n",
      "Requirement already satisfied: llvmlite<0.32.0,>=0.31.0dev0 in /usr/local/lib/python3.6/dist-packages (from numba) (0.31.0)\n",
      "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.6/dist-packages (from numba) (1.18.5)\n"
     ]
    }
   ],
   "source": [
    "# Usar Numba en GPU en Colab\n",
    "!apt-get install nvidia-cuda-toolkit\n",
    "!pip3 install numba\n",
    "\n",
    "import os\n",
    "os.environ['NUMBAPRO_LIBDEVICE'] = \"/usr/lib/nvidia-cuda-toolkit/libdevice\"\n",
    "os.environ['NUMBAPRO_NVVM'] = \"/usr/lib/x86_64-linux-gnu/libnvvm.so\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nd88KHERJNyQ"
   },
   "source": [
    "## Functions ufunc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T7Cknt_SKRc_"
   },
   "source": [
    "One of the main design features of the GPU is the ability to handle data in parallel, so the universal functions of numpy (ufunc) are an ideal candidate to implement them in GPU programming.\n",
    "\n",
    "**_Note_**: ufunc are functions that perform the same operation on each element of a numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vI8WrSr2JVjk",
    "outputId": "61da0dcc-c99a-4468-86c1-6915cf9ceac8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 24, 343,  15,   9])"
      ]
     },
     "execution_count": 31,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3, 4])\n",
    "b = np.array([23, 341, 12, 5])\n",
    "\n",
    "np.add(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4UyLpN2sLbFV"
   },
   "source": [
    "Returns a new array, with the result of having performed the operation of adding to the array `a` the array `b`. It can also be used with scalars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yEDStx2wJVYS",
    "outputId": "265a37c8-57e8-4c8d-e24e-656ef35a5190"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([223, 541, 212, 205])"
      ]
     },
     "execution_count": 32,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(b, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q1TBpdFTL-oU"
   },
   "source": [
    "Arrays of different dimensions can also be operated using a technique called **broadcasting**. The array with the smallest dimension will be copied to match the dimensionality of the array with the largest dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hb2wkhXkL4Yy",
    "outputId": "698f787b-44fb-46b9-b79e-398d3f247479"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c array: \n",
      " [ 2  3  7  8 10 34]\n",
      "\n",
      "d array: \n",
      " [[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]\n",
      " [24 25 26 27 28 29]\n",
      " [30 31 32 33 34 35]]\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  9, 11, 14, 39],\n",
       "       [ 8, 10, 15, 17, 20, 45],\n",
       "       [14, 16, 21, 23, 26, 51],\n",
       "       [20, 22, 27, 29, 32, 57],\n",
       "       [26, 28, 33, 35, 38, 63],\n",
       "       [32, 34, 39, 41, 44, 69]])"
      ]
     },
     "execution_count": 33,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.array([2, 3, 7, 8, 10, 34])\n",
    "d = np.arange(6*6).reshape((6,6))\n",
    "\n",
    "print('c array: \\n', c)\n",
    "print('\\nd array: \\n', d)\n",
    "print('\\n')\n",
    "\n",
    "np.add(c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dtQpz6UgSWxU"
   },
   "source": [
    "### Making functions ufunc for GPU\n",
    "\n",
    "As we have said before, the ufunc functions are an ideal candidate to use them with GPU because of their parallelism. Therefore, Numba has the ability to create compiled ufunc functions without using C. To do this, we must use the decorator `@vectorize`.\n",
    "\n",
    "Let's start with an example using `@vectorize` to compile and optimize a CPU ufunc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qD24rHU3SzxR"
   },
   "outputs": [],
   "source": [
    "from numba import vectorize\n",
    "\n",
    "a = np.array([1, 2, 3, 4])\n",
    "b = np.array([23, 341, 12, 5])\n",
    "\n",
    "@vectorize\n",
    "def add_ufunc_cpu(a, b):\n",
    "  return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jB6fCpFrTOZO",
    "outputId": "c5873d0c-c558-4a6b-df56-c2817c99459a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 24, 343,  15,   9])"
      ]
     },
     "execution_count": 35,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numba function\n",
    "add_ufunc_cpu(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BRIuyhr6TeCb"
   },
   "source": [
    "Instead of using the CPU to compile and execute the previous function, we are going to use CUDA in the GPU and for this we must use a \"target attribute\". We will indicate what type each variable is (arguments and return value).\n",
    "\n",
    "\n",
    "`return_value_type(argument1_value_type, argument2_value_type, ...)`\n",
    "\n",
    "To do this, we will use the previous function that expects 2 int64 values and returns another int64 value. We will designate `target = 'cuda'` to be able to execute it in the GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "np5fvHEKUCCE",
    "outputId": "45b8dd2a-6d0e-4a14-eb4d-dab7391e6c1b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/numba/cuda/envvars.py:17: NumbaWarning: \n",
      "Environment variables with the 'NUMBAPRO' prefix are deprecated and consequently ignored, found use of NUMBAPRO_NVVM=/usr/lib/x86_64-linux-gnu/libnvvm.so.\n",
      "\n",
      "For more information about alternatives visit: ('http://numba.pydata.org/numba-doc/latest/cuda/overview.html', '#cudatoolkit-lookup')\n",
      "  warnings.warn(errors.NumbaWarning(msg))\n",
      "/usr/local/lib/python3.6/dist-packages/numba/cuda/envvars.py:17: NumbaWarning: \n",
      "Environment variables with the 'NUMBAPRO' prefix are deprecated and consequently ignored, found use of NUMBAPRO_LIBDEVICE=/usr/lib/nvidia-cuda-toolkit/libdevice.\n",
      "\n",
      "For more information about alternatives visit: ('http://numba.pydata.org/numba-doc/latest/cuda/overview.html', '#cudatoolkit-lookup')\n",
      "  warnings.warn(errors.NumbaWarning(msg))\n"
     ]
    }
   ],
   "source": [
    "@vectorize(['int64(int64, int64)'], target='cuda') \n",
    "def add_ufunc_gpu(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JGJCYwksUeXj",
    "outputId": "05891aa5-010f-44fd-a406-9c0680c7efc6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 24, 343,  15,   9])"
      ]
     },
     "execution_count": 37,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_ufunc_gpu(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z_i5yifNUtYL"
   },
   "source": [
    "We can check the speed of running it on CPU or GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "71DLTwwEVMyM",
    "outputId": "6be8305a-6f86-4ea6-a7e8-11a9855c7a35"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 33.59 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "1000000 loops, best of 3: 574 ns per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit np.add(a, b)   # Numpy en CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lVoLg2J-sWJH",
    "outputId": "cf5c468d-a1ab-4806-e888-546697191ace"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 1.12 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit add_ufunc_gpu(a, b)   # Numba en GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ElQvxCIpWKH_"
   },
   "source": [
    "GPU is slower than the CPU!!! Quiet, this has an explanation ... But first let's see what happens when we call that function\n",
    "![ChessUrl](https://media.giphy.com/media/9M1ALCAKvXQKSf9Zfo/giphy.gif)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1DZnfO_-WQTz"
   },
   "source": [
    "When we execute this function, Numba produces:\n",
    "\n",
    "\n",
    "\n",
    "1. Compile a CUDA kernel to execute the ufunc function in parallel over all the elements of the input array\n",
    "2. Assign the inputs and outputs to the GPU memory\n",
    "3. Copy the input to the GPU\n",
    "4. Run the CUDA Kernel\n",
    "5. Copy the results back from the GPU to the CPU\n",
    "6. Return the results as a numpy array\n",
    "\n",
    "As compared to the implementation in C, Numba allows you to perform these types of tasks in a more concise way.\n",
    "\n",
    "Why is the GPU slower than the CPU?\n",
    "\n",
    "\n",
    "* Our inputs are too small: The GPU achieves better performance using parallelism operating on thousands of values ​​at once. Our inputs are 4 (int64), \"we need larger arrays to keep the GPU occupied\".\n",
    "\n",
    "* Very simple calculation: Sending the calculation to the GPU requires a lot of \"effort\" compared to calling the CPU function. If our function does not require excessive mathematical computation (this is usually called **arithmetic intensity**), then the GPU could take longer than in the CPU.\n",
    "\n",
    "* Numba copies the data to the GPU\n",
    "\n",
    "* The variable types of our inputs are larger than necessary: ​​Our example uses int64 and we probably do not need them. Practically, in CPU, 32 and 64-bits have the same computing speed, but in GPU, 64-bits have a slight increase in computational speed (it can reach up to 24x slower respectively to 32-bits). So it is important to keep this in mind when executing our function in the GPU.\n",
    "\n",
    "\n",
    "With this in mind, we will try to apply what has been learned in the previous points to see if it is really faster to operate on the GPU than the CPU. We are going to calculate a density function, which is a slightly more complex operation with larger arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CCsVb1O9Q_Li"
   },
   "source": [
    "Let's calculate the value of a Gaussian density function in `x` given the mean and sigma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tNG-g0SyPWYL"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "sqrt_pi = np.float32((2*math.pi)**0.5) \n",
    "\n",
    "@vectorize(['float32(float32, float32, float32)'], target='cuda')\n",
    "def gaussian_dens_gpu(x, mean, sigma):\n",
    "    return math.exp(-0.5 * ((x - mean) / sigma)**2) / (sigma * sqrt_pi)\n",
    "  \n",
    "x = np.random.uniform(-3, 3, size=1000000).astype(np.float32)\n",
    "mean = np.float32(0.0)\n",
    "sigma = np.float32(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yZdIMOtpQBPk",
    "outputId": "2aedde9e-6938-45be-8681-b7fb1c8f6499"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 loops, best of 3: 58.3 ms per loop\n"
     ]
    }
   ],
   "source": [
    "# Same example using scipy (CPU vs GPU)\n",
    "import scipy.stats \n",
    "\n",
    "norm_pdf = scipy.stats.norm\n",
    "\n",
    "%timeit norm_pdf.pdf(x, loc=mean, scale=sigma)  # CPU function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XpwiTTYptIFI",
    "outputId": "621ad190-cebe-468d-ddad-333481af01d1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 32.99 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100 loops, best of 3: 5.22 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit gaussian_dens_gpu(x, mean, sigma) # GPU function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "41udDlkHRD2N"
   },
   "source": [
    "Yeaah!!\n",
    "\n",
    "![Ricky](https://media.giphy.com/media/3oKIPi2ELEdp4XFtVm/giphy.gif)\n",
    "\n",
    "We can even define our function to be executed in the CPU using Numba."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Qd3K-QRFRqCr",
    "outputId": "d7387914-9114-4d0e-acc6-5f1500461992"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 7.66 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "10 loops, best of 3: 22.2 ms per loop\n"
     ]
    }
   ],
   "source": [
    "import math \n",
    "\n",
    "sqrt_pi = np.float32((2*math.pi)**0.5)\n",
    "\n",
    "@vectorize\n",
    "def gaussian_dens_cpu(x, mean, sigma):\n",
    "    return math.exp(-0.5 * ((x - mean) / sigma)**2) / (sigma * sqrt_pi)\n",
    "  \n",
    "x = np.random.uniform(-3, 3, size=1000000).astype(np.float32)\n",
    "mean = np.float32(0.0)\n",
    "sigma = np.float32(1.0)\n",
    "\n",
    "%timeit gaussian_dens_cpu(x, mean, sigma) # CPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7CEyOflDR1fb"
   },
   "source": [
    "It is even faster than the function written in Python, but slower than the one executed in the GPU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sSruAoxYao9c"
   },
   "source": [
    "Unfortunately, there are several functions that do not fall within the scope of the definition of ufunc, therefore, to execute functions in the GPU that do not meet that requirement we use `cuda.jit`. We can use \"device functions\" that run on our GPU.\n",
    "\n",
    "__*note*__: \"devices functions\" are functions that can only be called from a kernel or from another \"device\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Gcvl1EMEanjh"
   },
   "outputs": [],
   "source": [
    "from numba import cuda\n",
    "\n",
    "# Device function\n",
    "@cuda.jit(device=True)\n",
    "def polar_to_cartesian(rho, theta):\n",
    "    x = rho * math.cos(theta)\n",
    "    y = rho * math.sin(theta)\n",
    "    return x, y\n",
    "\n",
    "@vectorize(['float32(float32, float32, float32, float32)'], target='cuda')\n",
    "def polar_distance(rho1, theta1, rho2, theta2):\n",
    "    x1, y1 = polar_to_cartesian(rho1, theta1)\n",
    "    x2, y2 = polar_to_cartesian(rho2, theta2)\n",
    "    \n",
    "    return ((x1 - x2)**2 + (y1 - y2)**2)**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vlib7BNXbzfI"
   },
   "outputs": [],
   "source": [
    "n = 1000000\n",
    "rho1 = np.random.uniform(0.5, 1.5, size=n).astype(np.float32)\n",
    "theta1 = np.random.uniform(-np.pi, np.pi, size=n).astype(np.float32)\n",
    "rho2 = np.random.uniform(0.5, 1.5, size=n).astype(np.float32)\n",
    "theta2 = np.random.uniform(-np.pi, np.pi, size=n).astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ERUppMswb1O_",
    "outputId": "2d1c1184-78e7-4e54-f7a1-68c50697a3c6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 23.49 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "1 loop, best of 3: 9.71 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit polar_distance(rho1, theta1, rho2, theta2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G59Ix_AMG82t"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Numba_CUDA.ipynb",
   "provenance": []
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}