low-level-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python-C interoperability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python has an [excellent C API](https://docs.python.org/3/c-api/index.html) for writing extension modules in C/C++. Let's not use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"tmp.c\", \"w\") as file:\n",
    "    file.write(\"\"\"\n",
    "#include <math.h>\n",
    "void runs_in_c(int N, double* p, double* px, double* py, double* pz) {\n",
    "    int i;\n",
    "    for (i = 0;  i < N;  i++) {\n",
    "        p[i] = sqrt(px[i]*px[i] + py[i]*py[i] + pz[i]*pz[i]);\n",
    "    }\n",
    "}\"\"\")\n",
    "import os\n",
    "assert os.system(\"gcc -fPIC -shared tmp.c -o libtmp.so\") == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import ctypes\n",
    "libtmp = ctypes.cdll.LoadLibrary(\"./libtmp.so\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "libtmp.runs_in_c.argtypes = (ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p)\n",
    "libtmp.runs_in_c.restype = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    "px = numpy.random.normal(0, 10, 1000000)\n",
    "py = numpy.random.normal(0, 10, 1000000)\n",
    "pz = numpy.random.normal(0, 10, 1000000)\n",
    "p = numpy.zeros(1000000)\n",
    "\n",
    "libtmp.runs_in_c(1000000, p.ctypes.data, px.ctypes.data, py.ctypes.data, pz.ctypes.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Going the other way:** running Python in C.\n",
    "\n",
    "The GNU Scientific Library is a large collection of C functions, some of which take functions as arguments:\n",
    "\n",
    "```c\n",
    "struct gsl_function {\n",
    "    double (*function) (double x, void* params);\n",
    "    void* params;\n",
    "};\n",
    "```\n",
    "\n",
    "Let's convince GSL to take a Python function as though it were a C function (in its derivative-calculating method)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def f(x, params):\n",
    "    out = 3*x**2 + 2*x + 1\n",
    "    print(\"f({}) = {}\".format(x, out))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# express the (double, double -> void) function type in ctypes\n",
    "func_type = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_void_p)\n",
    "\n",
    "# express the gsl_function struct in ctypes\n",
    "class gsl_function(ctypes.Structure):\n",
    "    _fields_ = [(\"f\", func_type), (\"params\", ctypes.c_void_p)]\n",
    "\n",
    "# make a ctypes object for the function\n",
    "callback = gsl_function(func_type(f), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "gslcblas = ctypes.CDLL(\"libgslcblas.so\", mode=ctypes.RTLD_GLOBAL)\n",
    "gsl = ctypes.CDLL(\"libgsl.so\")\n",
    "\n",
    "# pointers to GSL's output: result and abserr\n",
    "p_result = ctypes.POINTER(ctypes.c_double)(ctypes.c_double(-1))\n",
    "p_abserr = ctypes.POINTER(ctypes.c_double)(ctypes.c_double(-1))\n",
    "\n",
    "# call the function\n",
    "assert gsl.gsl_deriv_central(\n",
    "    ctypes.POINTER(gsl_function)(callback), ctypes.c_double(2), ctypes.c_double(1e-8), p_result, p_abserr) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_result[0], p_abserr[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Doing it in ROOT:** ROOT has a built-in compiler and PyROOT automatically generates bindings, making it almost a one-liner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import ROOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROOT.gInterpreter.Declare(\"\"\"\n",
    "void runs_in_cpp(int N, double* p, double* px, double* py, double* pz) {\n",
    "    int i;\n",
    "    for (i = 0;  i < N;  i++) {\n",
    "        p[i] = sqrt(px[i]*px[i] + py[i]*py[i] + pz[i]*pz[i]);\n",
    "    }\n",
    "}\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "px = numpy.random.normal(0, 10, 1000000)\n",
    "py = numpy.random.normal(0, 10, 1000000)\n",
    "pz = numpy.random.normal(0, 10, 1000000)\n",
    "p = numpy.zeros(1000000)\n",
    "\n",
    "ROOT.runs_in_cpp(1000000, p, px, py, pz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**To mix Python objects with C++ objects, use Cython.**\n",
    "\n",
    "Cython (not CPython!) is a halfway language between Python and C++, with constructs familiar to both.\n",
    "\n",
    "It's usually used as to make libraries (root_numpy, rootpy, NumPythia, pyjet all use it), but I think its Jupyter extension is a killer app."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(continued on next page)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%cython -a --cplus -c-std=c++11 -c-O3\n",
    "\n",
    "import numpy\n",
    "\n",
    "cdef extern from *:\n",
    "    \"\"\"\n",
    "void pure_cpp(int N, double* p, double* px, double* py, double* pz) {\n",
    "    for (int i = 0;  i < N;  i++) {\n",
    "        p[i] = sqrt(px[i]*px[i] + py[i]*py[i] + pz[i]*pz[i]);\n",
    "    }\n",
    "}\"\"\"\n",
    "    void pure_cpp(int N, double* p, double* px, double* py, double* pz)\n",
    "\n",
    "def mixed_python_cpp(px, py, pz):\n",
    "    if not isinstance(px, numpy.ndarray) or not isinstance(px, numpy.ndarray) or not isinstance(px, numpy.ndarray):\n",
    "        raise TypeError(\"should be Numpy arrays\")\n",
    "    cdef int N = len(px)\n",
    "    p = numpy.empty(N)\n",
    "    cdef double* p_ptr = <double*>(<size_t>p.ctypes.data)\n",
    "    cdef double* px_ptr = <double*>(<size_t>px.ctypes.data)\n",
    "    cdef double* py_ptr = <double*>(<size_t>py.ctypes.data)\n",
    "    cdef double* pz_ptr = <double*>(<size_t>pz.ctypes.data)\n",
    "    pure_cpp(N, p_ptr, px_ptr, py_ptr, pz_ptr)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    "px = numpy.random.normal(0, 10, 1000000)\n",
    "py = numpy.random.normal(0, 10, 1000000)\n",
    "pz = numpy.random.normal(0, 10, 1000000)\n",
    "\n",
    "mixed_python_cpp(px, py, pz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyCUDA (and PyOpenCL): arbitrary GPU programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The lowest of low-level programming— programming and running accelerator devices— can be done from the comfort of a notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pycuda\n",
    "import pycuda.autoinit\n",
    "import pycuda.driver\n",
    "import pycuda.compiler\n",
    "\n",
    "compiled_cuda = pycuda.compiler.SourceModule(\"\"\"\n",
    "__global__ void runs_on_gpu(float* p, float* px, float* py, float* pz) {\n",
    "    const int i = blockDim.x * blockIdx.x + threadIdx.x;\n",
    "    if (i < 1000000) {\n",
    "        p[i] = sqrt(px[i]*px[i] + py[i]*py[i] + pz[i]*pz[i]);\n",
    "    }\n",
    "}\"\"\")\n",
    "runs_on_gpu = compiled_cuda.get_function(\"runs_on_gpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "px = pycuda.driver.In(numpy.random.normal(0, 10, 1000000).astype(numpy.float32))\n",
    "py = pycuda.driver.In(numpy.random.normal(0, 10, 1000000).astype(dtype=numpy.float32))\n",
    "pz = pycuda.driver.In(numpy.random.normal(0, 100, 1000000).astype(dtype=numpy.float32))\n",
    "p = numpy.zeros(1000000, dtype=numpy.float32)\n",
    "\n",
    "runs_on_gpu(pycuda.driver.Out(p), px, py, pz, block=(1024, 1, 1), grid=(1000000 // 1024 + 1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Working with Numpy arrays is already GPU-like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pycuda.gpuarray\n",
    "\n",
    "px = pycuda.gpuarray.to_gpu(numpy.random.normal(0, 10, 1000000))\n",
    "py = pycuda.gpuarray.to_gpu(numpy.random.normal(0, 10, 1000000))\n",
    "pz = pycuda.gpuarray.to_gpu(numpy.random.normal(0, 100, 1000000))\n",
    "\n",
    "type(px)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = (px**2 + py**2 + pz**2)**0.5\n",
    "type(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Isn't that what CuPy does? Yes, yes it is.\n",
    "\n",
    "Once, there was also a \"gnumpy\" (U Toronto CS dept). Like Numeric and numarray, this is an active area of development."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numba-CUDA: compile *Python* code on the GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Numba can compile a subset of Python for CPUs with LLVM or GPUs with CUDA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numba.cuda\n",
    "\n",
    "@numba.cuda.jit\n",
    "def runs_on_gpu(p, px, py, pz):\n",
    "    i = numba.cuda.grid(1)\n",
    "    p[i] = math.sqrt(px[i]**2 + py[i]**2 + pz[i]**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "px = numpy.random.normal(0, 10, 1000000)\n",
    "py = numpy.random.normal(0, 10, 1000000)\n",
    "pz = numpy.random.normal(0, 100, 1000000)\n",
    "p = numpy.zeros(1000000)\n",
    "\n",
    "runs_on_gpu(p, px, py, pz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The snake eating its own tail: Numpy+ctypes to hack Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Beyond its use for doing math, Numpy is a tool for interpreting arrays from other sources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import ctypes\n",
    "import numpy\n",
    "\n",
    "jemalloc = ctypes.cdll.LoadLibrary(\"libjemalloc.so\")   # a specialized memory-allocator\n",
    "jemalloc.malloc.argtypes = (ctypes.c_size_t,)\n",
    "jemalloc.malloc.restype = ctypes.POINTER(ctypes.c_double)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ptr = jemalloc.malloc(1000 * numpy.dtype(numpy.float64).itemsize)\n",
    "ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ctypes.addressof(ptr.contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ptr.__array_interface__ = {\n",
    "    \"version\": 3,\n",
    "    \"typestr\": numpy.ctypeslib._dtype(type(ptr.contents)).str,\n",
    "    \"data\": (ctypes.addressof(ptr.contents), False),\n",
    "    \"shape\": (1000 * numpy.dtype(numpy.float64).itemsize,)\n",
    "}\n",
    "array = numpy.array(ptr, copy=False)\n",
    "array[:] = 3.14\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Think about what this means:** we can cast any region in memory as a Numpy array and make arbitrary changes to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<center><img src=\"https://vignette.wikia.nocookie.net/villains/images/a/a4/Evil_Calvin.jpeg/revision/latest?cb=20131009203849&format=original\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "hello = b\"Hello, world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings and byte-strings are immutable in Python; a fact Python uses for optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "hello[4:8] = \"????\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "But if we cast it as a Numpy array and make it writeable..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "array = numpy.frombuffer(hello, dtype=numpy.uint8)\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "array.flags.writeable = True\n",
    "array[4:8] = [69, 86, 73, 76]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can use Python's C API without using C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# C struct of a Python object, represented with ctypes\n",
    "class PyObject(ctypes.Structure): pass\n",
    "PyObject._fields_ = [(\"ob_refcnt\", ctypes.c_size_t), (\"ob_type\", ctypes.POINTER(PyObject))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above is equivalent to\n",
    "\n",
    "```c\n",
    "struct PyObject {\n",
    "    size_t ob_refcnt;\n",
    "    PyObject* ob_type;\n",
    "    // there's more, but we don't need to encode it...\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Not guaranteed in all implementations, but in CPython, `id(obj)` is a C pointer to `obj`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_ptr = PyObject.from_address(id(hello))\n",
    "hello_ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_ptr.__array_interface__ = {\n",
    "    \"version\": 3,\n",
    "    \"typestr\": \"u1\",\n",
    "    \"data\": (ctypes.addressof(hello_ptr), False),\n",
    "    \"shape\": (100,)\n",
    "}\n",
    "array = numpy.array(hello_ptr, copy=False)\n",
    "array.tobytes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The `ob_refcnt` is Python's internal reference count, used by the garbage collector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_ptr.ob_refcnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.getrefcount(hello)   # overcounts by 1 because it's passed as an argument to this function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "another_reference = hello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_ptr.ob_refcnt, sys.getrefcount(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Now try something truly sinister: can we change the type of the object by setting its pointer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class DifferentClass(bytes):\n",
    "    def has_a_method(self):\n",
    "        return self * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# change the class of this object by directly manipulating its pointer\n",
    "hello_ptr.ob_type = ctypes.POINTER(PyObject)(PyObject.from_address(id(DifferentClass)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello.has_a_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dead kernel: the end!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}