tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "79b3ba15-2375-4efd-97de-1c5fa6e6d2d4",
   "metadata": {},
   "source": [
    "# Tutorial: JAX"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a61a4ff0-537e-42cc-bdfd-2a76ca8de292",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## JAX: Intro\n",
    "\n",
    "At a high level, jax is an extensible system for composable function transformations based on trace-specializing functional python code. These transformations include:\n",
    "\n",
    "- Just In Time Compilation\n",
    "- Automatic Differentiation\n",
    "- Automatic Vectorization\n",
    "- Single Program Multiple Device (SMPD) transformations.\n",
    "- And more...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89bfe947-f766-4771-90cf-711f3d086e04",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "The functions on which jax can operate must:\n",
    "\n",
    "- take a (collections of) tensor-like inputs and return (collections of) tensor-like outputs, which are instances of the `DeviceArray` class (similar to np.ndarry instances)\n",
    "- manipulate these tensors using only a set of (closed) primitives exposed in the `jax` libraries, for the most part in the `jax.numpy` and `jax.scipy` modules, and which often have a direct equivalent in `numpy` or `scipy`\n",
    "- be functionally pure: running the same function with the same inputs should yield the same outputs. Functional programming should feel natural when the code logic is the direct translation of mathemtatical operations, a case which is very frequent in Machine Learning.\n",
    "\n",
    "\n",
    "We will start with a few very examples, and expand on that."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a294589-a6ed-40f5-a7a4-242e237d7dc6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Starting simple... The gaussian kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ae21ec89-b9a1-455d-953c-72532653acf5",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import jit, grad, vmap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "664690cf-3eea-4772-ac4e-ee45260b3f21",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "The `gaussian_kernel` function is a jax implementation of the famous gaussian kernel:\n",
    "$$ k(x, y) = e^{-\\frac{\\|x - y\\|^2}{\\sigma^2}}$$\n",
    "\n",
    "A function often used when implementing kernel-based methods, such as [Kernel Regression](https://en.wikipedia.org/wiki/Kernel_regression)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8eb17e5b-ad06-4919-b10b-290f6d743463",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def gaussian_kernel(x, y):\n",
    "    sigma = 2\n",
    "    z = x - y\n",
    "    return jnp.exp(-jnp.sum(jnp.square(z)) / sigma ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "60ef0206-4aef-4b64-b1a0-a168213bcaf9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray(0.60653067, dtype=float32)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_input = jnp.ones((2,))  # [0., 0.]\n",
    "y_input = jnp.zeros((2,))  # [1., 1.]\n",
    "retval = gaussian_kernel(x_input, y_input)\n",
    "retval"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922cde14-db48-4379-8731-82c92fd08a5e",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "The gaussian kernel relies on the following jax primitives: `jnp.sum`, `jnp.square`, and `jnp.exp`, which are the jax-analogues of `np.sum`, `np.square` and `np.exp`. Almost all `numpy` primitives are present in `jax.numpy`, including traditional linear algebra operations like `jnp.dot` or `jnp.matmul`.\n",
    "\n",
    "This function satisfies all the constraints enumerated in the introductory paragraph of this section: it takes as input 2 jax arrays, return a scalar (0-th order jax array), and is pure (same input->same output). We can thus apply jax transformations on it!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55861338-3dd4-40ef-9586-388d927184ca",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Jax Transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ade6e9ca-f328-4430-ba90-5b9bfd483b68",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### JIT compilation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6d7ac895-e6b3-4bff-b5e9-8306b3470447",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# just-in-time compilation\n",
    "jitted_gaussian_kernel = jit(gaussian_kernel)\n",
    "assert gaussian_kernel(x_input, y_input) == gaussian_kernel(x_input, y_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb30fc49-3860-4c99-a1a7-3b375b9595a7",
   "metadata": {
    "tags": []
   },
   "source": [
    "The JIT-compiled version of `gaussian_kernel`, `jitted_gaussian_kernel` executes the same end-to-end mathematical operations, makes additional software and harware optimizations to speed up computations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "97aa17d7-d822-470a-a01a-c2edffefdf0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.3 µs ± 147 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit gaussian_kernel(x_input, y_input).block_until_ready()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c2ffc3ea-b12f-417d-89b5-2d8cea507000",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3 µs ± 57.4 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit jitted_gaussian_kernel(x_input, y_input).block_until_ready()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75d37c83-691e-453e-8f25-eef4b9c6ec36",
   "metadata": {},
   "source": [
    "The speedup here is minimal, due to the fact that the function `gaussian_kernel` is quite simple: there is not much optimizations to perform.\n",
    "We will see other use cases where the speedup yieled by jit-compilation of such functions can become significant."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c509077-fe69-4863-889f-34bcf897226f",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### Automatic differentiation\n",
    "\n",
    "Jax can compute derivatives of functions with respect to one or several arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e3573043-703f-4c33-885a-07b17ac1a39a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([-0.30326533, -0.30326533], dtype=float32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# automatic differentiation\n",
    "d_dx_gaussian_kernel=grad(gaussian_kernel, argnums=0)  # compute the partial derivative of gaussian_kernel w.r.t x\n",
    "d_dx_gaussian_kernel(x_input, y_input)  # returns a 2-d vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b72448b9-d6ae-410f-b4e5-90b7f3274951",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### Automatic vectorization\n",
    "\n",
    "Last but not least, jax can also \"automatically vectorize\" a function. The vectorized function:\n",
    "- takes as input a \"batch\" input tensors, stacked in a new dimension\n",
    "- applies the original function to all  input tensors in the batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b230cf65-3a6f-41a5-8fde-09a93e141706",
   "metadata": {},
   "outputs": [],
   "source": [
    "vmapped_gaussian_kernel = vmap(gaussian_kernel, in_axes=(0, None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9c8e506e-3891-471f-868b-27019f70d364",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([1.        , 0.60653067], dtype=float32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_of_x_inputs = jnp.stack((jnp.zeros((2,)), jnp.ones((2,))))\n",
    "vmapped_gaussian_kernel(batch_of_x_inputs, y_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1159d42e-59f8-4492-a344-62ff98833536",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### Arbitrary transformation composition\n",
    "\n",
    "Importantly, all these transformations can be composed together (!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "231a5524-346c-45c8-af0b-ca82db740d39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([[-0.        , -0.        ],\n",
       "             [-0.30326533, -0.30326533]], dtype=float32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jit(vmap(grad(gaussian_kernel), in_axes=(0, None)))(batch_of_x_inputs, y_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c86aad-47cb-4f49-a442-6a57b8dc05ac",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "With these basic building blocks in mind, we can start implementing interestiting mathematical and statistical objects. As you will see, using the function transformations provided by \n",
    "jax will often benefit you in one or multiple of the following ways:\n",
    "\n",
    "- reduce code complexity, increase code readability\n",
    "- increase code efficiency"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41fb74c3-e527-43e0-b044-f9dcd81bf322",
   "metadata": {},
   "source": [
    "### Exercise 1: Computing the (Gaussian Kernel) gram matrix between two datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3acd4131-e729-47ed-8519-97a88604fe28",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "As a first nontrivial composition exercise, try to implement a function that computes the **gram matrix** between two datasets $X = \\{x_i\\}_{i=1}^{n}$ and $X = \\{y_i\\}_{i=1}^{m}$, for a given kernel $k$. This gram matrix is given by:\n",
    "    \n",
    "    \n",
    "$$\n",
    "M = \\begin{vmatrix}\n",
    "k(x_1, y_1) & \\dots & k(x_1, y_m)\\\\\n",
    "\\vdots & \\ddots & \\vdots \\\\\n",
    "k(x_n, y_1) & \\dots & k(x_n, y_m)\\\\\n",
    "\\end{vmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e53ccace-db4f-415b-ba88-c3a5d0336bd2",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "random_state = np.random.RandomState(42)\n",
    "X = random_state.randn(100, 2)\n",
    "Y = random_state.randn(200, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7294df9d-f253-442c-be38-260dfc291871",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "#### numpy-style implementations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb8ecf36-55a8-4fe0-8e71-7e15ebb2de4b",
   "metadata": {},
   "source": [
    "A naive implementation would consists in two nested for-loops that iterates over X and Y to compute each element of the matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ee4d029d-c36b-477c-9cbc-3092e41bfbf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gram_matrix_naively(X, Y):\n",
    "    gram_matrix = np.empty((X.shape[0], Y.shape[0]))\n",
    "    for i in range(X.shape[0]):\n",
    "        for j in range(Y.shape[0]):\n",
    "            kij = gaussian_kernel(X[i], Y[j])  # note the interoperability between jax and numpy arrays within **untransformed** jax funtions\n",
    "            gram_matrix[i, j] = kij\n",
    "    return gram_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "aa26bae6-6835-4e55-8291-7ca3319f20b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "M_naive = compute_gram_matrix_naively(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09b880d6-021a-465d-9b8b-63d9be6620d1",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "A more efficient implementation consists in leveraging numpy's broadcasting abilities to compute the entries of the gram matrix in a vectorized manner.\n",
    "Note that this requires plumbing axis values in reduction operations happening during the kernel computation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "437676b6-b054-427c-ba86-6ba0a0babea4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gaussian_kernel_explicit_reduction_axes(x, y):\n",
    "    sigma = 2\n",
    "    z = x - y\n",
    "    # we add a axis=-1 to prevent numpy from summing over all axes when giving gaussian_kernel a stack of tensors.\n",
    "    # return jnp.exp(-jnp.sum(jnp.square(z)) / sigma ** 2)\n",
    "    return jnp.exp(-jnp.sum(jnp.square(z), axis=-1) / sigma ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bf3a5a6c-f1c4-4ca0-bf00-f96da0f71368",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gram_matrix_bcast_semantics(X, Y):\n",
    "    return gaussian_kernel_explicit_reduction_axes(X[:, None, :], Y[None, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a752c3d7-3f9a-4521-9214-b5aab5fec8c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "M_bcast = compute_gram_matrix_bcast_semantics(X, Y)\n",
    "assert np.allclose(M_naive, M_bcast)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb590f0f-1855-4e88-9deb-d29bafd77c56",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "Benchmarking these two functions highlights the dramatically higher efficiency of the latter method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d89c1d1f-3acb-4b26-a24b-3097a4e58192",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "286 ms ± 3.72 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit M_naive = compute_gram_matrix_naively(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5a2475e2-c16b-4da4-885b-e33618a72b81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "213 µs ± 5.82 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit M_bcast = compute_gram_matrix_bcast_semantics(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9cb735-f547-462b-8f82-692e6685a2d2",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "However, the latter method required:\n",
    "\n",
    "- rewriting `gaussian_kernel` to account for the case when it is given batched inputs. What if `gaussian_kernel` is replaced by a much more complex function? What is it is replaced by a third-party function that you are not familiar with?\n",
    "- relying on broadcasting semantics in `compute_gram_matrix_bcast_semantics`: althought in that case, the use of such semantics was quite simple, its use in complex code base can quickly become error-prone."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd07bd73-cc67-472c-a68c-47df3f789915",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "#### Jax-implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f700875e-b672-4c39-b67b-e355b01d2864",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: combine of vmap and gaussian_kernel within compute_gram_matrix_using_vmap to compute the gram matrix between X and Y\n",
    "def compute_gram_matrix_using_vmap(X, Y):\n",
    "    raise NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a143ddf1-8a5e-4ea0-a519-2cfc777f2587",
   "metadata": {},
   "outputs": [],
   "source": [
    "M_vmap = compute_gram_matrix_using_vmap(X, Y)\n",
    "assert np.allclose(M_vmap, M_bcast)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5acaaa09-a7a6-454e-b9e8-0f0912d8c213",
   "metadata": {},
   "outputs": [],
   "source": [
    "jitted_gaussian_kernel = jit(gaussian_kernel)\n",
    "_ = jitted_gaussian_kernel(jnp.ones((2,)), jnp.zeros((2,))).block_until_ready()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a056ab3-6fca-4c36-8c3b-d39d3973d393",
   "metadata": {},
   "source": [
    "### Exercise 2: A jax-implementation of the Kernelized Stein Discrepancy.\n",
    "\n",
    "\n",
    "Further composition of `vmap`, `jit` and `grad` happens when computing the infamous `Stein` kernel, which is used to evaluate whether samples $\\{x_i\\}_{i=1}^{n}$ are distributed according to a test density $q(x) = p(x) / Z$ known up to a normalizing constant Z. Given some given kernel $k$, Writing $s(x) = \\nabla \\log p(x)$, the stein kernel writes:\n",
    "\n",
    "$$\n",
    "k_{\\textrm{stein}}(x, y) = s(x)^\\top s(y)k(x, y) + s(x)^\\top \\nabla_yk(x, y) + \\nabla_x k(x, y)^\\top s(y) + \\textrm{div}_x(∇_yk(x, y))\n",
    "$$\n",
    "\n",
    "which can be used to compute a measure of discrepancy between the samples and the density $p$, called the Kernelized Stein Discrepancy (or KSD):\n",
    "\n",
    "$$\n",
    "\\text{KSD}(p, x) = \\sqrt{ \\frac{1}{N^2} \\sum_{i=1}^n \\sum_{j=1}^n k_{\\textrm{stein}}(x_i, y_j)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3516c328-d001-495b-b758-f9372697db83",
   "metadata": {},
   "source": [
    "As an exercise, compute KSD between $p$ and  $X$ and using the gaussian kernel as the base kernel, and $p$ being standard normal distributio\n",
    "We will place ourselves under the null hypothesis, meaning that $X$ will be sampled from $p$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1ad2457f-0879-4640-91c2-380aa6028c28",
   "metadata": {},
   "outputs": [],
   "source": [
    "def p(x):\n",
    "    return jnp.exp(-0.5 * jnp.sum(jnp.square(x))) #  unnormalized standard normal density\n",
    "\n",
    "s = ...  # compute the score function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "72df2649-5067-482c-a116-00001b1cb4f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "s = grad(lambda x: jnp.log(p(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "21ffa12f-8032-45c1-98ec-87cc329cf19b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You will need the jacobian function transformation of jax, which computes the jacobian of a vector-valued function\n",
    "from jax import jacobian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0760266f-9f58-4f21-8299-eb71f19ec634",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stein_kernel(x, y):\n",
    "    k = gaussian_kernel\n",
    "    term_1 = jnp.dot(s(x), s(y)) * k(x, y)\n",
    "    term_2 = ...\n",
    "    term_3 = ...\n",
    "    term_4 = ...\n",
    "    \n",
    "    return term_1 + term_2 + term_3 + term_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c29f9790-7b8b-4c6e-a490-8d3ecfecd25b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gram_matrix_stein_kernel(X):\n",
    "    return vmap(vmap(stein_kernel, in_axes=(None, 0)), in_axes=(0, None))(X, X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e3b506e-754c-4e7b-98d4-3202e1d46567",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ksd(X):\n",
    "    return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b732e0ce-12fd-47c3-bba1-6ef2616a3d21",
   "metadata": {},
   "outputs": [],
   "source": [
    "from jax import random\n",
    "key = random.PRNGKey(0)\n",
    "X = random.normal(key, (5000,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3fd341-7705-4570-9ca0-2f27607630ae",
   "metadata": {},
   "source": [
    "Under the null hypothesis KSD(X, p) should tend to 0 at a $1/\\sqrt{N}$ rate. Given that X is actually sampled from a unit gaussian, we should recover this regime if we implemented\n",
    "the KSD properly. The following cells will plot the relationship between $1/\\sqrt{N}$ and $\\text{KSD}(X, p)$ for different sample size $N$ for X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "73272e70-12d4-46f4-a460-6d4dab6fe0e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_sizes = (50, 100, 200, 300, 500, 1000, 2000, 5000)\n",
    "random_state = np.random.RandomState(40)\n",
    "\n",
    "ksd_vals = []\n",
    "for N in sample_sizes:\n",
    "    ksd_vals_this_iter = []\n",
    "    for rs in range(5):\n",
    "        X = random_state.randn(N, 2)\n",
    "        ksd_vals_this_iter.append(ksd(jnp.array(X)))\n",
    "    ksd_vals.append(jnp.mean(jnp.array(ksd_vals_this_iter)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6b46607b-7aae-4690-a619-76215260b7a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1680f8820>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABl3UlEQVR4nO3dd3yN9///8cfJToggNkFixxZ701pVNapiFjVq1eqgA61WVZWqWTWqVqQtLW21pZTaKhXUqiBmgiBDQsY51+8PX/l9UqMJOTkZz/vtltvNuc41XtdbnPP0vq73+zIZhmEgIiIikoPY2boAERERkYymACQiIiI5jgKQiIiI5DgKQCIiIpLjKACJiIhIjqMAJCIiIjmOApCIiIjkOA62LiAzslgsXL58GXd3d0wmk63LERERkVQwDIOYmBiKFSuGnd2j+3gUgB7g8uXLeHl52boMEREReQwXLlygRIkSj1xHAegB3N3dgbsNmCdPHhtXIyIiIqkRHR2Nl5dX8vf4oygAPcC9y1558uRRABIREcliUnP7im6CFhERkRxHAUhERERyHAUgERERyXF0D9ATMJvNJCYm2roMeQQnJ6f/HAopIiI5jwLQYzAMg/DwcCIjI21divwHOzs7vL29cXJysnUpIiKSiSgAPYZ74adQoUK4ublpssRM6t6ElmFhYZQsWVJ/TyIikkwBKI3MZnNy+PH09LR1OfIfChYsyOXLl0lKSsLR0dHW5YiISCahmyPS6N49P25ubjauRFLj3qUvs9ls40pERCQzUQB6TLqckjXo70lERB5EAUhERERyHAUgERERyXEUgERERCTHUQDKQfr160enTp1SLPv2229xcXHh448/JjY2lnHjxuHj44OLiwsFCxakefPm/Pjjj8nrN2/eHJPJhMlkwtnZmeLFi9OhQwfWrVuXwWcjIiLy+BSAcrDFixfTq1cv5s6dyxtvvMGQIUP4/vvvmTt3LidOnOCXX37h+eef5/r16ym2GzRoEGFhYYSEhLB27Vp8fX3p3r07gwcPttGZiIhIVmCxWJg2bRqff/65rUvRPEDpwTAMbifaZpi1q6P9Y410+vjjj5k4cSKrV6/m+eefB+CHH37gs88+45lnngGgdOnS+Pn53betm5sbRYoUAcDLy4v69etTsWJFXnrpJbp168bTTz/9BGckIiLZ0ZUrV3jxxRfZtGkTTk5OtG7dGh8fH5vVowCUDm4nmvGd+KtNjn1schvcnNL21zh+/HjmzZvHjz/+mCKsFClShI0bN9KlSxfc3d3TtM++ffvy6quvsm7dOgUgERFJYcuWLfTu3Zvw8HBcXV2ZPXs23t7eNq1Jl8BymJ9//plp06axfv36+4LKF198we7du/H09KROnTqMGTOGXbt2pWq/dnZ2lC9fntDQUCtULSIiWVFSUhLvvPMOrVq1Ijw8nMqVK/Pnn38ycOBAm8/Tph6gdODqaM+xyW1sduy0qFatGhEREUycOJE6deqk6Olp2rQpZ86cYe/evezatYutW7fy2Wef8d577zFhwoT/3LdhGDb/hRYRkczBbDbTqlUrtm3bBsDgwYP59NNPM82TFNQDlA5MJhNuTg42+Ulr4ChevDjbt28nLCyMtm3bEhMTk+J9R0dHmjRpwvjx49m0aROTJ0/m/fffJyEh4ZH7NZvNnDp1yuZdmiIikjnY29vTunVr8uTJw5o1a1i4cGGmCT+gAJQjlSxZku3bt3P16lVat25NdHT0Q9f19fUlKSmJO3fuPHKfX331FTdv3ky+oVpERHKe+Ph4Lly4kPx63Lhx/P333/j7+9uwqgfTJbAcqkSJEmzbto0WLVrQunVrfv31Vzp27EiPHj2oXbs2np6eHDt2jLfeeosWLVqQJ0+e5G3j4uIIDw8nKSmJS5cusW7dOj799FOGDh1KixYtbHhWIiJiKyEhIfj7+xMfH8/+/ftxc3PDzs4OLy8vW5f2QOoBysHuXQ6LjIykVatWtGnThq+++orWrVtTqVIlXnnlFdq0acPXX3+dYrtFixZRtGhRypQpQ+fOnTl27BiBgYHMnz/fRmciIiK2tHr1amrWrMlff/1FeHg4J0+etHVJ/8lkGIZh6yIym+joaDw8PIiKikrR8wFw584dzp49i7e3Ny4uLjaqUFJLf18iItYTGxvLyJEjWbp0KXB3MM2qVasoUaKETep51Pf3v6kHSERERNLsyJEj1KlTh6VLl2IymZg4cSJbtmyxWfhJK90DJCIiImn2+uuvc/z4cYoWLcqqVavSdA/opcjbWCwGXvltNypMPUAiIiKSZosXL6ZHjx4EBwenOvycux7L+LWHaT79d6b+fNzKFT6aeoBERETkP+3fv58tW7bw5ptvAndHE69evTpV24ZcvcX830NYf+gyZsvdW4+jbieSkGTBycE2fTEKQCIiIvJQFouFTz/9lPHjx5OUlETVqlV59tlnU7XtifBo5m4N4acjYdwbctWsfEFeaVmW2qXzW7Hq/6YAJCIiIg8UERFB37592bhxIwBdu3alcePG/7nd35eimL3lFJuOXUle9nSlwrzSsizVvfJaq9w0UQASERGR+2zfvp2ePXty+fJlnJ2dmTVrFi+//PIjH8H01/mbzNlyit9PXgPAZIJ2VYowokU5fIs9elh6RlMAEhERkRQ++eQTxo0bh8VioWLFigQGBlKtWrWHrr/vzHXmbA1hZ0gEAHYmeK56MYa3KEu5wu4P3c6WNAosB2nevDmjR49Ofl26dGlmzZpls3r+S3h4OK1atSJXrlzkzZsXuPvg2e+//96mdYmIZHelS5fGYrHQr18/Dhw48MDwYxgGO05do9vne/D/Yi87QyJwsDPxgl8JtrzanFnda2ba8APqAcrR/vzzT3LlymXrMh7q008/JSwsjODgYDw8PAAICwsjX758AISGhuLt7c3BgwepUaOGDSsVEcn6bt68mfz52rVrV/bt20fdunXvW88wDH4/eZXZW0IIvhAJgJO9HV1rl2BoszI2ndsnLRSAcrCCBQvaugQAEhMTcXR0vG/56dOn8fPzo1y5csnLihQpkpGliYhkewkJCbz11lusWLGCgwcPUqxYMYD7wo/FYrDp2BXm/n6Kvy9FA+DsYEePuiV5uZkPRT1cM7z2J6FLYDnYvy+BmUwmFi9eTOfOnXFzc6NcuXJs2LAhxTbHjh3jmWeeIXfu3BQuXJg+ffoQERGR/P4vv/xC48aNyZs3L56enjz77LOcPn06+f3Q0FBMJhNff/01zZs3x8XFhZUrVz6wtrVr17J8+XJMJhP9+vVLrvHeJTBvb28Aatasiclkonnz5unTMCIiOcSZM2do0qQJM2bM4OrVq/d95gOYLQY/HLpMu892MGRlEH9fisbNyZ7BTX3YMa4F7z5XOcuFH1AASlexsbEP/blz506q1719+3aq1rWG9957j27dunH48GGeeeYZevXqxY0bN4C7l5+aNWtGjRo1OHDgAL/88gtXrlyhW7duKWodO3Ysf/75J1u2bMHOzo7OnTtjsVhSHGfcuHGMHDmS48eP06ZNm/vq+PPPP2nbti3dunUjLCyMzz777L519u/fD8Bvv/1GWFgY69atS8+mEBHJ1r755htq1qzJ/v37yZcvH99//z1DhgxJfj/JbGFt0EVafbqdVwIOcvJKDLmdHRjeogw7x7XkrWcqUcg96z5kWpfA0lHu3Lkf+t4zzzzDTz/9lPy6UKFCxMXFPXDdZs2asW3btuTXpUuXTtHLco9xb1apdNSvXz969OgBwIcffsicOXPYv38/bdu2ZcGCBdSqVYsPP/wwef2lS5fi5eXFP//8Q/ny5Xn++edT7G/JkiUUKlSIY8eOUaVKleTlo0ePpkuXLg+to2DBgjg7O+Pq6vrQy173LuF5enrq0piISCrdvn2bMWPGsHDhQgAaNmxIQEAAJUuWBCAhycK6vy4yf9tpzt+4+z2Vx8WBlxp707+hNx5u99+ykBUpAEkK/3unf65cuXB3d+fq1asABAUF8fvvvz8w6J0+fZry5ctz+vRpJkyYwN69e4mIiEju+Tl//nyKAFS7dm0rn4mIiDzI1KlTWbhwISaTiTfffJN3330XR0dH7iSa+ebABT7ffoZLkXevROTP5cTAJt70qV8Kd5fsEXzuUQBKR7du3Xroe/b29ile3wsVD2Jnl/LKZGho6BPVlRb/vhnZZDIlhxiLxUKHDh2YNm3afdsVLVoUgA4dOuDl5cWiRYsoVqwYFouFKlWqkJCQkGL9zDz6TEQkOxs3bhw7duzgrbfeolWrVtxOMPPVjjN88ccZrsbEA1DQ3ZmXm/rQs15J3JyyZ1TInmdlI2n5UrfWutZUq1Yt1q5dS+nSpXFwuP9X5/r16xw/fpyFCxfSpEkTAHbu3Gm1epycnAAwm81WO4aISFYXExPDwoULGTt2LHZ2duTKlYutW7cSm2BmwbbTLN5xhuuxd/+TWtTDhSHNyuBfxwsXR/v/2HPWpgAkqTZ8+HAWLVpEjx49eP311ylQoAAhISGsWbOGRYsWkS9fPjw9Pfniiy8oWrQo58+fZ/z48Varp1ChQri6uvLLL79QokQJXFxckucLEhGRu7cudO/enZCQEAzD4PXXXyfqdiJf7Q5l6a6zRMYlAuCV35VhzcvSpVZxnB2yd/C5R6PAJNWKFSvGrl27MJvNtGnThipVqjBq1Cg8PDyws7PDzs6ONWvWEBQURJUqVRgzZgzTp0+3Wj0ODg7Mnj2bhQsXUqxYMTp27Gi1Y4mIZCWGYTB79mwaNGhASEgIXl5eVKlZh09+PUnjj7Yyc/M/RMYl4lMgF5+8UJ2trzanR92SOSb8AJgMawwlyuKio6Px8PAgKiqKPHlSPrztzp07nD17Fm9vb1xcsu7wv5xCf18iktPcuHGDl156ifXr1wPQtn0Havd5k7VHo4hLuHvLQPnCuRneoizPViuGvd3DH26a1Tzq+/vfdAlMREQkm9i3bx8vvPACFy5cwMnJiaf6vcrpgo05fvDufG6+RfMw8qmytPYtgl02Cj6PQwFIREQkm7C3tyc8PJz8RUuRq92rHMvnA0kG1b3yMrJlWVpWLITJlLODzz0KQCIiIlnYvecphkbE8nWoIwW6TMChaEXsnN2oUzofr7QsR5NyBRR8/kUBSEREJIvatGkT/QcMpPmI6eyJzI3FAKfStWhU1pNXWpajvo+nrUvMtBSAHpPuHc8a9PckItlRYmIiw8aOY/HcTwH4fulsCnZ+i+YVCvJKy3L4lcpn4wozPwWgNLo3U3JcXByurlnv6bc5zb0ZqP89E7eISFb1694jvNinF1dDjgCQu0Y7Xhj+FqPbVqFaiby2LS4LUQBKI3t7e/LmzZv8KAs3NzddV82kLBYL165dw83N7YEzV4uIZCVB527y2vRF/LF4Mpb4WEzObrR6eSKzxg+lUtFHD/mW++lb4THce/L4o57nJZmDnZ0dJUuWVEgVkSxr75nrzNl6it82b+bq1xMBKFymCgEBq2lRp6qNq8u6FIAeg8lkomjRohQqVIjExERblyOP4OTkdN/DZUVEMjvDMNhxKoK5W0PYH3p3Dp/cPjVxq96AVo3rMnfmx8nPQ5THowD0BOzt7XVviYiIpBvDMNh64ipztoYQfCGSuJO7yVOuNt0blmVIszIUeb+tLumnE7WiiIiIjVksBpuOhTNnawhHL0djSbhN1JaFRB/+jVYv9ueDTkttXWK2owAkIiJiI2aLwY+HLzPv9xD+uXILALub54ndOJ3oi2exs7OjQpnSGIahexnTmQKQiIhIBks0W1gffJn5v4dwJiIWgNxO9lS4uZefvvqI+Ph4ihUrxurVq2nWrJmNq82eFIBEREQySEKShbV/XWT+thAu3LgNQF43R7pX92TPsims+/47ANq3b8+yZcsoUKCALcvN1hSARERErOxOopnAPy/w+fbThEXdAcAzlxODmvrQu34pIq+F88mAP3B0dOSjjz5izJgxuuRlZQpAIiIiVhKXkMTqfedZ+McZrsXEA1DI3ZmXm5WhRx0v3Jzvfg3nLlGCgIAA8ubNS506dWxZco6hACQiIpLOYu4ksmLvORbvOMuN2LuP5Cnm4cLQ5mV4obYX0Tev83ynDrz88st06tQJgFatWtmw4pxHAUhERCSdRMUl8uXus3y5K5So23cnyi2Z343hLcrQuWYJnBzs2Lp1K7169SI8PJzDhw/Trl07nJ2dbVx5zqMAJCIi8oRuxCawZOcZlu8+R0x8EgA+BXMxokVZnqteDAd7O5KSkpgwYRJTpkzBMAx8fX0JDAxU+LERBSAREZHHdDXmDot3nGXl3nPEJZgBqFDYnREty/JM1aLY2929kfnixYv07NmTHTt2ADBgwABmz56Nm5ubzWrP6RSARERE0ig86g6fbz9NwP7zxCdZAKhSPA+vtCxHq0qFsbP7/yO4rl69So0aNbh+/Tru7u4sXLiQHj162Kp0+T8KQCIiIql04UYcC7af5tsDF0kw3w0+NUvmZWTLcjSvUPCBQ9cLFSpEt27d2L9/P2vWrKFs2bIZXbY8gAKQiIjIfwiNiGXe7yF8d/ASSRYDgLre+RnZshyNynreF3xOnz6Nm5sbRYsWBWDmzJmYTCbd75OJKACJiIg8RMjVGOZuDWHDocv8X+6hSbkCjGhRlno+ng/cZs2aNQwePJjatWuzefNm7O3tcXFxycCqJTUUgERERP7l2OVo5v5+ip//Dsf4v+DTsmIhRrQsS62S+R64TVxcHKNGjWLx4sUAJCYmEh0dTb58D15fbMvO1gXMnz8fb29vXFxc8PPzS75D/kHWrVtHq1atKFiwIHny5KFBgwb8+uuv9623du1afH19cXZ2xtfXl++++86apyAiItnE4YuRDPzqAM/M3sHGI3fDT5vKhfnxlcYs7VfnoeHn6NGj1K1bl8WLF2MymXjnnXf4/fffFX4yMZsGoMDAQEaPHs3bb7/NwYMHadKkCe3ateP8+fMPXP+PP/6gVatWbNy4kaCgIFq0aEGHDh04ePBg8jp79uzB39+fPn36cOjQIfr06UO3bt3Yt29fRp2WiIhkMUHnbtB36X6em7uL345fwWSCZ6sV5ZfRTVjYpzZVins8cDvDMFi0aBF16tTh6NGjFClShN9++433338fBwddZMnMTIZxr3Mv49WrV49atWqxYMGC5GWVKlWiU6dOTJ06NVX7qFy5Mv7+/kycOBEAf39/oqOj+fnnn5PXadu2Lfny5SMgICBV+4yOjsbDw4OoqCjy5MmThjMSEZGswjAM9py5zpwtIew5cx0AezsTHWsUY3iLspQpmPs/93Hnzh1q1arF8ePHad26NStWrKBQoULWLl0eIi3f3zaLpwkJCQQFBTF+/PgUy1u3bs3u3btTtQ+LxUJMTAz58+dPXrZnzx7GjBmTYr02bdowa9ash+4nPj6e+Pj45NfR0dGpOr6IiGQ9hmHwx6kI5mw5xYFzNwFwtDfxfK0SDG1ehlKeuVK9LxcXFwIDA/n555957bXXsLOz+Z0lkko2C0ARERGYzWYKFy6cYnnhwoUJDw9P1T5mzJhBbGws3bp1S14WHh6e5n1OnTqV9957Lw3Vi4hIVmMYBluOX2XO1lMcuhgFgJODHf61vRjSvAzF87qmah+zZs3CZDIxevRoAKpWrUrVqlWtWbpYgc0vUP577gTDMB44kdS/BQQE8O6777J+/fr7uhvTus8333yTsWPHJr+Ojo7Gy8srNeWLiEgmZ7EY/HI0nDlbQzgedreH38XRjl71SjG4qQ+F86RuiHpERAT9+/fnxx9/xMHBgbZt21KxYkVrli5WZLMAVKBAAezt7e/rmbl69ep9PTj/FhgYyIABA/jmm294+umnU7xXpEiRNO/T2dlZk1OJiGQzZovBj4cvM3drCKeu3gIgl5M9fRqUZmATbwrkTv3n/h9//EHPnj25dOkSzs7OzJw5kwoVKlirdMkANrtY6eTkhJ+fH5s3b06xfPPmzTRs2PCh2wUEBNCvXz9Wr15N+/bt73u/QYMG9+1z06ZNj9yniIhkH4lmC98cuMDTM7czak0wp67ewt3FgZEty7JzXEvGt6uY6vBjNpuZPHkyLVq04NKlS1SoUIG9e/cybNiwVF2tkMzLppfAxo4dS58+fahduzYNGjTgiy++4Pz58wwZMgS4e2nq0qVLLF++HLgbfl588UU+++wz6tevn9zT4+rqiofH3SGKo0aNomnTpkybNo2OHTuyfv16fvvtN3bu3GmbkxQRkQwRn2RmbdAl5m8L4eLN2wDkdXNkYGNvXmxYmjwujmnan2EYtG/fPnm+ub59+zJ37lxy5/7v0WGS+dk0APn7+3P9+nUmT55MWFgYVapUYePGjZQqVQqAsLCwFHMCLVy4kKSkJIYPH87w4cOTl/ft25dly5YB0LBhQ9asWcM777zDhAkTKFOmDIGBgdSrVy9Dz01ERDLGnUQza/afZ+EfZwiLugNAgdxODGriQ+/6pcjl/HhfdSaTibZt27Jz504WLFhAnz590rNssTGbzgOUWWkeIBGRzC8uIYlVe8/zxY4zXIu5O5VJ4TzOvNy0DD3qlsTVyT7N+0xMTCQsLIySJUsCd3uBLly4kPxaMrcsMQ+QiIjI44i5k8jyPedYsvMsN2ITACie15WhzcvwQu0SODukPfgAhIaG0r17d27cuEFQUBDu7u6YTCaFn2xKAUhERLKEqLhElu46y5e7zhJ9JwmAUp5uDG9els61iuNo//jjetauXcuAAQOIiooib968HDt2TLdOZHMKQCIikqldvxXPkp1nWb7nHLfi7wafMgVzMaJlWTpUK4bDEwSfO3fuMHbs2ORHMtWvX5+AgABKly6dHqVLJqYAJCIimdLV6Dss2nGGlXvPczvRDEDFIu680rIcbasUwd7uyYahnzhxAn9/fw4fPgzAuHHjeP/993F0TNtoMcmaFIBERCRTuRx5m4XbTxPw5wUSkiwAVC3uwSsty/J0pcLYPWHwuefNN9/k8OHDFCxYkBUrVtCmTZt02a9kDQpAIiKSKVy4Ecf8baf5NugCiea7A5RrlczLK0+Vo3n5guk+8eDnn3+Oi4sLM2fOpGjRoum6b8n8FIBERMSmzly7xfxtp/nu4CXMlrvBp75Pfka2LEeDMp7pFnwOHjzIDz/8wMSJE4G7D8oOCAhIl31L1qMAJCIiNvHPlRjmbg3hx8OX+b/cQ5NyBRj5VDnqlM6fbscxDIN58+bx6quvkpCQgK+vL127dk23/UvWpAAkIiIZ6ujlKOZuDeHnv///g6ufrlSIES3LUcMrb7oe6+bNmwwYMIDvvvsOgOeee44WLVqk6zEka1IAEhGRDHHoQiRztp7it+NXk5e1q1KEES3LUrmYR7ofb/fu3fTo0YPz58/j6OjI9OnTGTlypB5iKoACkIiIWNmB0BvM3hrCH/9cA8DOBM9WK8aIlmUpX9jdKsecO3cuo0ePxmw2U7ZsWdasWYOfn59VjiVZkwKQiIikO8Mw2HP6OrO3nmLvmRsA2NuZ6FyzOMOal8GnoHWfqO7t7Y3ZbKZnz54sWLBAz3WU+ygAiYhIujEMg+3/XGPO1hCCzt0EwNHeRFc/L4Y1L4NXfjerHfvmzZvky5cPgPbt27Nv3z7q1KmjS17yQApAIiLyxAzD4LfjV5mz9RSHL0YB4ORgR486XrzcrAzF8rpa7dhJSUlMmjSJhQsXEhQURKlSpQCoW7eu1Y4pWZ8CkIiIPDaLxeDnv8OZs/UUJ8JjAHB1tKd3/ZIMauJDoTwuVj3++fPn6dmzJ7t27QJg3bp1jBkzxqrHlOxBAUhERNIsyWzhx8NhzP09hJCrtwDI7ezAiw1KMaCxN565na1ew/r16+nfvz83b94kT548fPHFF/j7+1v9uJI9KACJiEiqJZotfHfwEvN/DyH0ehwAeVwc6N/Im/6NSpPXzcnqNcTHx/P6668zZ84cAOrUqcOaNWvw8fGx+rEl+1AAEhGRVFn310VmbPqHS5G3Acify4kBjb15sUEp3F0y7gnqM2fOTA4/r776Kh9++CFOTtYPXpK9KACJiMh/WrDtNNN+OQFAgdzOvNzUh171S+LmlPFfI2PGjGHLli2MGTOG9u3bZ/jxJXtQABIRkUda9MeZ5PAzrHkZRj5VDhdH+ww7fmxsLAsWLGDMmDHY29vj4uLC5s2bNbxdnogCkIiIPNTSnWeZsvE4AKOfLsfop8tn6PGPHDmCv78/x48f5/bt20yYMAFA4UeemJ2tCxARkcxp+Z5QJv94DIBXWpZl1FPlMuzYhmGwcOFC6taty/HjxylatChNmjTJsONL9qceIBERuc/KveeYuP4oAEObl2Fsq/IZ1usSGRnJ4MGD+eabbwBo164dX331FQULFsyQ40vOoB4gERFJYc3+87zz/d8ADG7qwxttKmRY+AkKCqJmzZp88803ODg4MH36dH788UeFH0l36gESEZFkXx+4wJvfHQHgpUbevNmuYobeb+Pk5ER4eDje3t6sWbNGj7MQq1EAEhER4O48P+PWHsYwoF/D0kx4tlKGhJ/ExEQcHe/OI1S1alU2bNhA3bp18fDwsPqxJefSJTAREWF98CVe++YQhgG965dkUgffDAk/27Zto1y5cuzduzd5WatWrRR+xOoUgEREcrgfDl1mTGAwFgN61C3J5OeqWD38mM1m3n33XZ566inOnTvH5MmTrXo8kX/TJTARkRxs45EwRv9f+OlWuwRTOlXBzs664efSpUv06tWL7du3A9C/f//kR1uIZBQFIBGRHOqXv8MZGXAQs8Xg+Vol+KhLNauHn40bN9K3b18iIiLInTs3n3/+Ob169bLqMUUeRAFIRCQH2nzsCiNW/0WSxaBTjWJ83NX64WfHjh3Jz+6qWbMmgYGBlCuXcZMrivwvBSARkRxm64krDFsVRJLFoEP1YnzyQnXsrRx+ABo3bkyHDh3w9vbm448/xtnZ2erHFHkYBSARkRxk+z/XGLLiLxLNBu2rFuXTbtVxsLfeeJj169fTsmVL3N3dMZlMrFu3DgcHffWI7WkUmIhIDrHzVASDlh8gwWyhbeUizOpew2rh5/bt27z88st06tSJoUOHYhgGgMKPZBr6TRQRyQF2h0Qw4Ks/SUiy0Mq3MLN71MTRSuHn2LFj+Pv78/fff2MymShVqhSGYegJ7pKpKACJiGRze89cZ8BXB4hPsvBUxULM61kLJ4f0Dz+GYfDll18yYsQIbt++TeHChVm5ciVPP/10uh9L5EkpAImIZGP7z97gpWV/cjvRTPMKBZnf2zrhJyYmhiFDhrB69Wrg7mzOK1asoHDhwul+LJH0oHuARESyqaBzN+j/5X7iEsw0KVeAz3v74exgb5VjxcXFsWXLFuzt7Zk6dSq//PKLwo9kauoBEhHJhg6ev0nfpX8Sm2CmYRlPFr1YGxfH9A0//3tfT+HChQkMDMTBwYFGjRql63FErEE9QCIi2cyhC5G8uGQ/t+KTqO+TnyV966R7+Ll+/TqdOnUiICAgeVmzZs0UfiTLUAASEclG/r4URZ8l+4iJT6Ju6bvhx9UpfcPPzp07qVGjBhs2bGDkyJHExcWl6/5FMoICkIhINnH0chS9Fu8j+k4SfqXysbR/HXI5p9+dDmazmSlTptC8eXMuXrxIuXLl2LRpE25ubul2DJGMonuARESygRPh0fRevI+o24nU8MrLsv51yJ2O4ScsLIw+ffqwZcsWAHr37s38+fNxd3dPt2OIZCQFIBGRLO6fKzH0WrSPm3GJVC/hwfIBdXF3cUy3/d+8eZOaNWty5coV3NzcmD9/Pi+++KImNpQsTZfARESysJCrMfRctJfrsQlULe7B8gH1yJOO4QcgX7589OrVi2rVqhEUFETfvn0VfiTLMxn3HtAiyaKjo/Hw8CAqKoo8efLYuhwRkQc6fe0W3b/Yy7WYeHyL5mH1oHrkdXNKl32fO3cOOzs7vLy8AEhISMBsNuPq6pou+xexhrR8f6sHSEQkCwqNiKXnorvhp2IRd1YNTL/w891331GjRg26d+9OYmIiAE5OTgo/kq0oAImIZDHnrsfSY9FerkTHU75wblYNrEe+XE8efu7cucOIESPo0qULkZGRJCUlcfPmzXSoWCTzUQASEclCLtyIo8cXewmLukPZQrlZNbA+nrmdn3i/J0+epH79+sybNw+A119/nZ07d1KoUKEn3rdIZqRRYCIiWcTFm3H0WLSXy1F38CmYi9WD6lHQ/cnDz/Llyxk2bBixsbEUKFCA5cuX065du3SoWCTzUgASEckCLkfepueifVy8eRvvArkIGFSfQu4uT7zfxMREZs6cSWxsLC1atGDlypUUK1YsHSoWydwUgEREMrnwqDv0XLSX8zfiKJnfjdWD6lE4z5OHHwBHR0cCAwP59ttvGT9+PPb21nlavEhmo2HwD6Bh8CKSWVyNvkP3L/ZyJiKWEvlcCXy5AcXzPv5oLMMwWLBgATExMYwbNy4dKxWxvbR8f6sHSEQkk7oWE0+PRXfDT/G8rgQMqv9E4ScyMpKBAweydu1a7OzsaNu2LdWrV0/HikWyDgUgEZFMKOJWPD0X7eX0tViKebgQMKg+Xvkf/6Gje/fupXv37pw7dw5HR0emTZtGtWrV0rFikaxFw+BFRDKZG7EJ9F68j1NXb1EkjwurB9WnpOfjhR+LxcLHH39MkyZNOHfuHD4+PuzevZsxY8bocRaSo6kHSEQkE4mMS6DX4n2cCI+hkLszqwfVo3SBXI+1L8MweOGFF1i3bh0A/v7+LFy4EA8Pj/QsWSRLUg+QiEgmERWXSK/F+zgeFk2B3M6sHlQfn4K5H3t/JpOJ1q1b4+rqyqJFiwgICFD4Efk/GgX2ABoFJiIZLep2In2W7OPwxSg8czmxZnB9yhV2T/N+kpKSuHjxIqVLlwbu9gKdP3+eUqVKpXPFIpmPHoYqIpKFRN9J5MWl+zl8MYr8uZxYPejxws/Fixdp2bIlzZs3T36Gl8lkUvgReQAFIBERG7oVn0S/pfs5dCGSvG6OrBxQjwpF0h5+fvjhB6pXr86OHTu4ceMGR44csUK1ItmHApCIiI3ExifR/8v9/HU+kjwuDqwcUA/fYmm77B4fH8+YMWN47rnnuHHjBn5+fvz11180bdrUSlWLZA8KQCIiNhCXkET/ZX/yZ+hN3F0cWDWwPlWKp+0G5ZCQEBo1asSsWbMAGD16NLt27aJs2bJWqFgke9EweBGRDHY7wcyAZQfYf/YG7s4OrBhQj6ol0j46a+LEiQQFBZE/f36WLVtGhw4drFCtSPakACQikoHuJJoZtPwAe85cJ7ezA18NqEsNr7yPta85c+ZgsViYPn06Xl5e6VuoSDanS2AiIhnkTqKZl1cEsTMkAjcne5b1r0OtkvlSvf3ff//NhAkTuDd7iaenJ2vWrFH4EXkM6gESEckA8Ulmhq36i+3/XMPV0Z4v+9Whdun8qdrWMAwWL17MyJEjuXPnDhUqVKB3795Wrlgke7N5D9D8+fPx9vbGxcUFPz8/duzY8dB1w8LC6NmzJxUqVMDOzo7Ro0fft86yZcswmUz3/dy5c8eKZyEi8nAJSRaGr/qLrSeu4uJox9J+dajn45mqbaOioujRoweDBw/mzp07tGnThtatW1u5YpHsz6YBKDAwkNGjR/P2229z8OBBmjRpQrt27Th//vwD14+Pj6dgwYK8/fbbVK9e/aH7zZMnD2FhYSl+XFxcrHUaIiIPlWi2MGL1X/x2/CrODnYs6VuHBmVSF37+/PNPatWqRWBgIA4ODkybNo2NGzdSqFAhK1ctkv3ZNADNnDmTAQMGMHDgQCpVqsSsWbPw8vJiwYIFD1y/dOnSfPbZZ7z44ouPfJ6NyWSiSJEiKX5ERDJaotnCyICDbDp2BScHOxa9WJtGZQukattFixbRqFEjzpw5Q6lSpdixYwdvvPEGdnY277gXyRZs9i8pISGBoKCg+7pyW7duze7du59o37du3aJUqVKUKFGCZ599loMHDz5y/fj4eKKjo1P8iIg8iSSzhTGBwfz8dzhO9nYs7O1H0/IFU729t7c3SUlJPP/88wQHB1O/fn0rViuS89gsAEVERGA2mylcuHCK5YULFyY8PPyx91uxYkWWLVvGhg0bCAgIwMXFhUaNGnHq1KmHbjN16lQ8PDySfzSiQkSehNli8Oo3h/jxcBiO9ibm96pFi4r/fdnq3vO7AJ5++mn27t3LN998Q968ea1YrUjOlOZRYPHx8ezfv5/Q0FDi4uIoWLAgNWvWxNvb+7EKMJlMKV4bhnHfsrSoX79+iv8pNWrUiFq1ajFnzhxmz579wG3efPNNxo4dm/w6OjpaIUhEHovZYvD6N4dYH3wZBzsT83rW4mnfwo/exmxmypQpfPrppxw4cIAyZcoAULdu3YwoWSRHSnUA2r17N3PmzOH7778nISGBvHnz4urqyo0bN4iPj8fHx4fBgwczZMgQ3N3/+0F+BQoUwN7e/r7enqtXr97XK/Qk7OzsqFOnziN7gJydnXF2dk63Y4pIzmSxGIxfe5h1By9hb2dibs+atK786HsQL1++TO/evfn999+Bu4ND3nrrrYwoVyRHS9UlsI4dO9K1a1eKFy/Or7/+SkxMDNevX+fixYvExcVx6tQp3nnnHbZs2UL58uXZvHnzf+7TyckJPz+/+9bdvHkzDRs2fLyzeQDDMAgODqZo0aLptk8RkX+zWAze+u4I3wRdxN7OxOzuNWlb5dGfO7/88gs1atTg999/J1euXCxfvlzhRySDpKoHqHXr1nzzzTc4OTk98H0fHx98fHzo27cvR48e5fLly6k6+NixY+nTpw+1a9emQYMGfPHFF5w/f54hQ4YAdy9NXbp0ieXLlydvExwcDNy90fnatWsEBwfj5OSEr68vAO+99x7169enXLlyREdHM3v2bIKDg5k3b16qahIRSSvDMJiw/m/W/HkBOxPM7Fad9tUeHn4SEhJ45513mD59OgDVq1cnMDCQChUqZFTJIjleqgLQ8OHDU73DypUrU7ly5VSt6+/vz/Xr15k8eTJhYWFUqVKFjRs3UqpUKeDuxIf/nhOoZs2ayX8OCgpi9erVlCpVitDQUAAiIyMZPHgw4eHheHh4ULNmTf744w9dSxcRqzAMg3c3HGXVvvOYTDCjW3U61ij+yG0WLFiQHH5GjBjB9OnTNVeZSAYzGfceKpNGBw4c4Pjx45hMJipWrEjt2rXTuzabiY6OxsPDg6ioKPLkyWPrckQkkzIMg8k/HuPLXaGYTDC9a3W6+pX4z+0SEhJ47rnnePnll+ncuXMGVCqSM6Tl+zvNo8AuXrxIjx492LVrV/LQzMjISBo2bEhAQIBGT4lIjmAYBlN+Os6Xu0IB+KhL1YeGn9u3bzN37lxGjx6No6MjTk5O/Pzzz0804lVEnkya5wF66aWXSExM5Pjx49y4cYMbN25w/PhxDMNgwIAB1qhRRCRTMQyDj345weKdZwH4sHNV/OuUfOC6J06coH79+rzxxhtMmjQpebnCj4htpbkHaMeOHezevTvFzXoVKlRgzpw5NGrUKF2LExHJbAzD4JNNJ1m4/QwA73esTM9694cfwzD46quvGD58OHFxcRQqVIjmzZtncLUi8jBpDkAlS5YkMTHxvuVJSUkUL/7oG/9ERLK6Wb+dYt7vpwF4t4MvfRqUvm+dmJgYhg0bxsqVKwF46qmnWLlypZ5LKJKJpPkS2Mcff8wrr7zCgQMHuHf/9IEDBxg1ahSffPJJuhcoIpJZzN5yis+23J1U9Z32lejX6P4Z8I8cOYKfnx8rV67E3t6eKVOm8Ouvvyr8iGQyaR4Fli9fPuLi4khKSsLB4W4H0r0/58qVK8W6N27cSL9KM5BGgYnIv837PYTpv54E4K1nKjK4aZkHrnfixAn8/PzInz8/AQEBNG7cOCPLFMnRrDoKbNasWY9bl4hIlrRw++nk8PNG2wr3hZ/ExEQcHR2Buw9k3rBhAzVq1MDT0zPDaxWR1HnseYCyM/UAicg9i3ec4YOfjgPwaqvyvPJUuRTv7969m969e/Pll1/SrFkzW5QoIv8nLd/fab4HSEQkp1i262xy+Bn1VLkU4cdisTB16lSaNm3K2bNneffdd21UpYg8jjRfAhMRyQlW7Anl3R+OATCiRVlGP/3/w8+VK1fo06dP8sOce/bsyeeff26TOkXk8agHSETkX1bvO8+E9UcBGNKsDK+2Lp88ceFvv/1G9erV2bx5M25ubixdupSVK1fi7u5uy5JFJI3UAyQi8j8C/zzPW98dAWBQE2/Gta2QHH7+/PNPWrdujWEYVKlSha+//ppKlSrZslwReUwKQCIi/+ebAxcYv+5u+OnfqDRvPVMpxSMrateuTdeuXcmfPz+ffvoprq6utipVRJ5Qul4Ce+mll1ixYkV67lJEJEN8d/Aib6w9jGFA3walmPisLyaTiZ9++onIyEjg7vO7Vq9ezeeff67wI5LFpWsAOnPmDBMnTqR69erpuVsREataH3yJV78+hGFA7/olefe5yiQkJDBy5EieffZZBg4cmDzz/b0JYEUka0vXf8nbtm0D4OTJk+m5WxERq/nx8GXGBAZjMaBHXS8mP1eFU6dO0b17dw4ePAhA6dKlMZvNCj8i2Ui6/mu+Nxvq/z4pXkQks/r5SBij1twNPy/4lWBKp6qsXr2KoUOHcuvWLTw9Pfnqq69o3769rUsVkXSW6ktgL774ItHR0Q99/8CBA9SsWTNdihIRsbZNR8N5JeAgZotBl1rFmdC2DAMGvESfPn24desWzZo149ChQwo/ItlUqgPQ33//ja+vL7/++muK5YmJibz11ls0bNhQD/0TkSxhy/ErDF/9F0kWg441ijG9a3USE+L57bffsLOzY9KkSWzZsoXixYvbulQRsZJUXwLbv38/kydPpkOHDvTv358ZM2Zw4sQJ+vbtS2xsLD/99BOtWrWyZq0iIk/s95NXGbryLxLNBu2rFuGTrtWwtzPh6elJYGAgCQkJNG/e3NZlioiVpflhqEFBQfTt25cbN24QERFBv379mDFjRraaBVUPQxXJnrb/c41Byw+QkGThKZ9cRG+eR/v27enXr5+tSxORdJCW7+803wTt7OyMo6MjUVFRODk50ahRo2wVfkQke9p5KoLB/xd+arpEsHXqCEJDQ/ntt9/o0qWL/rMjksOk+h4gwzCYOnUqtWvXpkaNGly+fJmPP/6YESNG0LFjR65evWrNOkVEHtvu0xEMXP4ndxKTKBy6iR+nDCQ0NBRvb29+/fVXhR+RHCjVAahBgwbMmTOHb775hi+//BIPDw+GDRvGoUOHiIyMxNfXl8DAQGvWKiKSZvvOXGfAsgPERt3E/PNH7A+cTVJSEi+88AIHDx6kbt26ti5RRGwg1QGodOnS/P3333To0CHFch8fH7Zt28bbb7/NgAED0r1AEZHHdSD0Bv2X/Uls7C1urBzDpSO7cXFxYeHChQQGBuLh4WHrEkXERtJ8E/SjnDp1inLlyqXX7mxGN0GLZH1B527y4pJ9xCaYaVKuAMVD1rNh/fcEBgZStWpVW5cnIlaQlu/vdA1A2YUCkEjWFnwhku4zfyLm9h2a+VVmSd86ONoZxMfHkytXLluXJyJWkpbv71RdAmvbti27d+/+z/ViYmKYNm0a8+bNS12lIiLp7MjFKDqNm82phcO4/fMnzOteFVcnexwcHBR+RCRZqobBv/DCC3Tr1g13d3eee+45ateuTbFixXBxceHmzZscO3aMnTt3snHjRp599lmmT59u7bpFRO5z8Ow1WvcaQsSedQCU8izD7Zgo8rkr+IhISqm+BJaQkMC3335LYGAgO3bsIDIy8u4OTCZ8fX1p06YNgwYNyhYPQtUlMJGs59c9h+j8QjduX/oHgKHDR/DpjE9wdna2cWUiklEy5B6gqKgobt++jaenJ46Ojo9VaGalACSStXy6cBmvjRqOJT4ORzd3li/7ku4vPG/rskQkg1l1Juh7PDw8NIRURGzuxOVI3nn/IyzxceTzqcofP39HlfJlbF2WiGRyaQ5AW7duZd26dYSGhmIymfD29qZr1640bdrUGvWJiDxUyNVb9F56gLzPvk7xczvZEzgfzzyuti5LRLKANF0CGzJkCF988QX58uWjfPnyGIbBqVOniIyMZNiwYcyZM8eatWYYXQITybwMw2Dp0qUcOXmG3R4tuBoTj2/RPKweVI+8bk62Lk9EbMgql8C+++47vvzyS5YuXUrfvn0xmUwAWCwWli1bxtChQ2nVqhXPPffck1UvIvIQ0dHRDBkyhICAAACK9PGkeq3arByo8CMiaZPqAPTll18yduxY+vXrl2K5nZ0dL730EidPnmTJkiUKQCJiFUFBQXTv3p2QkBCwsyNvkxepUr0mqwbWI38uhR8RSZtUPwvsr7/+onPnzg99//nnnycoKChdihIRuccwDD777DMaNGhASEgITnkLUaTnNGp16MvqwQ3xzK1h7iKSdqnuAYqIiKB48eIPfb948eJcv349XYoSEbmnd+/erF69GgDPyo1xfXoE5UoUJmBQfQq6K/yIyONJdQ9QQkICTk4P72Z2cHAgISEhXYoSEbmnTZs2ODk5UbbTSHK1H0eZ4oVYPag+hfK42Lo0EcnC0jQMfsKECbi5uT3wvbi4uHQpSERyNrPZzPnz5/H29gagTadu1DrpRJjZnVL53QgYXJ8iHgo/IvJkUh2AmjZtysmTJ/9zHRGRxxUWFkbv3r05ceIEhw4dwuKUmx6L9hJmdqdEPlcCBtenqIfm+RGRJ5fqALRt2zYrliEiOd2vv/7Kiy++yNWrV3Fzc+P3XftYeDo3Z67FUjyvKwGD6lM8r8KPiKSPVN8D9DBJSUncunUrPWoRkRwoMTGR8ePH07ZtW65evUrVqlX5bftuFp3JTcjVWxT1cCFgUH288j/48ruIyONIdQDauHEjK1asSLFsypQp5M6dm7x589K6dWtu3ryZ7gWKSPYVGhpK06ZNmTZtGgBDhw7l5607eG9nFP9cuUXhPM4EDKpPSU+FHxFJX6kOQJ988gnR0dHJr3fv3s3EiROZMGECX3/9NRcuXOD999+3SpEikj29//777N27Fw8PD7799ls+/GQWg1Yd5kR4DAXd74af0gVy2bpMEcmGUn0P0N9//82MGTOSX3/77be0atWKt99+GwAXFxdGjRrFzJkz079KEcmWZs6cSWxsLFOnTsWSuyAvfL6HU1dvUSD33fDjUzC3rUsUkWwq1T1AMTExeHp6Jr/euXMnLVu2TH5duXJlLl++nL7ViUi2cvLkSd566y3uPYPZw8ODNWvWcOKWC8/N2cmpq7co5O7M6kH1KFtI4UdErCfVAahYsWIcP34cgFu3bnHo0CEaNWqU/P7169cfOkeQiMjy5cvx8/Nj6tSpLF68GIAks4UpPx1j6Kq/iE0wU887Pz+ObEz5wu42rlZEsrtUXwLr2rUro0eP5q233mLjxo0UKVKE+vXrJ79/4MABKlSoYJUiRSTrunXrFsOHD2f58uUAtGjRgvbt23M15g4jVh9k/9kbAAxu6sMbbSrgYP/Eg1NFRP5TqgPQpEmTuHz5MiNHjqRIkSKsXLkSe3v75PcDAgLo0KGDVYoUkazp0KFD+Pv7c/LkSezs7Hj33Xd56623+OtCFMNm7+RaTDy5nR2Y3rUa7aoWtXW5IpKDmIx7F+PTQXR0NHny5Emv3dlMdHQ0Hh4eREVFZYvzEbGFlStXMnDgQOLj4ylevDgBAQE0btyYJTvPMvXnE5gtBuUK5ebzPn6U0c3OIpIO0vL9naZh8P910NatW6d2dyKSzZUuXZqkpCQ6dOjAoUOHqFm3ASMCDvLBT8cxWwyeq16M74c3UvgREZtI9SWwCRMm4OnpSf/+/e9779atW7Rp0ybFPEEikvPcvHmTfPnyAdC4cWN2795NnTp1OH3tFi/P3cnpa7E42Jl4p30l+jYsjclksnHFIpJTpboHaMWKFQwbNozvv/8+xfJbt27RunVrbty4we+//57e9YlIFmCxWJg2bRre3t7Jo0UB6taty09Hwug4dxenr8VSOI8zgS/Xp18jb4UfEbGpVAegrl27MmfOHHr27JkcdG7dukXbtm2JiIhg27ZtFC5c2GqFikjmdPXqVZ555hnGjx9PVFQUq1atAiDRbGHyD8cYsfogsQlm6vvk58dXmuBXKr+NKxYRScMlMICBAwdy48YNOnXqxPr165kwYQLh4eFs376dokU1gkMkp9m6dSu9evUiPDwcV1dXZs+ezYABA7gafYfhq//iz9C7zwcc0qwMr7UuryHuIpJppCkAAbzxxhvcvHmTp556itKlS7N9+3aKFy9ujdpEJJNKSkrivffeY8qUKRiGga+vL19//TWVK1dm35nrDF99kIhb8bg7O/BJt+q0qVzE1iWLiKSQ6gDUpUuXFK8dHR0pUKAAI0eOTLF83bp16VOZiGRaS5cu5YMPPgDu9gx/9tlnuLq6suiPM3z0y90h7hUKu/N5Hz+89TBTEcmEUh2APDw8Urzu0aNHuhcjIlnDSy+9xPr16+nTpw/du3cn5k4iw1b9xc9/hwPQuWZxpnSugptTmjuZRUQyRLpOhJhdaCJEkZTi4+OZM2cOr7zyCs7OzgAYhoHJZOKfKzEMWRnEmWuxONqbmPisL73rl9IoLxHJcGn5/tZ/z0TkkUJCQvD39+evv/7i0qVLfPrppwCYTCY2HLrMuG8PczvRTFEPF+b1qkWtkvlsXLGIyH9TABKRhwoICODll18mJiYGT09PnnrqKQASkix8uPE4y3aHAtCorCezu9fEM7ezDasVEUk9BSARuU9cXBwjR45kyZIlADRt2pRVq1ZRokQJwqPuDnEPOnd3iPvwFmUY26oC9na65CUiWYcCkIikcOLECZ5//nmOHTuGyWRiwoQJTJgwAQcHB3afjmBkwEEibiXg7uLAzG41aOWrCVBFJOtRABKRFJycnLh48SJFixZl1apVtGjRAsMw+Hz7aT7+5QQWAyoWcefz3n6U1hB3EcmiFIBEhMTERBwdHQHw8fFh/fr1+Pr6UqhQIaLvJPLa14fYdOwKAF1qFWdKp6q4OtnbsmQRkSeieelFcrg///yTSpUqsWnTpuRlzZs3p1ChQpwIj6bj3F1sOnYFJ3s7pnSuwowXqiv8iEiWZ/MANH/+fLy9vXFxccHPz48dO3Y8dN2wsDB69uxJhQoVsLOzY/To0Q9cb+3atfj6+uLs7Iyvry/fffedlaoXybosFgszZsygYcOGnD59mgkTJvC/04J9f/ASneft5mxELMU8XPhmSAN61dP8PiKSPdg0AAUGBjJ69GjefvttDh48SJMmTWjXrh3nz59/4Prx8fEULFiQt99+m+rVqz9wnT179uDv70+fPn04dOgQffr0oVu3buzbt8+apyKSpURERNChQwdee+01kpKS6NKlC7/88gsmk4mEJAsT1//N6MBgbieaaVKuAD+ObEJ1r7y2LltEJN3YdCboevXqUatWLRYsWJC8rFKlSnTq1ImpU6c+ctvmzZtTo0YNZs2alWK5v78/0dHR/Pzzz8nL2rZtS758+QgICHjgvuLj44mPj09+HR0djZeXl2aClmxp+/bt9OzZk8uXL+Ps7Mynn37KkCFDMJlMhEXdZtiqvzh4PhKAkS3LMurp8hriLiJZQlpmgrZZD1BCQgJBQUG0bt06xfLWrVuze/fux97vnj177ttnmzZtHrnPqVOn4uHhkfzj5eX12McXycyOHDlCy5YtuXz5MhUqVGDfvn0MHToUk8nErpAI2s/eycHzkeRxcWBpv9qMba35fUQke7LZKLCIiAjMZjOFC6ecQ6Rw4cKEh4c/9n7Dw8PTvM8333yTsWPHJr++1wMkkt1UrVqV3r17Y2dnx9y5c8mVKxcWi8GC7aeZsekkFgN8i+bh895+lPR0s3W5IiJWY/Nh8P++ofLeAxYzcp/Ozs7JD3gUyW5+/fVX/Pz8KFCgAABLlizBweHuP/2o24m8+vUhfjt+d4j7C34leL9TFVwcNcpLRLI3m10CK1CgAPb29vf1zFy9evW+Hpy0KFKkSLrvUyQrSkhI4PXXX6dt27b069cveYTXvfBzPCya5+bu5LfjV3BysOOjLlWZ/kJ1hR8RyRFsFoCcnJzw8/Nj8+bNKZZv3ryZhg0bPvZ+GzRocN8+N23a9ET7FMlqzp49S5MmTfjkk08A8Pb2JikpKfn9tUEX6Tx/F+eux1E8ryvfDmlA97olbVWuiEiGs+klsLFjx9KnTx9q165NgwYN+OKLLzh//jxDhgwB7t6bc+nSJZYvX568TXBwMAC3bt3i2rVrBAcH4+TkhK+vLwCjRo2iadOmTJs2jY4dO7J+/Xp+++03du7cmeHnJ2IL3377LQMHDiQqKoq8efOydOlSOnfuDEB8kpnJPxxj1b67U000K1+QWf41yJfLyZYli4hkOJsGIH9/f65fv87kyZMJCwujSpUqbNy4kVKlSgF3Jz7895xANWvWTP5zUFAQq1evplSpUoSGhgLQsGFD1qxZwzvvvMOECRMoU6YMgYGB1KtXL8POS8QWbt++zdixY/n888+Bu72hAQEByf+eLkXeHeJ+6EIkJhOMbFmOUU+Vw06jvEQkB7LpPECZVVrmERDJLKKioqhZsyahoaGMHz+e9957L/n5XjtOXWNkwEFuxiXi4erIrO41aFGhkI0rFhFJX2n5/rb5KDAReXz3/v9iMpnw8PAgMDCQyMhIWrVqBYDFYjB/WwgzNv+DYUDV4h7M71ULr/wa4i4iOZsCkEgWFRMTw9ChQ2nUqBFDhw4FoE6dOsnvR8UlMvbrYLacuApA9zpevPtcZY3yEhFBl8AeSJfAJLM7ePAg/v7+nDp1ily5cnHu3Dk8PT2T3//7UhTDVv3F+RtxODnY8UHHKnSro8k9RSR70yUwkWzKMAzmzp3La6+9RkJCAl5eXgQEBCSHH4vFYPHOM0z/9SSJZgOv/K4s6OVHleIeNq5cRCRzUQASySJu3LjBSy+9xPr16wF47rnn+PLLL8mfPz8AYVG3efXrQ+w+fR2AVr6F+aRrdTzcHG1Ws4hIZqUAJJIF3L59m9q1a3P27FmcnJyYPn06r7zySvIjXjYeCePNdUeIup2Iq6M9kzr44l/H64kfKyMikl0pAIlkAa6urgwYMIBly5YRGBhIrVq1ALgVn8S7G47ybdBFAKqV8GCWfw18Cua2ZbkiIpmeboJ+AN0ELZlBeHg4t27domzZsgCYzWbi4uJwd3cHIOjcTcYEBnP+Rhx2JhjWvCyjni6Ho73NnnAjImJTuglaJIvbvHkzvXv3plChQuzfvx9XV1fs7e1xd3cnyWxhztYQ5v4egtliUDyvK5/616Cud35bly0ikmXov4oimUhiYiJvvfUWbdq04erVq5hMJq5du5b8/vnrcXRbuIfPtpzCbDHoVKMYP49uovAjIpJG6gESySTOnTtHz5492b17NwBDhgxh5syZuLq6YhgG3wZd5N0NR4lNMOPu7MAHnavQsUZxG1ctIpI1KQCJZALff/89/fv3JzIykjx58rB48WJeeOEFACLjEnj7u7/56UgYAHVL52emf3VK5NPjLEREHpcCkIiNWSwWZs6cSWRkJHXq1GHNmjX4+PgAsDskgrFfHyI8+g4OdibGtCrPkGZlsNcT3EVEnogCkIiN2dnZsWrVKhYuXMjEiRNxcnIiPsnMjE3/sGjHGQwDfArkYlb3GlQrkdfW5YqIZAsaBv8AGgYv1rZy5UqOHz/OlClT7nsv5GoMIwOCORYWDUCPuiWZ8Gwl3Jz0/xURkUfRMHiRTCo2NpYRI0awbNkyAFq3bk2zZs2Au8/5WrH3HFN+Ok58koX8uZz4qEtVWlcuYsOKRUSyJwUgkQxy+PBh/P39OXHiBHZ2dkycOJHGjRsDcC0mnje+PcTvJ+8OeW9aviCfdK1GoTwutixZRCTbUgASsTLDMFi4cCGjR48mPj6eYsWKsXr16uSeny3Hr/DGt4e5HpuAk4Mdb7arSN8GpbHTjc4iIlajACRiZYMGDWLJkiUAPPPMMyxbtoyCBQtyO8HMlI3HWLn3PAAVi7jzWfeaVCjibstyRURyBM0ELWJlbdq0wdHRkRkzZvDDDz9QsGBB/r4UxbNzdiSHn4GNvfl+eCOFHxGRDKIeIJF0ZrFYOHfuHN7e3gC88MIL1K1bl1KlSmG2GHy+/TQzNp0k0WxQyN2ZGd2q06RcQRtXLSKSsygAiaSja9eu0bdvX4KCgjh06BBFitwdwVWqVCkuR95m7NfB7D1zA4C2lYswtUtV8uVysmXJIiI5ki6BiaST33//nerVq/Pzzz8THR3NgQMHkt/74dBl2s76g71nbuDmZM/Hz1djQe9aCj8iIjaiHiCRJ5SUlMT777/P+++/j2EYVKpUicDAQKpWrUrMnUQmbTjKur8uAVDdKy+z/GvgXSCXjasWEcnZFIBEnsDFixfp1asXf/zxBwADBgzgs88+I1euXASdu8HowGAu3LiNnQlGtCjLK0+Vw9FeHa8iIramACTyBD766CP++OMPcufOzRdffEGPHj1IMluYufkf5m49hcWAEvlc+dS/BnVK57d1uSIi8n8UgESewEcffcT169d5//33KVu2LKERsYwODCb4QiQAXWoW592Olcnj4mjbQkVEJAX1xYukwenTp3njjTewWCwA5M6dm4CAAMqUKcPXf17gmdk7CL4QibuLA3N61GSmfw2FHxGRTEg9QCKpFBgYyKBBg4iJiaF48eKMGjUKgJuxCbz13RF+/jscgHre+ZnpX4PieV1tWa6IiDyCApDIf4iLi2P06NEsWrQIgMaNG9OlSxcAdp6K4NVvgrkSHY+DnYlXW1dgcFMf7PUcLxGRTE0BSOQRjh07Rrdu3Th69Cgmk4m3336bSZMmYcbElJ+OsWjHWQB8CubiM/+aVC3hYeOKRUQkNRSARB7i66+/pl+/fty+fZsiRYqwcuVKnnrqKf65EsOoNcEcD4sGoFe9krzT3hdXJ3sbVywiIqmlACTyEN7e3iQmJtK6dWuWL19OoUKFWLbrLFN/PkF8kgXPXE5Me74aT/sWtnWpIiKSRgpAIv/j5s2b5MuXD4A6deqwa9cuateuTURsAv2X/cm2k9cAaF6hIB93rUYhdxdblisiIo9Jw+BFAMMwmDVrFqVKlSI4ODh5ed26ddl64hptZ+1g28lrODvY8d5zlfmyXx2FHxGRLEw9QJLjXb9+nX79+vHjjz8CsGLFCmrUqEHU7UQ++vk4AfsvAFCpaB4+616D8oXdbVmuiIikAwUgydF27NhBz549uXjxIk5OTsycOZNhw4bxy9/hTFz/N1dj4gEY3NSHV1uXx9lBNzqLiGQHCkCSI5nNZqZOncqkSZOwWCyUL1+ewMBAivpUZOjKv/jl6N1JDX0K5GJql6rU8/G0ccUiIpKedA+Q5EirV69mwoQJWCwW+vTpw4EDBziekJ+nZ27nl6PhONiZGNGiLBtHNVH4ERHJhtQDJDlSz549Wbt2LV26dKFxuy4MXH2EfWdvAFC9hAcfPV+NSkXz2LhKERGxFvUASY6QmJjIjBkzuH37NgD29vZ8/e1aYrwa0vazHew7ewNXR3smPOvLumGNFH5ERLI59QBJthcaGkqPHj3Yu3cv//zzDwsXLuTwxUje+PYwJ8JjAGhSrgAfdq6KV343G1crIiIZQQFIsrV169YxYMAAIiMj8fDwoFnLp/jgx2Ms3XUWiwH53ByZ2MGXTjWKYzLpAaYiIjmFApBkS3fu3OHVV19l/vz5ANSvX5/RU+Yy588oLt68+wDTjjWKMfFZXzxzO9uyVBERsQEFIMl2QkJC6Nq1K4cOHQJg1NjXMPy6MW7T3aHtxfO68kHnKrSoUMiWZYqIiA0pAEm24+zszIULFyhYsCDD3v2UH64X4vrhq5hM0K9haV5rXYFczvrVFxHJyfQtINlCYmIijo6OAHh5ebFoRSCBJxNYdt4AEqhQ2J2Pnq9KzZL5bFuoiIhkChoGL1lecHAwVatWZcOGDZgtBst2neWdvUnsu2LgZG/Hq63K88MrjRV+REQkmXqAJMsyDIP58+fz6quvEh8fzxtvvs3S8/kIvhgNQJ3S+ZjapRplC+W2caUiIpLZKABJlnTz5k0GDBjAd999B4BvvRbcbjCY4IvR5HZ2YFy7ivSqWxI7Ow1tFxGR+ykASZazZ88eunfvzvnz53FwdMT7mcHcqtAWk8nE05UK836nyhT1cLV1mSIikokpAEmW8s8//9C0aVOSkpLIV8QL59ZjSShajoK5nZncsTLtqhTRhIYiIvKfFIAkSylfvjxtuvRk74kLuLUcip2zG/61vXjrmUp4uDnaujwREckiFIAk09u6dSu+vr7Y58rHuz8c5Uip58lV2o7SBXIxtXNVGpYtYOsSRUQki1EAkkwrKSmJd999lw8//JDKtRtiavc20fEWHBwcGNTEh9FPl8PF0d7WZYqISBakACSZ0oULF+jRowe7du0CIDQhN/lj46laypOPulSjSnEPG1coIiJZmQKQZDobNmygX79+3Lx5EzsnV/K3fQXPas0Z26o8LzXyxsFe83eKiMiTUQCSTCM+Pp433niD2bNnA+BUpBwFnnuD5nWq8GHnqpTyzGXjCkVEJLtQAJJMIzr2DqvX/QCAe+2OlGo7iIkdq9HVr4SGtouISLpSABKbMwyDPaev8+Z3R3BsNYaC0RF069KRSR0qU9Dd2dbliYhINqQAJDYTGxvLkGEjuEh+zhZtCUCpcr6837EKT/sWtnF1IiKSnSkAiU0cOXKE9p2e58KZU2DvSPEhNXipVU1eb1MBdxdNaCgiItalACQZyjAMPpk9jzdffw1zYjz2ufNTrc8EvnitPbVL57d1eSIikkMoAEmGuXkzkrYv9Gb/lp8AcPPxY9zUOYzrUhdnB01oKCIiGUcBSDLEsYvXqV/bj5gr58DOnsodX+bbeR9SsagmNBQRkYynACRWFXMnkbm/h/DlzlAcfJ/GMf5Hxn+8gEkDOmFvp6HtIiJiGzafUnf+/Pl4e3vj4uKCn58fO3bseOT627dvx8/PDxcXF3x8fPj8889TvL9s2TJMJtN9P3fu3LHmaci/WCwGizcF02DcShZuP0OC2ULHPoM5fOgQkwd1VvgRERGbsmkACgwMZPTo0bz99tscPHiQJk2a0K5dO86fP//A9c+ePcszzzxDkyZNOHjwIG+99RYjR45k7dq1KdbLkycPYWFhKX5cXFwy4pQEOBB6g0aj5zLk+ac4uXICXu52LO1Xm6X96lCxpIa3i4iI7ZkMwzBsdfB69epRq1YtFixYkLysUqVKdOrUialTp963/rhx49iwYQPHjx9PXjZkyBAOHTrEnj17gLs9QKNHjyYyMvKx64qOjsbDw4OoqCjy5Mnz2PvJaS5H3ubDn46ycsFMonYHgmGhcEkfft/0C5UqlLN1eSIiks2l5fvbZj1ACQkJBAUF0bp16xTLW7duze7dux+4zZ49e+5bv02bNhw4cIDExMTkZbdu3aJUqVKUKFGCZ599loMHDz6ylvj4eKKjo1P8SOrdTjAz67d/aDLpWxa/2Z+oXQFgWOjeqw+njx1W+BERkUzHZgEoIiICs9lM4cIpL4kULlyY8PDwB24THh7+wPWTkpKIiIgAoGLFiixbtowNGzYQEBCAi4sLjRo14tSpUw+tZerUqXh4eCT/eHl5PeHZ5QyGYbDh0GWemrGNqQtXE7poBPEX/sYtV25WrFhBwMrl5MqlB5iKiEjmY/NRYP9+yKVhGI988OWD1v/f5fXr16d+/frJ7zdq1IhatWoxZ86c5KeM/9ubb77J2LFjk19HR0crBP2HIxejeO+Hoxw4dxPDMIgP/hHL7Whq1qzJmjVrKF++vK1LFBEReSibBaACBQpgb29/X2/P1atX7+vluadIkSIPXN/BwQFPT88HbmNnZ0edOnUe2QPk7OyMs7Meupka12Li+eTXk3wddAHDABdHO4Y1L8tzI9azcP5c3n33XbWliIhkejYLQE5OTvj5+bF582Y6d+6cvHzz5s107Njxgds0aNCAH374IcWyTZs2Ubt2bRwdH/z8KMMwCA4OpmrVqulXfA4Un2Rm2a5Q5mwN4VZ8ErEndlLSfIkfViykWF5XgAfeuC4iIpIZ2fQS2NixY+nTpw+1a9emQYMGfPHFF5w/f54hQ4YAdy9NXbp0ieXLlwN3R3zNnTuXsWPHMmjQIPbs2cOSJUsICAhI3ud7771H/fr1KVeuHNHR0cyePZvg4GDmzZtnk3PM6gzDYMvxq3zw0zFCr8dhSYzHbv9yInauJwI4sq8Xxdq0sXWZIiIiaWLTAOTv78/169eZPHkyYWFhVKlShY0bN1KqVCkAwsLCUswJ5O3tzcaNGxkzZgzz5s2jWLFizJ49m+effz55ncjISAYPHkx4eDgeHh7UrFmTP/74g7p162b4+WV1/1yJ4f0fj7Hj1N0bzHPfDidm4yecCzmByWTizTffpGXLljauUkREJO1sOg9QZpXT5wGKjEvg083/sHLfecwWA0c7E9VvH+TnLz4kLi6OwoULs2LFClq1amXrUkVERJKl5fvb5qPAJPNIMltYvf88Mzf/Q2Tc3XmVWvsWJmHHYr5avBCAVq1asXz5cooUKWLLUkVERJ6IApAAsPNUBJN/PMo/V24BUKGwOxM7+NKobAF+yBfGqmVLmDx5MuPGjcPOzuaPkBMREXkiCkA53LnrsXzw03E2H7sCQF43R8Y+XY76Bc2UL1sAgA4dOhASEpJ8b5aIiEhWpwCUQ92KT2Lu1hCW7jxLgtmCvZ2JPvVL0beWJ2NGDGHMjh0EBwcnTwip8CMiItmJAlAOY7EYfPvXRT7+5SQRt+IBaFKuABOf9eXKqUM0a9iOCxcu4OTkxP79+zUjtoiIZEsKQDlI0LkbvLvhGEcuRQFQ2tONCc/60qycJ9OmTWPSpEmYzWbKli1LYGAgtWrVsnHFIiIi1qEAlANcjrzNtF9OsD74MgC5nR0Y+VRZ+jYszc2Ia7Rt25YtW7YA0KtXLxYsWIC7u7stSxYREbEqBaBs7vDFSHot3kfMnSRMJujm58VrbSpQ0P3u87pmzJjBli1bcHNzY+7cufTr1++RD6MVERHJDhSAsrFjl6Pps2Q/MXeSqFbCgw87V6VKcY8U60yePJmLFy8yceJEKlWqZKNKRUREMpYmdMmmTl2JofeSfUTdTqRmybysHlSfKsU9OHfuHK+++ipmsxkAV1dXAgICFH5ERCRHUQ9QNnTm2i16Lt7HjdgEqhb3YFn/uuR2duD777+nf//+REZGUrBgQcaPH2/rUkVERGxCPUDZzPnrcfRctI9rMfFULOLOigF1cTaZeeWVV+jcuTORkZHUrVsXf39/W5cqIiJiMwpA2cilyNv0WLSX8Og7lCuUm1UD63H1YigNGjRg7ty5ALz22mvs2LEDb29vG1crIiJiO7oElk1cib5Dz0V7uRR5G+8CuVg1sB67tv5Kz549iY2NpUCBAixfvpx27drZulQRERGbUwDKBq7FxNNz0V7OXY/DK78rqwfVo1AeF0qXLk1SUhLNmzdn1apVFCtWzNalioiIZAoKQFncjdgEei/ex+lrsRTzcGF+1woU9XAFoFq1auzYsYNatWphb29v40pFREQyD90DlIVF3U6kz5J9nLwSQ8HcTrS1P0yjGpXYv39/8jp16tRR+BEREfkXBaAsKuZOIn2X7ufo5Wjy2ifguW8ek8aNJSYmhmXLltm6PBERkUxNl8CyoLiEJF5a9ifBFyJxvB7CtV9mcujieRwdHfnoo48YM2aMrUsUERHJ1BSAspg7iWYGfnWA/WevE//Xei5t+4qkpCR8fHxYs2YNderUsXWJIiIimZ4ugWUh8UlmBq8IYvfp61hO7+XKb0tISkrC39+fv/76S+FHREQkldQDlEUkJFkYvuov/vjnGq6O9iz7eCwz7E7RqlUrBg4cqCe4i4iIpIECUBaQZLYwcvWfrFu+GE+/dizp25R6Pp4EBgYq+IiIiDwGBaBMzmwxGPz5JlZPe534C39Txz2ahmW7ACj8iIiIPCYFoEzMYjHo9vZcvv/sHSy3o3HLlZt+/p1sXZaIiEiWpwCUScXHx9P0hYHs/2ElAGV9q/Hz+rWULVvWxpWJiIhkfRoFlgmdPXsWnyp+yeGnQ8+B/P3XfoUfERGRdKIAlMkYhsHi3RcJv3wJOxd33pixhA2rFuHs7Gzr0kRERLINXQLLJBITE3F0dOSzLadYdSSaQl3eZlzXRozu2MDWpYmIiGQ7CkCZwNGjR/H396fe84PZEl8GgPcHd2FgEx8bVyYiIpI96RKYDRmGwaJFi6hTpw5Hjx5l+dzpGBYzb7StoPAjIiJiReoBspHo6GgGDx5MYGAgAC6la1Lg2bGMblWRYc11s7OIiIg1KQDZwIEDB/D39+fMmTPY2duTp3Ef8tTrwrAW5Rj9dDlblyciIpLtKQBlsHPnztGoUSMSEhIoWLQE9k+PwrlYJV5q5M0bbSpodmcREZEMoACUwUqVKsWwYcPYd/gkl6r1xeScm971SzLh2UoKPyIiIhlEN0HbQJv+r3Gl7nBMzrl5wa8Ek5+rovAjIiKSgRSAMti2k1cZGXgYswEdaxTjo+erYWen8CMiIpKRFIAy0O7TEby8IogEs4V2VYow44Xq2Cv8iIiIZDjdA5SBPHM54+7iQBOvvHzWvSYO9sqfIiIitqAAlIEqFHHnu2GNKJTHGScHhR8RERFbUQDKYF753WxdgoiISI6nbggRERHJcRSAREREJMdRABIREZEcRwFIREREchwFIBEREclxFIBEREQkx1EAEhERkRxHAUhERERyHAUgERERyXEUgERERCTHUQASERGRHEcBSERERHIcBSARERHJcfQ0+AcwDAOA6OhoG1ciIiIiqXXve/ve9/ijKAA9QExMDABeXl42rkRERETSKiYmBg8Pj0euYzJSE5NyGIvFwuXLl3F3d8dkMtm6nP8UHR2Nl5cXFy5cIE+ePLYuJ9NQuzyc2ubh1DYPp7Z5OLXNw2Vk2xiGQUxMDMWKFcPO7tF3+agH6AHs7OwoUaKErctIszx58ugf3gOoXR5ObfNwapuHU9s8nNrm4TKqbf6r5+ce3QQtIiIiOY4CkIiIiOQ4CkDZgLOzM5MmTcLZ2dnWpWQqapeHU9s8nNrm4dQ2D6e2ebjM2ja6CVpERERyHPUAiYiISI6jACQiIiI5jgKQiIiI5DgKQCIiIpLjKABlQvPnz8fb2xsXFxf8/PzYsWPHI9ffvn07fn5+uLi44OPjw+eff57i/UWLFtGkSRPy5ctHvnz5ePrpp9m/f781T8Fq0rtt/teaNWswmUx06tQpnavOGNZom8jISIYPH07RokVxcXGhUqVKbNy40VqnYDXWaJtZs2ZRoUIFXF1d8fLyYsyYMdy5c8dap2AVaWmXsLAwevbsSYUKFbCzs2P06NEPXG/t2rX4+vri7OyMr68v3333nZWqt670bpuc+jmc2t+bezL0c9iQTGXNmjWGo6OjsWjRIuPYsWPGqFGjjFy5chnnzp174Ppnzpwx3NzcjFGjRhnHjh0zFi1aZDg6Ohrffvtt8jo9e/Y05s2bZxw8eNA4fvy40b9/f8PDw8O4ePFiRp1WurBG29wTGhpqFC9e3GjSpInRsWNHK59J+rNG28THxxu1a9c2nnnmGWPnzp1GaGiosWPHDiM4ODijTitdWKNtVq5caTg7OxurVq0yzp49a/z6669G0aJFjdGjR2fUaT2xtLbL2bNnjZEjRxpfffWVUaNGDWPUqFH3rbN7927D3t7e+PDDD43jx48bH374oeHg4GDs3bvXymeTvqzRNjn1czg1bXNPRn8OKwBlMnXr1jWGDBmSYlnFihWN8ePHP3D9N954w6hYsWKKZS+//LJRv379hx4jKSnJcHd3N7766qsnLzgDWattkpKSjEaNGhmLFy82+vbtmyUDkDXaZsGCBYaPj4+RkJCQ/gVnIGu0zfDhw42WLVumWGfs2LFG48aN06lq60tru/yvZs2aPfCLrFu3bkbbtm1TLGvTpo3RvXv3J6o1o1mjbf4tp3wO/69HtY0tPod1CSwTSUhIICgoiNatW6dY3rp1a3bv3v3Abfbs2XPf+m3atOHAgQMkJiY+cJu4uDgSExPJnz9/+hSeAazZNpMnT6ZgwYIMGDAg/QvPANZqmw0bNtCgQQOGDx9O4cKFqVKlCh9++CFms9k6J2IF1mqbxo0bExQUlHwJ48yZM2zcuJH27dtb4SzS3+O0S2o8rO2eZJ8ZzVpt82855XM4tWzxOayHoWYiERERmM1mChcunGJ54cKFCQ8Pf+A24eHhD1w/KSmJiIgIihYtet8248ePp3jx4jz99NPpV7yVWattdu3axZIlSwgODrZW6VZnrbY5c+YMW7dupVevXmzcuJFTp04xfPhwkpKSmDhxotXOJz1Zq226d+/OtWvXaNy4MYZhkJSUxNChQxk/frzVziU9PU67pMbD2u5J9pnRrNU2/5ZTPodTw1afwwpAmZDJZErx2jCM+5b91/oPWg7w8ccfExAQwLZt23BxcUmHajNWerZNTEwMvXv3ZtGiRRQoUCD9i81g6f17Y7FYKFSoEF988QX29vb4+flx+fJlpk+fnmUC0D3p3Tbbtm1jypQpzJ8/n3r16hESEsKoUaMoWrQoEyZMSOfqrSet7WKrfdqCNc8jp30OP4otP4cVgDKRAgUKYG9vf1+Svnr16n2J+54iRYo8cH0HBwc8PT1TLP/kk0/48MMP+e2336hWrVr6Fm9l1mibo0ePEhoaSocOHZLft1gsADg4OHDy5EnKlCmTzmeS/qz1e1O0aFEcHR2xt7dPXqdSpUqEh4eTkJCAk5NTOp9J+rNW20yYMIE+ffowcOBAAKpWrUpsbCyDBw/m7bffxs4uc99d8DjtkhoPa7sn2WdGs1bb3JPTPof/y+nTp232OZy5/5XmME5OTvj5+bF58+YUyzdv3kzDhg0fuE2DBg3uW3/Tpk3Url0bR0fH5GXTp0/n/fff55dffqF27drpX7yVWaNtKlasyJEjRwgODk7+ee6552jRogXBwcF4eXlZ7XzSk7V+bxo1akRISEjyhxHAP//8Q9GiRbNE+AHrtU1cXNx9Icfe3h7j7sCSdDwD63icdkmNh7Xdk+wzo1mrbSBnfg7/F5t+Dlv9NmtJk3tDDJcsWWIcO3bMGD16tJErVy4jNDTUMAzDGD9+vNGnT5/k9e8N2R0zZoxx7NgxY8mSJfcN2Z02bZrh5ORkfPvtt0ZYWFjyT0xMTIaf35OwRtv8W1YdBWaNtjl//ryRO3duY8SIEcbJkyeNH3/80ShUqJDxwQcfZPj5PQlrtM2kSZMMd3d3IyAgwDhz5oyxadMmo0yZMka3bt0y/PweV1rbxTAM4+DBg8bBgwcNPz8/o2fPnsbBgweNo0ePJr+/a9cuw97e3vjoo4+M48ePGx999FGWHgafnm2TUz+HDeO/2+bfMupzWAEoE5o3b55RqlQpw8nJyahVq5axffv25Pf69u1rNGvWLMX627ZtM2rWrGk4OTkZpUuXNhYsWJDi/VKlShnAfT+TJk3KgLNJX+ndNv+WVQOQYVinbXbv3m3Uq1fPcHZ2Nnx8fIwpU6YYSUlJ1j6VdJfebZOYmGi8++67RpkyZQwXFxfDy8vLGDZsmHHz5s0MOJv0k9Z2edDnSKlSpVKs88033xgVKlQwHB0djYoVKxpr167NgDNJf+ndNjn5czg1vzf/K6M+h03/V5yIiIhIjqF7gERERCTHUQASERGRHEcBSERERHIcBSARERHJcRSAREREJMdRABIREZEcRwFIREREchwFIBEREclxFIBEJEcLDQ2ldOnSbN261daliEgGUgASkSzpjz/+oEOHDhQrVgyTycT333//wPWaN2/O559//tD9rFixgrlz59KyZUu2bduGyWSiSpUqmM3mFOvlzZuXZcuWpeMZiIgtKQCJSJYUGxtL9erVmTt37kPXuXHjBrt376ZDhw4PXWfTpk20bds2xbLTp0+zfPnydKtVRDIfB1sXICLyONq1a0e7du0euc5PP/1E9erVKV68+APf37t3L7Vr18bBIeVH4SuvvMKkSZPo0aMHLi4u6VaziGQe6gESkWxrw4YNdOzYMfl1WFhYiveXL19O375979tu9OjRJCUlPbJ3SUSyNgUgEcmW4uPj+fXXX+nYsSMWi4Xhw4dTsmRJLl26BEBCQgInTpygRo0a923r5ubGpEmTmDp1KlFRURlcuYhkBAUgEcmWtm7diqenJ1WrVsXOzo558+ZRv359Vq9eDdy9PPbss88+dPsBAwZQoEABpk2bllEli0gGUgASkWzp35e/APr06cPKlSsBWL16NT179nzo9g4ODnzwwQd89tlnXL582aq1ikjGUwASkWzHMAx++OEHnnvuuRTLu3XrxsmTJ9m2bRtms5kiRYo8cj8vvPAClStX5r333rNmuSJiAxoFJiJZ0q1btwgJCUl+ffbsWYKDg8mfPz9Xr14lNjaWpk2bptgmb968PPPMM7z44ot88sknqTrORx99RJs2bdK1dhGxPQUgEcmSDhw4QIsWLZJfjx07FoC+ffvi5eVF+/bt7xveDtC7d29+//33+3qHHqZly5a0bNmSTZs2pU/hIpIpmAzDMGxdhIhIeqpWrRrvvPMO3bp1u++9hIQElixZwtChQ21QmYhkFgpAIpKtJCQkMHXqVMaOHYu7u7utyxGRTEoBSERERHIcjQITERGRHEcBSERERHIcBSARERHJcRSAREREJMdRABIREZEcRwFIREREchwFIBEREclxFIBEREQkx1EAEhERkRzn/wGBT/cVWtMc5QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(1 / jnp.sqrt(jnp.array(sample_sizes)), ksd_vals, label=\"KSD\")\n",
    "\n",
    "coef = np.polyfit(1 / jnp.sqrt(jnp.array(sample_sizes)),ksd_vals,1)\n",
    "poly1d_fn = np.poly1d(coef) \n",
    "# poly1d_fn is now a function which takes in x and returns an estimate for y\n",
    "\n",
    "plt.plot(1 / jnp.sqrt(jnp.array(sample_sizes)), poly1d_fn(jnp.array(1 / jnp.sqrt(jnp.array(sample_sizes)))), '--k', label=\"linear fit\")\n",
    "plt.xlabel(\"1/√N\")\n",
    "plt.ylabel(\"KSD(X, p)\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e11843b-d02a-4a33-b822-c0d7369ee2bb",
   "metadata": {},
   "source": [
    "## Randomness in JAX"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65142534-1c18-4e40-af17-d611499a1da3",
   "metadata": {},
   "source": [
    "### Description "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9a720f-6f12-48ff-aeeb-c3c2c9a9ccbb",
   "metadata": {},
   "source": [
    "- So far, we have conveniently evaded the notion of randomness in Jax by delegating draws from probability distributions to numpy.\n",
    "- Random variables can be drawn from jax. However, the handling of randomness is an example of the functionalization constraint that jax imposes.\n",
    "- his constrain prevents numpy-like random variables drawing, since drawing a random variable in numpy incurs a side effect by modifying numpy's random state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "93f314aa-5ec6-4f67-9e70-e1215e7ff5d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_one_random_variable():\n",
    "    return np.random.randn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "36bdb6a9-e92c-474d-b846-8f97d462d1fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.6218898697659059 0.45215438948829273\n"
     ]
    }
   ],
   "source": [
    "print(draw_one_random_variable(), draw_one_random_variable())  # two different outputs for the same input (Φ): "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2781b0-d006-4f43-b51f-682286dd4dac",
   "metadata": {},
   "source": [
    "`RandomState` Based randomness generation is also forbidden in functional programming frameworks, since it modifies its input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "90a08a0c-b2c7-44f5-a9a3-70e4dbe72bbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_one_random_variable_RandomState(rs):\n",
    "    return rs.randn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "a1655007-e9ce-40ed-a57e-a49c2de6c981",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rs = np.random.RandomState(42)\n",
    "orig_state = rs.get_state()\n",
    "\n",
    "draw_one_random_variable_RandomState(rs)\n",
    "np.allclose(rs.get_state()[1], orig_state[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb152e1-01a9-4689-9bcd-64eef2d61a6c",
   "metadata": {},
   "source": [
    "Instead, `jax` generates random variables in a functionally pure manner by:\n",
    "- requiring a one-off `PRNGKey`, a `RandomState` equivalent characterizing some pseudorandomness state.\n",
    "- not alterating this key when generating a random variable\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7033363-a038-487e-bf3d-b9775c409a17",
   "metadata": {},
   "source": [
    "- The consequence of this pure randomness generation is that new keys must be repeteadly generated to \"create\" new randomness.\n",
    "- Generating new keys from old ones is known in the computational pseudorandomness literrature as splitting, for which a utility function is provided in jax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "09d05b35-7018-4530-9b44-e66f31e08f50",
   "metadata": {},
   "outputs": [],
   "source": [
    "#                                           key \n",
    "#                                           | \n",
    "#                                           |  random.split(key)\n",
    "#                                           | \n",
    "#                             ---------------------------\n",
    "#                             |                          |\n",
    "#                             |                          |\n",
    "#                             |                          |\n",
    "#                           subkey1                    subkey2\n",
    "#                              | \n",
    "#     random.split(subkey1)    |                         |  random.split(subkey2)\n",
    "#                              |                         | \n",
    "#                        --------------            --------------\n",
    "#                        |            |            |            |\n",
    "#                        |            |            |            |\n",
    "#                        |            |            |            |\n",
    "#                       subkey1.1   subkey1.2   subkey2.1      subkey2.2\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "bb7037e4-253e-47e2-b794-d4b6cb7b96ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "from jax import random\n",
    "key = random.PRNGKey(42)\n",
    "\n",
    "key, subkey = random.split(key)\n",
    "# provide a one-shot \"RandomState\"-like subkey to generate a random variable.\n",
    "x1 = random.normal(subkey)\n",
    "\n",
    "# From now on, subkey cannot be used since it was used to generate randomness in random.normal\n",
    "x1_same = random.normal(subkey)\n",
    "assert x1_same == x1\n",
    "\n",
    "# You're left with an \"untouched\" new key that can be split to generate new randomness\n",
    "key, subkey = random.split(subkey)\n",
    "\n",
    "x2 = random.normal(subkey)\n",
    "assert x2 != x1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42a1af8c-eec9-4e90-8a78-37651b0b6600",
   "metadata": {},
   "source": [
    "### Exercise 3: re-plot the KSD values obtained from your previous exercise, but by generating random jax arrays natively this time!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "61430432-a145-4e2f-a6ab-301c13f4ddf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from jax import random\n",
    "\n",
    "sample_sizes = (50, 100, 200, 300, 500, 1000, 2000, 5000)\n",
    "\n",
    "key = random.PRNGKey(0)\n",
    "\n",
    "ksd_vals = []\n",
    "for N in sample_sizes:\n",
    "    ksd_vals_this_iter = []\n",
    "    for rs in range(5):\n",
    "        # 1. generate jax randomness, 2. generate array of appropriate size\n",
    "        ksd_vals_this_iter.append(jit(ksd)(jnp.array(X)))\n",
    "    ksd_vals.append(jnp.mean(jnp.array(ksd_vals_this_iter)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94d5ec3d-aab8-446b-a63b-58e21972779b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(1 / jnp.sqrt(jnp.array(sample_sizes)), ksd_vals, label=\"KSD\")\n",
    "\n",
    "coef = np.polyfit(1 / jnp.sqrt(jnp.array(sample_sizes)),ksd_vals,1)\n",
    "poly1d_fn = np.poly1d(coef) \n",
    "# poly1d_fn is now a function which takes in x and returns an estimate for y\n",
    "\n",
    "plt.plot(1 / jnp.sqrt(jnp.array(sample_sizes)), poly1d_fn(jnp.array(1 / jnp.sqrt(jnp.array(sample_sizes)))), '--k', label=\"linear fit\")\n",
    "plt.xlabel(\"1/√N\")\n",
    "plt.ylabel(\"KSD(X, p)\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aafd0bb-3c90-423a-b969-4ace884b7acf",
   "metadata": {},
   "source": [
    "## Control-Flows in JAX\n",
    "\n",
    "Understanding control flows in `jax` requires some additional digging of jax internals:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4534d45e-92f9-472d-a93f-8790dd79c717",
   "metadata": {},
   "source": [
    "### A primer on jax internals: static shapes, functional purity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad38c9fe-1f83-41de-be22-945cddfc1dda",
   "metadata": {},
   "source": [
    "\n",
    "- Jax works by transforming a functionally pure function into a directed acyclic computation graph\n",
    "- The interpreted nature of python makes the creation of this graph a challenge: such computation graphs are typically created ahead of time, during the compilation process when working with compiled languages.\n",
    "- In intrepreted languages, the structure of the computational graph will be \"discovered\" at runtime, when executing the said program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3551379f-4939-4459-b35c-cec5e31c201f",
   "metadata": {},
   "source": [
    "- To build this graph, jax relies on the amazing polymorphism capabilities of Python by substituting input to jax functions with special jax constructs called \"tracers\".\n",
    "- These tracers progressively record the set of instructions applied on them, gathering the necessary informations to create a computational graph, called a \"Jax Intermediate Representation\", or JAX IR.\n",
    "- This graph can then be traversed to perform computation graph transformations by defining appropritate transformation translation rules, leading to `vmap`, `jit`, `grad` etc.\n",
    "\n",
    "\n",
    "Jax IRs can be described using a 1st order ANF called a `jaxpr`. Example is given below (credits to the Jax Team for the slides)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0700bcf-6928-4298-b329-a501c130b159",
   "metadata": {},
   "source": [
    "![title](./fun_to_jax_ir.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f26f401-37e9-4c90-8ddb-4016b07d7507",
   "metadata": {},
   "source": [
    "### Constructing jax-friendly control flows "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe45ea2-fc0a-4171-97d9-f4a371fcab71",
   "metadata": {},
   "source": [
    "Additionally, as of now, `jaxpr`s are specialized to specific input and output shapes: thus, these shapes are required to be static, and cannot change depending on the value of the input. Thus, the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "03e7e1b7-f98b-4a58-a283-b8c6a2b67b32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    if x > 0:\n",
    "        return jnp.ones((2,))\n",
    "    else:\n",
    "        return jnp.ones((3,))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "649b55df-9635-413c-836e-ebb561ee0067",
   "metadata": {},
   "source": [
    "will not yield a valid `jaxpr`, as the shape of the output depends on dynamic values (namely the values on the input).\n",
    "Note however that because shapes are treated as static this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e39493c8-5931-4508-9718-50afaf57d5f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    if x.shape[0] == 2:\n",
    "        return jnp.ones((2,))\n",
    "    elif x.shape[0] == 3:\n",
    "        return jnp.ones((3,))\n",
    "    else:\n",
    "        raise ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad67505-d14e-46c4-8ad6-5124d3a4e28b",
   "metadata": {},
   "source": [
    "will yield a valid `jaxpr`, and can thus be subject to transformations.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9488908a-ba58-49bf-a932-16fc49c6c7d7",
   "metadata": {},
   "source": [
    "#### Jax Conditionals\n",
    "\n",
    "Note however, that even a modified version of the first function that would return outputs with identical shapes on both branches:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "a259c020-0222-499b-9e15-7dbe8c4ffc73",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    if x > 0:\n",
    "        return jnp.ones((2,))\n",
    "    else:\n",
    "        return jnp.zeros((2,))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4973897c-0388-49e9-8ea0-bb89683dad5d",
   "metadata": {},
   "source": [
    "is fundamentally incompatible with a tracing-based mechanism: within a single function call, a tracer will visit only one branch,\n",
    "leading to an incomplete construction of the funciton's computational graph.\n",
    "\n",
    "To solve this problem, jax exposes special control-flow primitives to be used in-lieu of Python control flows. Here is a jax-compatible rewrite of `f`,\n",
    "using `jax.lax.cond`, the native jax if-statement primitive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "0678e724-7cc2-4bdd-ac0e-5b230b0b7d15",
   "metadata": {},
   "outputs": [],
   "source": [
    "import jax.lax\n",
    "\n",
    "def f(x):\n",
    "    return jax.lax.cond(x > 0, lambda: jnp.ones((2,)), lambda: jnp.zeros((2,)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "23fde93a-338d-45c6-930b-106b4834c171",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f(-1.)=DeviceArray([0., 0.], dtype=float32)\n",
      "f(2.)=DeviceArray([1., 1.], dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(f\"{f(-1.)=}\")\n",
    "print(f\"{f(2.)=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db9f0aed-2a14-4da5-9b1e-3fd5d4a76bc3",
   "metadata": {},
   "source": [
    "#### Jax for-loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aada819-eabe-4c3d-8f26-ef12fcc6048e",
   "metadata": {},
   "source": [
    "for `for-loop` primitives, something different is at stake. Indeed, consider the following, (jax-valid) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8ca4099f-802d-4830-8e2a-90e72f5adf52",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    for i in range(100):\n",
    "        x = x+1\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd13ca3b-7119-4268-b8c5-727f90815b19",
   "metadata": {},
   "source": [
    "Unlike for the if-statement case, a jax-tracer will completely visit `f`'s computational graph. However, the tracer will not be aware of the loop-structure:\n",
    "\n",
    "- Looking at the resulting computational graph, the loop will appear \"unrolled\", e.g. each iteration yielding it's independent sequence of operations.\n",
    "- Statically unrolling python for-loops can become costly when the number of iterations increases, increasing the compilation time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd8878b-8bc5-4411-9391-954ccf784a74",
   "metadata": {},
   "source": [
    "- As you may have figured it, jax exposes a for-loop special primitive, that lowers the entire loop to a single HLO For node.\n",
    "- Using `jax.lax.cond` the user tells much more about the structure of the for loop than using a dynamic Pythonic for loop.\n",
    "- In particular, all outputs of `body_fun` must keep the same shape across iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "72a2b700-4cdc-428b-91b1-ac3bdb4063fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import jax.lax\n",
    "\n",
    "def f_fori_loop(x):\n",
    "    def body_fun(i, x):\n",
    "        return x+1\n",
    "    return jax.lax.fori_loop(0, 100, body_fun, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "984c76be-96c0-42c7-838f-4e0478f59c93",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert f(1) == f_fori_loop(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e2ce1a-3534-4f12-9db4-7a4991f9a7d8",
   "metadata": {},
   "source": [
    "Note that this `fori_loop` does not capture intermediates iterates, but only the final iterate. Instead, use `jax.lax.scan` to capture all intermediate iterates."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cda11e2e-3f8c-4de4-a25d-a5c4d76a0a2f",
   "metadata": {},
   "source": [
    "### Exercise 4: implementing a Monte-Carlo Markov Chain Algorithm\n",
    "\n",
    "\n",
    "- A Monte-Carlo Markov Chain algorithm is an algorithm that can be used to approximately sample from an unnormalized probabilty distribution p.\n",
    "- MCMC algorithm srepeateadly generates iterates $x_i$ by drawing them from a **Markov Kernel** $k(x_{i-1}, \\cdot)$, a distributution parametrized by $x_{i-1}$ and which admits $p$ as an invariant distribution:\n",
    "\n",
    "$$\n",
    "\\int k(x, y) p(x) = p(y)\n",
    "$$\n",
    "\n",
    "A famous family of kernels are Metropolis Hasting kernels, which, given some input $x$ (typically, $x_{i-1}$ during a loop), are parametrized by a proposal distribution $q(\\cdot | x)$ and are described by the following probabilistic program:\n",
    "\n",
    "\n",
    "**How to sample from $k(\\cdot, x)$**\n",
    "\n",
    "- generate $x' \\sim q(\\cdot|x)$\n",
    "-  $\\alpha = \\frac{p(x')q(x | x')}{p(x)q(x'|x)}$\n",
    "-  with prob. $\\min(\\alpha, 1)$, return x'. Else, return x."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f6f72cc-b615-43d2-88f9-9ae146c0283a",
   "metadata": {},
   "source": [
    "The goal of this exercise is to write an efficient implementation of a MCMC algorithm with for some target density $p(x)$ given below, random walk MH kernel,  which is a MH kernel characetrized by the proposal distribution $q(x, y) = \\mathcal N(x-y, \\sigma^2 I_2)$. \n",
    "\n",
    "Importantly, this proposal is symmetric $q(x|x')=q(x'|x)$. Thus, the computation of $\\alpha$ reduces to $p(x')/p(x)$.\n",
    "  \n",
    "\n",
    "To complete this algorithm you will have to:\n",
    "- implement the random walk kernel\n",
    "- create the for-loop representing the MCMC algorith, using a jax.lax.scan primitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "f5bf9063-affe-4c2c-8e80-09949d87e2d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def p(x):\n",
    "    \n",
    "    # the unnormalized density of interest\n",
    "    sigma = 1.\n",
    "    return jnp.exp(-0.5/sigma**2 * jnp.sum(jnp.square(x - jnp.ones((2,)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "6d878b9d-068e-46d9-a74b-cbff7c7c19df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the proposal distribution q(\\cdot | x)\n",
    "def q(x, y):\n",
    "    return jnp.exp(-0.5/sigma**2 * jnp.sum(jnp.square(x - y)))\n",
    "\n",
    "def random_walk_kernel(x, key, sigma=1):\n",
    "    # 1. generate x' from q(x, \\cdot). Hint: use a shifted and scaled sample from random.normal.\n",
    "    # 2. compute \\alpha\n",
    "    # 3. return x or x'.\n",
    "    raise NotImplemented"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f75e6c74-b459-46a2-9310-3378b3151c40",
   "metadata": {},
   "source": [
    " Careful! there should not be native if statements! try running a jitted version of `random_walk_kernel`\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f51cba4e-f50b-4853-ae61-b6ac4c6e2904",
   "metadata": {},
   "outputs": [],
   "source": [
    "x0 = jnp.zeros((2,))\n",
    "key = random.PRNGKey(0)\n",
    "\n",
    "x1 = random_walk_kernel(x0, key)\n",
    "x1_jitted = jit(random_walk_kernel)(x0, key)\n",
    "\n",
    "assert jnp.allclose(x1, x1_jitted)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43495098-33bd-4b44-bd97-a21042aafb64",
   "metadata": {},
   "source": [
    "For the next step, implement a full MCMC algorithm by iteratively sampling from this kernel.\n",
    "Below is a for-loop equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "945d3e58-266e-4f9d-acfd-bd2b89c27071",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rw_mcmc(num_steps, x0, key):\n",
    "    x = x0\n",
    "    iterates = [x]\n",
    "    for i in range(steps):\n",
    "        key, subkey = random.split(key)\n",
    "        x = random_walk_kernel(x, subkey)\n",
    "        iterates.append(x)\n",
    "    return iterates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "009f8a91-7032-412f-a75d-b38ab7a684ce",
   "metadata": {},
   "source": [
    "Fill the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c814c93-cd2e-411c-9f99-ffecfd071d2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rw_mcmc_jax_control_flow(num_steps, x0, key):\n",
    "    x = x0\n",
    "    iterates = [x]\n",
    "    \n",
    "    def step_fn(carry, input_):\n",
    "        output = ...  # do a MH kernel step\n",
    "        return output, output\n",
    "    \n",
    "    # call jax.lax.scan using step_fn as its step function.\n",
    "    _, iterates  = jax.lax.scan(...)\n",
    "    return iterates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f963ff5-81b2-47d1-9144-90492a3d5560",
   "metadata": {},
   "source": [
    "You will notice how much faster the version of  `rw_mcmc` using jax.lax control flow is as opposed to its Python counterpart!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d96037f-e74f-402c-84d1-465a485315ac",
   "metadata": {},
   "source": [
    "## Extending the flexibility of jax functions with PyTrees\n",
    "\n",
    "\n",
    "### A Primer on PyTrees \n",
    "\n",
    "The aforementioned fact that valid `jax` functions could only take `jax` arrays as inputs and return `jax` arrays is a slight reduction. Actually, jax functions can take as inputs arbitrary nested collections  JAX arrays. These nested collections are called PyTrees.\n",
    "\n",
    "- Collections that defines valid PyTrees by defaults are tuples, namedtuple, lists, dictionaries. PyTrees are characetrized by the structure or the nested collections (where the cardinality of each collection is a static attribute of the PyTree structure, i.e cannot change across instances of this pytree structure). Such collections have a tree structure (hence the name), and the leaves are the array.\n",
    "- The structure of the PyTree is called a PyTreeDef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "38782b7d-6956-4905-8f24-014f73681128",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example\n",
    "some_pytree = {'a': jnp.ones((2,)), 'b': jnp.ones((2,))}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6becb5a7-3abc-4dc0-9335-ec7aa2b72f0c",
   "metadata": {},
   "source": [
    "The principles applying to jax arrays mostly generalize to PyTrees. For instances, shapes must be known statically. This function for example is invalid jax code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c8ca3b35-d4cd-4918-9df4-76d2b93b60bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    return jax.lax.cond(True, lambda: [jnp.ones((2,)), jnp.ones((3,))], lambda: [jnp.ones((3,)), jnp.ones((3,))])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d64ce41-986e-4e50-adb8-57ca62423d59",
   "metadata": {},
   "source": [
    "Pytrees can be differentiated of vmapped against:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "23648821-a677-4c8c-8e48-f37c1da6f75e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(tree):\n",
    "    return 2 * tree['a']['c'] * tree['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "bccf93c7-9fc3-4b4b-a449-d12461f60e04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': {'c': DeviceArray(-4., dtype=float32, weak_type=True)},\n",
       " 'b': DeviceArray(20., dtype=float32, weak_type=True)}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grad_f = grad(f)\n",
    "grad_f({'a': {'c': 10.}, 'b': -2.})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "bcc247d1-6d55-4769-b83d-153fa642c36f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([  -0.,  -40.,  -80., -120., -160., -200., -240., -280.,\n",
       "             -320., -360.], dtype=float32)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vmapped_f = vmap(f)\n",
    "vmapped_f({'a': {'c': 10. * jnp.ones((10,))}, 'b': -2. * jnp.arange(10)})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da0e5217-c07d-4dc0-8f4d-b7d494b9680e",
   "metadata": {},
   "source": [
    "All such operations can be done only on part of the PyTree structure of each argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "0d9446ba-ba53-4832-b7a8-165221182cac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([-40., -40., -40., -40., -40., -40., -40., -40., -40., -40.],            dtype=float32)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vmapped_f_partial = vmap(f, in_axes=({'a': {'c': 0}, 'b': None}, ))  # a bit error-prone: this is currently a jax usability weak spot.\n",
    "vmapped_f_partial({'a': {'c': 10. * jnp.ones((10,))}, 'b': -2.})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "927a6a98-60d7-4ca1-b786-991a66f2b18e",
   "metadata": {},
   "source": [
    " pytrees are useful to represent the internal state (e.g. the weights, the batch norm statistics, etc) of a neural network, as often, neural network have a nested/hierechical/modular structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aab100e-83a9-4fc3-ac47-6b7126ed7ce0",
   "metadata": {},
   "source": [
    "### Convenients PyTrees\n",
    "\n",
    "Two important remarks on PyTree are in order:\n",
    "\n",
    "- NamedTuple are PyTree. Using namedtuples often prevent extenive kwargs plumbing in functions, by gathering all \"configuration\" arguments (as opposed to actual variables) to a function within a `Config` NamedTuple Umbrella (note that all attributes of the named tuple must be tracable!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8036103b-2eb7-4c82-835b-287849917fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import NamedTuple\n",
    "class MyAlgorithmConfig(NamedTuple):\n",
    "    learning_rate: int = 0.01\n",
    "    regularization_val: int = 0.001\n",
    "    # careful! if the training loop was implememted as a jax.lax.scan loop,\n",
    "    # num_iter will have to be static, as it impacts the output shape of the scan loop\n",
    "    # num_iter = 100\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "110ec796-b937-4f85-908a-888ae62e0ae8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_my_network(X, y, my_algorithm_config: MyAlgorithmConfig,\n",
    "                     # num_iter = 100\n",
    "                    ):\n",
    "    ...\n",
    "    \n",
    "# instead of\n",
    "def train_my_network(X, y, learning_rate, regularization_val, \n",
    "                     # num_iter = 100\n",
    "                    ):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d21c30-1722-47e8-afa9-b703799e0d1f",
   "metadata": {},
   "source": [
    "- Additional User-Defined Collection Types can be registered as PyTreeNodes, using the jax.tree_util.register_pytree_node_class\n",
    "- However, `flax`, a jax-powered neural network library, exposes a `struct.PyTreeNode` helper allowing the extremly useful operation:\n",
    "  - automatically register dataclass-like classes...\n",
    "  - ...while manually specifying which arguments are static and which are traceable! Thanks to this, `num_iter` in the previous example can be safely ignored:\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fda057f5-afaf-4a2b-b737-cc3b9f8095c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from flax import struct\n",
    "\n",
    "class MyAlgorithmConfig(struct.PyTreeNode):\n",
    "    learning_rate: int = 0.01\n",
    "    regularization_val: int = 0.001\n",
    "    # num_iter can be marked as static!\n",
    "    num_iter: int = struct.field(pytree_node=False, default=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d550e43-baa4-4e97-9eb5-e17c3c943ef3",
   "metadata": {},
   "source": [
    "## A final End-to-end example. Mixture of Gaussians:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d682d61-4542-427b-b6e3-aad6e186e17b",
   "metadata": {},
   "source": [
    "### What This Example shows"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bcf1ebc-122d-4266-bb07-08e1b783abab",
   "metadata": {},
   "source": [
    "This final example is an end-to-end macro-example showcasing the capabilities of jax on a end-to-end algorithm with a few subtlelties: a mixture of gaussian algorithms. In particular, this examples demostrates:\n",
    "\n",
    "- the functional nature of jax through the use of functional slice setting semantics (x = x.at[i].set(y))\n",
    "- the use of user-defined PyTrees, both as input and output algorithm\n",
    "- top-level use of jax.vmap to seamlessly vectorize the algorithm over random initializations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "524f1124-831e-46d0-ab3f-3d1a617c1fb7",
   "metadata": {},
   "source": [
    "### Show Me the Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4c45c09b-fbfe-4956-9e06-71ef7ddd9d93",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import NamedTuple\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from flax import struct\n",
    "from jax import random\n",
    "from jax._src.api import vmap\n",
    "from jax.nn import log_softmax, logsumexp\n",
    "from jax.tree_util import tree_map\n",
    "from jax.flatten_util import ravel_pytree  # type: ignore\n",
    "from numpyro import distributions as np_distributions\n",
    "import numpy as np\n",
    "\n",
    "from typing import Any\n",
    "Array, Numeric, PRNGKeyArray = Any, Any, Any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "12fdf9e5-cb5a-44d6-a55c-b55b077be951",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MOGDistribution(np_distributions.Distribution):\n",
    "    def __init__(self, cluster_means: Array, cluster_covs: Array, cluster_props: Array):\n",
    "        assert len(cluster_means.shape) == 2\n",
    "        self._num_clusters, self._num_dims = cluster_means.shape\n",
    "        self.cluster_means = cluster_means\n",
    "\n",
    "        assert len(cluster_props.shape) == 1\n",
    "        self.cluster_props = cluster_props\n",
    "\n",
    "        self.cluster_covs = cluster_covs\n",
    "\n",
    "        self._dists = np_distributions.MultivariateNormal(\n",
    "            cluster_means, covariance_matrix=cluster_covs\n",
    "        )\n",
    "\n",
    "        super(MOGDistribution, self).__init__(\n",
    "            batch_shape=(), event_shape=(self._num_dims,)\n",
    "        )\n",
    "\n",
    "    def log_prob(self, x: Array):\n",
    "        assert len(x.shape) == 1\n",
    "        return logsumexp(self._dists.log_prob(x), b=self.cluster_props)\n",
    "\n",
    "    def _sample_from_cluster_idx(self, key, idx):\n",
    "        return tree_map(lambda d: d[idx], self._dists).sample(key)\n",
    "\n",
    "    def sample(self, key: PRNGKeyArray, sample_shape: tuple = ()) -> Array:\n",
    "        if sample_shape == tuple():\n",
    "            sample_shape = (1,)\n",
    "\n",
    "        key, key_latent = random.split(key)\n",
    "\n",
    "        mn = np_distributions.Categorical(probs=self.cluster_props)\n",
    "        idxs = mn.sample(key_latent, sample_shape=sample_shape)\n",
    "        keys_observed = random.split(key, num=sample_shape[0])\n",
    "        return vmap(self._sample_from_cluster_idx, in_axes=(0, 0))(  # type: ignore\n",
    "            keys_observed, idxs\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ed3896a3-f636-40b5-96ce-6c9d1a771af2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MOGTrainingConfig(struct.PyTreeNode):\n",
    "    num_clusters: int = struct.field(pytree_node=False)\n",
    "    max_iter: int = struct.field(pytree_node=False)\n",
    "    num_inits: int = struct.field(pytree_node=False)\n",
    "    min_std: float = struct.field(pytree_node=True, default=0.01)\n",
    "    max_train_samples: int = struct.field(pytree_node=False, default=1000)\n",
    "    cov_reg_param: int = struct.field(pytree_node=False, default=1e-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ec1d8153-fd45-4cfa-a9f0-2f8633c7e257",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _kmeans_plus_plus_init(data: Array, num_clusters: int, key: PRNGKeyArray) -> Array:\n",
    "    num_points, num_dim = data.shape\n",
    "    clusters = jnp.empty((num_clusters, num_dim))\n",
    "\n",
    "    init_cluster_data_idx = random.choice(key, a=num_points)\n",
    "    init_cluster_center = data[init_cluster_data_idx, :]\n",
    "\n",
    "    this_cluster_center = init_cluster_center\n",
    "    clusters = clusters.at[0, :].set(this_cluster_center)\n",
    "\n",
    "    all_sq_dists = jnp.inf * jnp.ones((num_points, num_clusters))\n",
    "\n",
    "    for i in range(num_clusters - 1):\n",
    "        sq_dists = jnp.sum(jnp.square(data - this_cluster_center), axis=1)\n",
    "\n",
    "        all_sq_dists = all_sq_dists.at[:, i].set(sq_dists)\n",
    "        min_sq_dists = jnp.min(all_sq_dists, axis=1)\n",
    "\n",
    "        key, subkey = random.split(key)\n",
    "        next_cluster_idx = random.categorical(\n",
    "            subkey, logits=jnp.log(min_sq_dists + 1e-15)\n",
    "        )\n",
    "        next_cluster_center = data[next_cluster_idx]\n",
    "\n",
    "        this_cluster_center = next_cluster_center\n",
    "        clusters = clusters.at[i + 1, :].set(this_cluster_center)\n",
    "\n",
    "    return clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9f7c926c-9a55-4361-8fde-30a342a82055",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MOGResult(NamedTuple):\n",
    "    # don't return a MOGDistribution because numpyro Distributions objects are not\n",
    "    # vmap-able\n",
    "    min_std: float\n",
    "    cluster_init: Array\n",
    "    cluster_means: Array\n",
    "    cluster_covs: Array\n",
    "    cluster_props: Array\n",
    "    log_probs: Array\n",
    "    final_log_prob: Numeric\n",
    "    converged: bool\n",
    "    num_iter_convergence: Numeric\n",
    "\n",
    "    def to_dist(self) -> MOGDistribution:\n",
    "        return MOGDistribution(\n",
    "            self.cluster_means, self.cluster_covs, self.cluster_props\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3d41eeda-49b6-4dec-8bb4-ab01d787dc88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _fit_one_mog(\n",
    "    data: Array, num_clusters: int, min_std: float, max_iter: int,\n",
    "    max_train_samples: int, cov_reg_param: float, key: PRNGKeyArray\n",
    ") -> MOGResult:\n",
    "    num_points, num_dims = data.shape\n",
    "\n",
    "    assert len(data.shape) == 2\n",
    "    # TODO: kmeans++?\n",
    "\n",
    "    if data.shape[0] > max_train_samples:\n",
    "        key, subkey = random.split(key)\n",
    "        data = random.permutation(subkey, data, axis=0)\n",
    "        data = data[:max_train_samples]\n",
    "\n",
    "    # init_cluster_data_idx = random.choice(key, a=num_points, shape=(num_clusters,))\n",
    "\n",
    "    # cluster_means = data[init_cluster_data_idx]\n",
    "    key, key_init = random.split(key)\n",
    "    init_cluster_means = _kmeans_plus_plus_init(data, num_clusters, key_init)\n",
    "    init_cluster_covs = jnp.stack(\n",
    "        [jnp.eye(num_dims) for _ in range(num_clusters)], axis=0\n",
    "    )\n",
    "\n",
    "    log_cluster_props = -np.log(num_clusters) * jnp.ones((num_clusters,))\n",
    "\n",
    "    log_prob = prev_log_prob = -jnp.inf\n",
    "\n",
    "    iter_no = 0\n",
    "    assert max_iter > 0\n",
    "\n",
    "    converged = False\n",
    "    num_iter_convergence = 0\n",
    "\n",
    "    log_probs = jnp.empty((max_iter,))\n",
    "\n",
    "    cluster_means = init_cluster_means\n",
    "    cluster_covs = init_cluster_covs\n",
    "\n",
    "\n",
    "    for iter_no in range(max_iter):\n",
    "        dists = np_distributions.MultivariateNormal(\n",
    "            cluster_means,\n",
    "            covariance_matrix=cluster_covs,\n",
    "        )\n",
    "        log_joint = dists.log_prob(data[:, None, :]) + log_cluster_props[None, :]\n",
    "\n",
    "        log_prob = logsumexp(log_joint, axis=1).mean()\n",
    "        log_probs = log_probs.at[iter_no].set(log_prob)\n",
    "\n",
    "        # assert log_prob - prev_log_prob > -1e-6\n",
    "        converged = jnp.abs(log_prob - prev_log_prob) < 1e-4\n",
    "        num_iter_convergence += 1 - converged\n",
    "\n",
    "        # E-step: compute posterior p(z=k|x) (num_points, num_clusters)\n",
    "        log_resps = log_softmax(log_joint, axis=1)\n",
    "\n",
    "        # M-step\n",
    "        # data: (num_points, dim)\n",
    "        # normalized_data_weights: (num_points,num_clusters)\n",
    "        normalized_data_weights = jax.nn.softmax(log_resps, axis=0)\n",
    "        cluster_means = jnp.sum(data[:, None, :] * normalized_data_weights[:, :, None], axis=0)\n",
    "\n",
    "        log_cluster_props = jax.nn.log_softmax(jax.nn.logsumexp(log_resps, axis=0))\n",
    "\n",
    "        def _compute_cov(mean, weights):\n",
    "            return (\n",
    "                (data - mean).T @ jnp.diag(weights) @ (data - mean) + cov_reg_param * jnp.eye(num_dims)\n",
    "            )\n",
    "\n",
    "        cluster_covs = vmap(_compute_cov, in_axes=(0, 1))(cluster_means, normalized_data_weights)  # type: ignore\n",
    "\n",
    "        prev_log_prob = log_prob\n",
    "\n",
    "    def smooth_cov(cov_mat):\n",
    "        from jax.numpy.linalg import eigh\n",
    "        eigvals, eigvecs = eigh(cov_mat)\n",
    "        return eigvecs @ jnp.diag(jnp.clip(jnp.real(eigvals), a_min=min_std ** 2)) @ eigvecs.T\n",
    "\n",
    "    cluster_covs = vmap(smooth_cov)(cluster_covs)\n",
    "    return MOGResult(\n",
    "        min_std,\n",
    "        init_cluster_means,\n",
    "        cluster_means,\n",
    "        cluster_covs,\n",
    "        jax.nn.softmax(log_cluster_props),\n",
    "        log_probs,\n",
    "        log_prob,\n",
    "        converged,\n",
    "        num_iter_convergence,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2a4cb854-b195-4aa4-b3f5-6beddf8bde9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_mog(data: Array, config: MOGTrainingConfig, key: PRNGKeyArray) -> MOGResult:\n",
    "    keys = random.split(key, num=config.num_inits)\n",
    "    vmapped_fit = vmap(_fit_one_mog, in_axes=(None, None, None, None, None, None, 0))  # type: ignore\n",
    "    rets = vmapped_fit(data, config.num_clusters, config.min_std, config.max_iter,\n",
    "                       config.max_train_samples, config.cov_reg_param, keys)\n",
    "\n",
    "    print(rets.final_log_prob)\n",
    "    best_fit_idx = jnp.argmax(rets.final_log_prob)\n",
    "    return tree_map(lambda l: l[best_fit_idx], rets)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bdd8aac9-31fe-48fd-bb8e-77437b83ef14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.3706485 -1.3741974 -1.4081246]\n"
     ]
    }
   ],
   "source": [
    "data = jnp.concatenate([\n",
    "    np_distributions.Normal(0, 0.25).sample(random.PRNGKey(0), (1000, 2)),\n",
    "    np_distributions.Normal(1, 0.25).sample(random.PRNGKey(1), (1000, 2)),\n",
    "    np_distributions.Normal(2, 0.25).sample(random.PRNGKey(2), (1000, 2))\n",
    "    ], axis=0)\n",
    "\n",
    "# fix the algorithm by increasing the number of clusters\n",
    "ret = fit_mog(data, MOGTrainingConfig(2, 100, 3, 0.01), random.PRNGKey(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6abf29a7-4fe2-49f8-9bc2-8c3877d013d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "simulated_data = ret.to_dist().sample(random.PRNGKey(3), sample_shape=(len(data),))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "537f7b68-85bf-4659-9a90-db1c000859ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'MoG-simulated data')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "f, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 5))\n",
    "ax1.scatter(data[:, 0], data[:, 1], s=3)\n",
    "ax1.set_title('training data')\n",
    "\n",
    "ax2.scatter(simulated_data[:, 0], simulated_data[:, 1], s=3)\n",
    "ax2.set_title('MoG-simulated data')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jax-tutorial",
   "language": "python",
   "name": "jax-tutorial"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}