db-python-speedup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5d681704",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "# Speeding up your Python Code\n",
    "\n",
    "\n",
    "## Pete Lawson, PhD\n",
    "\n",
    "### October 10th, 2022\n",
    "\n",
    "<i class=\"fa fa-github\"> <a href =\"https://github.com/pete-lawson\">github.com/pete-lawson</a></i>\n",
    "\n",
    "<i class=\"fa fa-envelope\"> <a href =\"plawson@jhu.edu\">plawson@jhu.edu</a></i>\n",
    "\n",
    "<img src=\"images/data-bytes-logo.png\" align = \"left\" width = \"300\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d65a24",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why speed up your `python` code?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2ea00f5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Lots to compute** - Your code is taking many minutes, hours, or days to run!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a4c1914",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Refactor** - Make your code more efficient, compact, and easier to read."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69fc0780",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Use List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69f23750",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "List comprehension is a more compact way to represent a for loop in Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "114fdf4c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lets take a look at a regular for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f976070e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "list_length = 10\n",
    "numbers = []\n",
    "\n",
    "for val in range(list_length):\n",
    "    numbers.append(val**2)\n",
    "\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31f3b753",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now lets convert that to list comprehension syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcfc35ba",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "## List Comprehension Syntax\n",
    "newlist = [expression for item in iterableList if condition == True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6b3aeb2b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# Our for loop code\n",
    "list_length = 10\n",
    "numbers = []\n",
    "\n",
    "for val in range(list_length):\n",
    "    numbers.append(val**2)\n",
    "\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e73a145a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# Now as a list comprehension\n",
    "list_length = 10\n",
    "\n",
    "numbers = [val**2 for val in range(list_length)]\n",
    "\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c63cb85",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "By not explicitly calling `append` you can speed things up quite a bit!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebbf44cf",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "By how much?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0988d03f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Maybe it's `time` for a lesson on timing our code!\n",
    "![cat-clock](https://media3.giphy.com/media/xT1XGLSb5E1VjIUw4E/giphy.gif?cid=790b7611664fb51eaac4bf0c144b1eacfebb996c5d1dabc9&rid=giphy.gif&ct=g)\n",
    "<p><small>Clock Cat Gif - Stephen Maurice Graham @smgdraws</small><//p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0fa32de",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The `time` library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ecccced1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Runtime is 0.000 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "start = time.time()\n",
    "# My Timed Code\n",
    "end = time.time()\n",
    "\n",
    "runtime = end - start\n",
    "\n",
    "print(f'Runtime is {runtime:.3f} seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52c8e0ca",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Timing a for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "558c886b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Runtime is 0.333 seconds\n"
     ]
    }
   ],
   "source": [
    "import time \n",
    "\n",
    "list_length = 1000000\n",
    "start = time.time()\n",
    "\n",
    "numbers = []\n",
    "for x in range(list_length):\n",
    "    numbers.append(x**2)\n",
    "\n",
    "end = time.time()\n",
    "        \n",
    "runtime_loop = end - start\n",
    "\n",
    "print(f'\\nRuntime is {runtime_loop:.3f} seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11246249",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Timing list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "37611271",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Runtime is 0.258 seconds\n",
      "\n",
      "Squaring a list with list comprehension is 1.29 times faster than a for loop\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "\n",
    "numbers = [x**2 for x in range(list_length)]   \n",
    "\n",
    "end = time.time()\n",
    "runtime_list_comp = end - start\n",
    "\n",
    "print(f'\\nRuntime is {runtime_list_comp:.3f} seconds')\n",
    "print(f'\\nSquaring a list with list comprehension is {runtime_loop/runtime_list_comp:.2f} times faster than a for loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f90b07",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Time for another timing command: `%%timeit` magic command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a87e3b73",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "244 ms ± 3.79 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -r 3 -n 10\n",
    "numbers = [x**2 for x in range(list_length)]   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fe1cc3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Using the `NumPy` Library - *Lets get close to the metal!*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5564373a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/0/03/Ordinateurs_centraux_348-3-006.jpg\" alt=\"man with mainframe\" style=\"height:400px;\">\n",
    "<small>IBM 360 mainframe computer, CPU light/switch panel, 4 visible Magnetic Tape Reader/Writers, \"Selectric\" \"teletype\" console, (not seen, cables under raised floor) <br>Photograph by Yves Tessier, distributed under a CC BY-SA 4.0 license.</small>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29f32c31",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `NumPy`: Scientific Computing in Python\n",
    "NumPy consists of mathematical functions, linear algebra routines, and array operations, all running in well-optimized C code. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eed269b9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Which is computer science speak for:\n",
    ">**It's fast!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e25c0793",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lets try implementing the original for loop in NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "e69f0534",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Runtime is 0.076 seconds\n",
      "\n",
      "Squaring a list with numpy is 4.18 times faster than a for loop\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "start = time.time()\n",
    "\n",
    "np_numbers = np.array([range(list_length)])\n",
    "np_numbers_squared = np.square(np_numbers)\n",
    "\n",
    "end = time.time()\n",
    "\n",
    "runtime_np = end - start\n",
    "\n",
    "print(f'\\nRuntime is {runtime_np:.3f} seconds')\n",
    "print(f'\\nSquaring a list with numpy is {runtime_loop/runtime_np:.2f} times faster than a for loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3201d696",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If you have an Nvidia **G**rahical **P**rocessing **U**nit (GPU) ...\n",
    "![nvidia-brand-logo](https://www.nvidia.com/content/dam/en-zz/Solutions/about-nvidia/logo-and-brand/01-nvidia-logo-horiz-500x200-2c50-d.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b9e203c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Then you can use `CuPy`!\n",
    "![CuPy Logo](https://repository-images.githubusercontent.com/93458756/a85df740-1aec-4a39-a5c9-4d219c1ac0f7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f10d73c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`CuPy` is a drop-in replacement to `NumPy` and `SciPy` that allows your code to automagically run on your GPU!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9be9a84",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Why is `CuPy` faster?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c66a278f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![cpu-vs-gpu](https://qph.cf2.quoracdn.net/main-qimg-29198fbe7b18570f369a93a7dc3f999a-lq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4220c87",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A **CPU** can do a few operations at once"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "597f1d79",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A **GPU** can do many thousands of (simple) operations at once"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60e65fe9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lets create a 2000 x 2000 array in NumPy, then square it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "820d98b7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n = 2000\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "np_array = np.random.random((n, n))C\n",
    "np_array_squared = np.square(np_array)\n",
    "\n",
    "end = time.time()\n",
    "\n",
    "runtime_np_array = end - start\n",
    "\n",
    "print(f'\\nRuntime is {runtime_np_array*1000:.3f} milliseconds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "955ffebb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Runtime is 0.998 milliseconds\n",
      "\n",
      "Squaring an array with CuPy is 48.01 times faster than NumPy\n"
     ]
    }
   ],
   "source": [
    "import cupy as cp\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "cp_array = cp.random.random((n, n))\n",
    "cp_array_squared = cp.square(cp_array)\n",
    "\n",
    "end = time.time()\n",
    "\n",
    "runtime_cp_array = end - start\n",
    "\n",
    "print(f'\\nRuntime is {runtime_cp_array*1000:.3f} milliseconds')\n",
    "print(f'\\nSquaring an array with CuPy is {runtime_np_array/runtime_cp_array:.2f} times faster than NumPy')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72d6caf1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Working with data in `Pandas`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "b82775e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>cat_breed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>16</td>\n",
       "      <td>Calico</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>72</td>\n",
       "      <td>Siamese</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10</td>\n",
       "      <td>Siamese</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>Calico</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>26</td>\n",
       "      <td>Maine Coon</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   age   cat_breed\n",
       "0   16      Calico\n",
       "1   72     Siamese\n",
       "2   10     Siamese\n",
       "3    5      Calico\n",
       "4   26  Maine Coon"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def getData(length):\n",
    "    df = pd.DataFrame()\n",
    "    df['age'] = np.random.randint(0, 100, length)\n",
    "    df['cat_breed'] = np.random.choice(['Calico', 'Maine Coon', 'Siamese'], length)\n",
    "    return(df)\n",
    "\n",
    "df = getData(10_000)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c53687f9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How many individuals between 30 and 45 with a Calico cat?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "fa22eb7d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "373 ms ± 1.93 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -r 5 -n 10\n",
    "\n",
    "# Computed with a loop\n",
    "def cat_keeper(row):\n",
    "    if((row['age']>= 30 and row['age']<=45) and row['cat_breed'] == 'Calico'):\n",
    "        return(True)\n",
    "    return(False)\n",
    "\n",
    "matches = []       \n",
    "\n",
    "for index, row in df.iterrows():\n",
    "    matches.append(cat_keeper(row))\n",
    "\n",
    "loop_match_count = sum(matches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "ed808aae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4 ms ± 83.3 µs per loop (mean ± std. dev. of 5 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -r 5 -n 10\n",
    "\n",
    "# Computed with vectorized operations\n",
    "vector_match_count = sum(((df['age'] >= 30) & (df['age'] <= 4|5)) & (df['cat_breed'] == 'Calico'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19b8417d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b347159",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Use list comprehension rather than for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a40be017",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Use NumPy for simple list/array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43d739b5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Use CuPy for simple list/array operations if:\n",
    "  - The list or array is large enough\n",
    "  - The operation is simple\n",
    "  - You have an Nvidia GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fbf7b9b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- If you are using Pandas, use vectorized operations, not loops"
   ]
  }
 ],
 "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}