course2/02_faster_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 2 - Optimizing Python \n",
    "----------------------------------------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "# Table of Content <a id='toc'></a>\n",
    "\n",
    "\n",
    "1. **[Numpy](#4)**\n",
    "\n",
    "2. **[Numba](#6)**\n",
    "   \n",
    "3. **[Cython](#5)**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Now that we have seen the tools to measure our code resource usage, we will review a couple of tricks that can help you speed-up your python code tremendously.\n",
    "\n",
    "The firsts are basic:\n",
    " 1. **Apply standard good sense**: does your code reads/write to the disk more than it need to?\n",
    "    Do you spend a lot of time searching for items in lists instead of dictionaries?\n",
    " 2. **Switch to numpy**: vectorized operations are great (as we have seen).\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import numba\n",
    "import cython\n",
    "\n",
    "print(\"All modules loaded successfully!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note: if you are missing some of the above modules, you should install them.\n",
    ">\n",
    ">    * Installation with **pip**: `pip install --user numpy numba cython` \n",
    ">    * Installation with **conda**: `conda install -c conda-forge numpy numba cython`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "## 1. Numpy <a id=\"4\"></a>\n",
    "\n",
    "If you have not done it already, a very good first step is to **use numpy structures and functions** wherever possible.  \n",
    "Indeed, `numpy` implements efficient (it is all C++ under the hood) and vectorized operations, within a fairly easy to approach interface.  \n",
    "It base structure is the **array**, which can be multi-dimensional, and can contains a single type of object (e.g. all floats).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "L = [1, 3, 45, 2, 3]\n",
    "A = np.array(L)\n",
    "\n",
    "print(\"list\", L)\n",
    "print(\"array\", A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "There are many numpy array creation routines, some of which we have already seen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 5x5 array of 0s.\n",
    "np.zeros((5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10 values randomly drawn from a standard normal distribution.\n",
    "np.random.randn(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "But the nicest is that you can **perform operations on whole arrays at once**, and fast:  \n",
    "* Let's compare the speed of using numpy vs a regular python list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.randn(10 ** 6)\n",
    "L = list(A) # for comparison\n",
    "\n",
    "# Multiply all elements by 13.\n",
    "%timeit -n 10 -r 3 A * 13\n",
    "%timeit -n 10 -r 3 [x * 13 for x in L]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is a speedup of ~200!\n",
    "\n",
    "The same thing works if you want to do operation between arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1 = np.random.randint(low=1, high=6, size=3)  # 3 random numbers.\n",
    "A2 = np.random.randint(low=1, high=6, size=3)  # 3 other random numbers.\n",
    "print(f\"{A1} + {A2} -> {A1+A2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "Numpy also has a number of nice common functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"sum\")\n",
    "%timeit -n 5 -r 3 A.sum()\n",
    "%timeit -n 5 -r 3 sum(L)    # Compare with builtin sum.\n",
    "print(\"***\")\n",
    "\n",
    "print(\"mean\")\n",
    "%timeit -n 5 -r 3 A.mean()\n",
    "%timeit -n 5 -r 3 sum(L)/len(L) \n",
    "print(\"***\")\n",
    "\n",
    "print(\"standard deviation\")\n",
    "%timeit -n 5 -r 3 A.sum()\n",
    "\n",
    "# We have to build a little function here.\n",
    "def std(L):\n",
    "    m = sum(L) / len(L) \n",
    "    s = 0\n",
    "    for i in L:\n",
    "        s+= (i - m)**2\n",
    "    return (s / len(L))**0.5\n",
    "%timeit -n 5 -r 3 std(L) \n",
    "\n",
    "print(\"***\")\n",
    "print(\"sorting\")\n",
    "%timeit -n 5 -r 3 np.sort(A)\n",
    "%timeit -n 5 -r 3 sorted(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, that's just scratching the surface, but you can see how even a few lines of code here can make you code much faster.\n",
    "\n",
    "If you are not familiar with numpy, we recommend you take some time to practice with it as it is somewhat ubiquitous in scientific python. Their [absolute beginner's guide](https://numpy.org/doc/stable/user/absolute_beginners.html) is a good (and actually fairly thorough) starting point.\n",
    "\n",
    "<br>\n",
    "\n",
    "Remember, in the previous section we rewrote the `pairwise_distance` function in numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pairwise_distance(X):\n",
    "\n",
    "    num_vectors = len(X)\n",
    "    num_measurements = len(X[0])\n",
    "    D = [[0]*num_vectors for x in range(num_vectors)]\n",
    "    \n",
    "    for i in range(num_vectors):\n",
    "        for j in range(num_vectors):\n",
    "            d = []\n",
    "            for k in range(num_measurements):\n",
    "                d.append( ( X[i][k] - X[j][k] )**2 )\n",
    "            \n",
    "            D[i][j] = sum(d) **0.5\n",
    "    return(D)\n",
    "\n",
    "\n",
    "def pairwise_distance_numpy(X):\n",
    "\n",
    "    num_vectors = X.shape[0]\n",
    "    num_measurements = X.shape[1] \n",
    "    D = np.empty((num_vectors, num_vectors), dtype=np.float64)\n",
    "    \n",
    "    for i in range(num_vectors):\n",
    "        for j in range(num_vectors):\n",
    "            d = np.square( np.subtract(X[i], X[j]) )\n",
    "            D[i, j] = np.sqrt(np.sum(d))\n",
    "    return(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can play *spot the differences* between these 2 implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## Exercise 2.1 - Numpy optimization\n",
    "\n",
    "See the dedicated `exercises_course2.ipynb` notebook.\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "[Back to ToC](#toc)\n",
    "\n",
    "## 2. Numba <a id='6'></a>\n",
    "\n",
    "**[Numba](https://numba.pydata.org/)** is a nice library which provide a number of optimization routines for python code, the most well know being **`@jit`** for **just-in-time** compilation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import jit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unchanged code \n",
    "# The option nopython=True raises an error if numba failed to convert the code to full C.\n",
    "@jit(nopython=True) \n",
    "def pairwise_distance_numba(X):\n",
    "\n",
    "    num_vectors = X.shape[0]\n",
    "    num_measurements = X.shape[1] \n",
    "    D = np.empty((num_vectors, num_vectors), dtype=np.float64)\n",
    "    \n",
    "    for i in range(num_vectors):\n",
    "        for j in range(num_vectors):\n",
    "            d = np.square( np.subtract(X[i], X[j]) )\n",
    "            D[i, j] = np.sqrt(np.sum(d))\n",
    "    return(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_vector = 200\n",
    "num_measures = 100\n",
    "\n",
    "data = np.random.uniform(size=(num_vector,num_measures))\n",
    "print(type(data[0][0]))\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%time result = pairwise_distance_numba(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "**Important:** The first time the code is executed, Numba need to translate and compile the C code, which creates an overhead and slows it down. This is no longer needed on subsequent runs, to try running the function again to get the execution time without compilation.\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%timeit -n 5 -r 7 result = pairwise_distance_numpy(data)\n",
    "%timeit -n 5 -r 7 result = pairwise_distance_numba(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Woosh!** that is quite a gain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alternative syntax\n",
    "import numba\n",
    "\n",
    "pairwise_distance_numba = numba.jit(pairwise_distance_numpy , nopython=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here it is pretty bluffing, but sometimes it can be a bit difficult to get this level of performance.\n",
    "\n",
    "Most external libraries are missing from numba, and [not all of numpy's code has been ported as well](https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html).\n",
    "\n",
    "> Note: a lot of function in external libraries (such as the ones of sklearn) have already been optimized and compiled, so there would not necessarily be much to gain there anyway...\n",
    "\n",
    "All-in-all, it depends quite a lot on the particulars of what you want to optimize : [here are some tips](https://numba.pydata.org/numba-doc/latest/user/performance-tips.html)\n",
    "\n",
    "\n",
    "> there also exists ways to [compile numba code ahead of time](https://numba.pydata.org/numba-doc/dev/user/pycc.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although it is usually a good idea to rely on `numpy` vectorized operations, `numba` copes very well with loops and vectorizes them when it can , and sometimes ends up even better for it:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(nopython=True)\n",
    "def pairwise_distance_numba2(X):\n",
    "\n",
    "    num_vectors = X.shape[0]\n",
    "    num_measurements = X.shape[1] \n",
    "    D = np.empty((num_vectors, num_vectors), dtype=np.float64)\n",
    "    \n",
    "    for i in range(num_vectors):\n",
    "        for j in range(num_vectors):\n",
    "            d = 0.\n",
    "            for k in range(num_measurements):\n",
    "                d += np.square( np.subtract(X[i][k], X[j][k])  )\n",
    "            D[i, j] = np.sqrt(d)\n",
    "    return(D)\n",
    "\n",
    "_ = pairwise_distance_numba2(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit -n 10 -r 3 result = pairwise_distance_numba(data)\n",
    "%timeit -n 10 -r 3 result = pairwise_distance_numba2(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "[Back to ToC](#toc)\n",
    "\n",
    "## 3. Cython <a id='5'></a>\n",
    "\n",
    "**[Cython](https://cython.org/)** provides a way to transform python code into C compiled code fairly seamlessly.\n",
    "\n",
    "By default, Cython retains Python flexibility by creating the ugliest of C-codes. This comes at the cost of a lot of efficiency, but is already enough to speed-up your code some.\n",
    "\n",
    "The \"command-line\" flavor of cython involves either calling `cython` or writing a little `setup.py` file for your code. It is a bit of work at the start but actually quite easy once you have done it a couple of time: see [here for examples](https://cython.readthedocs.io/en/latest/src/quickstart/build.html)\n",
    "\n",
    "The jupyter way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pure python \n",
    "def f_native(x):\n",
    "    return x ** 2 - x\n",
    "\n",
    "def integrate_f_native(a, b, N):\n",
    "    s = 0\n",
    "    dx = (b - a) / N\n",
    "    for i in range(N):\n",
    "        s += f_native(a + i * dx)\n",
    "    return s * dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "# cython, without changing a single thing\n",
    "\n",
    "def f(x):\n",
    "    return x ** 2 - x\n",
    "\n",
    "def integrate_f(a, b, N):\n",
    "    s = 0\n",
    "    dx = (b - a) / N\n",
    "    for i in range(N):\n",
    "        s += f(a + i * dx)\n",
    "    return s * dx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Native python:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f_native(0, 1, 1000000)\n",
    "\n",
    "print(\"Simple cython:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f(0, 1, 1000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so a speedup of about a third, fairly nice for a single line change.\n",
    "\n",
    "But, let's look how Cython performed with our code :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython --annotate\n",
    "# cython, without changing a single thing.\n",
    "\n",
    "def f(x):\n",
    "    return x ** 2 - x\n",
    "\n",
    "def integrate_f(a, b, N):\n",
    "    s = 0\n",
    "    dx = (b - a) / N\n",
    "    for i in range(N):\n",
    "        s += f(a + i * dx)\n",
    "    return s * dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "**We can give some hints to Cython**, to help it compile the code better :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%%cython --annotate\n",
    "# cython, with manually added typing.\n",
    "\n",
    "def f_typed(double x):\n",
    "    return x ** 2 - x\n",
    "\n",
    "\n",
    "def integrate_f_typed(double a, double b, int N):\n",
    "    cdef int i\n",
    "    cdef double s, dx\n",
    "    s = 0\n",
    "    dx = (b - a) / N\n",
    "    for i in range(N):\n",
    "        s += f_typed(a + i * dx)\n",
    "    return s * dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's better, but there is still a lot of yellow. \n",
    "In particular when the two functions interact. \n",
    "Which is not ideal because they should both be in C, their interaction should happen without any python element.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython --annotate\n",
    "# cython, more typing.\n",
    "\n",
    "# This function is only called inside functions which are cythonized.\n",
    "# So we can tell cython to try to compile is as pure C.\n",
    "cdef double f_full_typed(double x):\n",
    "    return x ** 2 - x\n",
    "\n",
    "\n",
    "def integrate_f_full_typed(double a, double b, int N):\n",
    "    cdef int i\n",
    "    cdef double s, dx\n",
    "    s = 0\n",
    "    dx = (b - a) / N\n",
    "    for i in range(N):\n",
    "        s += f_full_typed(a + i * dx)\n",
    "    return s * dx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "**Let's compare the speed** of our different implementations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Native python:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f_native(0, 1, 1_000_000)\n",
    "\n",
    "print(\"Cython - simple:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f(0, 1, 1_000_000)\n",
    "\n",
    "print(\"Cython - some typing:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f_typed(0, 1, 1_000_000)\n",
    "\n",
    "print(\"Cython - more typing:\")\n",
    "%timeit -n 10 -r 3 result = integrate_f_full_typed(0, 1, 1_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Woohoo! that's more like it.\n",
    "\n",
    "Of course, there is more things we could do, like typing the return type of the functions and so on, as shown in this [quick-start tutorial](https://cython.readthedocs.io/en/latest/src/quickstart/cythonize.html) (from which this example was taken). \n",
    "\n",
    "<br>\n",
    "\n",
    "These compiling tools usually won't work with external libraries, but a cool thing about Cython is that it works very well with numpy structures (although the code is somewhat ugly, and they use a deprecated API, which they are currently working on changing...).\n",
    "\n",
    "So le'ts see what we can get with our `pairwise_distance`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython --annotate\n",
    "# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION\n",
    "import numpy as np\n",
    "cimport numpy as np\n",
    "cimport cython\n",
    "DTYPE = np.float64\n",
    "ctypedef np.float64_t DTYPE_t\n",
    "\n",
    "@cython.boundscheck(False)  # Turn-off bounds-checking for entire function.\n",
    "@cython.wraparound(False)   # Turn-off negative index wrapping for entire function.\n",
    "def pairwise_distance_cython(double[:, ::1] X):\n",
    "    \n",
    "    cdef int num_vectors = X.shape[0]\n",
    "    cdef int num_measurements = X.shape[1]\n",
    "    cdef double d\n",
    "    cdef double[:, ::1] D = np.empty((num_vectors, num_vectors), dtype=DTYPE)\n",
    "    \n",
    "    for i in range(num_vectors):\n",
    "        for j in range(num_vectors):\n",
    "            d=0\n",
    "            for k in range(num_measurements):\n",
    "                \n",
    "                d += ( X[i][k] - X[j][k] )**2\n",
    "\n",
    "            D[i, j] = d**0.5\n",
    "    return(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data.shape)\n",
    "print(\"Numpy:\")\n",
    "%timeit -n 10 -r 3 D = pairwise_distance_numpy(data)\n",
    "\n",
    "print(\"Cython:\")\n",
    "%timeit -n 10 -r 3 result = pairwise_distance_cython(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so now we have really gotten a lot faster.\n",
    "\n",
    "So cython is really great, although it does take some practice to get it to work the way you want. \n",
    "They do have a [nice tutorial](https://cython.readthedocs.io/en/latest/index.html) though.\n",
    "\n",
    "> Notes:\n",
    "> * `cython` also a great way to\n",
    ">   [interface python and C code](https://cython.readthedocs.io/en/stable/src/userguide/external_C_code.html).\n",
    "> * It is also fairly easy to do\n",
    ">   [profiling on cython code](https://cython.readthedocs.io/en/latest/src/tutorial/profiling_tutorial.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Comparison between the different implementations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Create a test data matrix of size 400 x 100.\n",
    "data = np.random.uniform(size=(400, 100))\n",
    "print(\"Test matrix type:\", type(data[0][0]))\n",
    "print(\"Test matrix size:\", data.shape)\n",
    "\n",
    "# Benchmark the different implementations of the pairwise distance computing.\n",
    "print(\"\\nNative python:\")\n",
    "%time result = pairwise_distance(data)\n",
    "\n",
    "print(\"\\nNumpy:  \", end=\"\")\n",
    "%timeit -n 1 -r 10 result = pairwise_distance_numpy(data)\n",
    "\n",
    "print(\"Cython: \", end=\"\")\n",
    "%timeit -n 1 -r 10 result = pairwise_distance_cython(data)\n",
    "\n",
    "print(\"Numba:  \", end=\"\")\n",
    "%timeit -n 1 -r 10 result = pairwise_distance_numba2(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This is an example which tends to favors optimization by numba. In some other cases Cython may perform better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## Exercise 2.2 - Numba/Numpy/Cython optimization\n",
    "\n",
    "See the dedicated `exercises_course2.ipynb` notebook.\n",
    "\n",
    "<div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_py311)",
   "language": "python",
   "name": "conda_py311"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}