RL_part3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pYs6LMEbNqoQ"
      },
      "source": [
        "# RL coursework, part III (25 pts total)\n",
        "---\n",
        "\n",
        "**Name:** Yuen Chung, CHAN\n",
        "\n",
        "**SN:**\n",
        "\n",
        "---\n",
        "\n",
        "**Due date:** *April 11th, 2024*\n",
        "\n",
        "---\n",
        "\n",
        "Standard UCL policy (including grade deductions) automatically applies for any late submissions.\n",
        "\n",
        "## How to submit\n",
        "\n",
        "When you have completed the exercises and everything has finished running, click on 'File' in the menu-bar and then 'Download .ipynb'. This file must be submitted to Moodle named as **`<studentnumber>_RL_part3.ipynb`** before the deadline above, where `<studentnumber>` is your student number."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rNuohp44N00i"
      },
      "source": [
        "# The Assignment\n",
        "\n",
        "### Objectives\n",
        "\n",
        "You will be guided through the implementation of a full deep reinforcement learning agent."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVBcO5mAV9Ow"
      },
      "source": [
        "## Setup\n",
        "\n",
        "Run all the cells in this section, but do not modify them."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z1p0fpbxQLyn"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Ps5OnkPmDbMX"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "np.set_printoptions(precision=3, suppress=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3lpweIqAWBX3"
      },
      "source": [
        "## Helpers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iIRC73HLq6VH"
      },
      "source": [
        "# A) Actor-critics\n",
        "\n",
        "You are going to implement an Actor-critic agent that updates a policy parametrised as a deep neural network.\n",
        "\n",
        "The agent learns online from a single stream of experience, updating the parametes of its policy after each transition in the environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KV03Q3MpveUM"
      },
      "source": [
        "### Install packages"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "wc-kqp3tveUT"
      },
      "outputs": [],
      "source": [
        "### Already installed using the requirements.txt\n",
        "# !pip install -U jaxlib==0.4.23 -q\n",
        "# !git clone https://github.com/deepmind/bsuite.git\n",
        "# !pip install bsuite/ -q"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_pTfi5dSFX5"
      },
      "source": [
        "### Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "huyKrYpvSHSu"
      },
      "outputs": [],
      "source": [
        "from bsuite.environments import catch\n",
        "\n",
        "import jax\n",
        "import jax.numpy as jnp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M6kEki4XHbPy"
      },
      "source": [
        "### Plotting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "EYdWwRrbHbcl"
      },
      "outputs": [],
      "source": [
        "def plot_learning_curve(list_of_episode_returns):\n",
        "  \"\"\"Plot the learning curve.\"\"\"\n",
        "  plt.figure(figsize=(7, 5))\n",
        "\n",
        "  def moving_average(x, w):\n",
        "    return np.convolve(x, np.ones(w), 'valid') / w\n",
        "\n",
        "  smoothed_returns = moving_average(list_of_episode_returns, 30)\n",
        "  plt.plot(smoothed_returns)\n",
        "\n",
        "  plt.xlabel('Average episode returns')\n",
        "  plt.xlabel('Number of episodes')\n",
        "\n",
        "  ax = plt.gca()\n",
        "  ax.spines['left'].set_visible(True)\n",
        "  ax.spines['bottom'].set_visible(True)\n",
        "  ax.spines['right'].set_visible(False)\n",
        "  ax.spines['top'].set_visible(False)\n",
        "  ax.xaxis.set_ticks_position('bottom')\n",
        "  ax.yaxis.set_ticks_position('left')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xtlrr5d2p7cS"
      },
      "source": [
        "### Neural networks\n",
        "\n",
        "You will use JAX to define a network parametrising:\n",
        "\n",
        "* The values of each state $v(s)$.\n",
        "* The action preferences in each state $\\{p_i(s)\\}_{i\\in\\{1, ..., |A|\\}}$ (you can think of and implement the preferences $\\mathbf{p}(s)$ as a vector output with $|A|$ elements).\n",
        "\n",
        "There are many neural network libraries available that can be used to create networks in jax.  But here we will keep things relatively simple and just define our own network.\n",
        "\n",
        "Specifically, we will define a `network` function returns a **scalar** value `v` and a **vector** of preferences `p`, which will define the policy of the agent.  This function will take as its inputs a dictionary `params` of parameters that we will update, which will contain all the parameters of the network.\n",
        "\n",
        "A lot of the boilerplate code has been written for you.  You will have to implement some functions as indicated in the questions below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gj1nsUYuOoe1"
      },
      "source": [
        "### Q1 [4 marks]\n",
        "\n",
        "Create the parameters and define the forward pass of the neural network. The `network` function must look as follows when we call it:\n",
        "`v, p = network(params, observation)`\n",
        "\n",
        "The network should be implemented as follows:\n",
        "* The inputs are a dictionary of parameters `params`, and a tensor (a `jnp.array`) called `observation`.\n",
        "* We reshape the observation into a flat vector `flat_observation`.\n",
        "* We compute a hidden representation\n",
        "`h = relu(flat_observation.dot(w) + b)`, where the weights and biases are given in the input dictionary as `w = params['w']` and `v = params['b']` (and analogously for all other parameters), and where `relu(x)` is a 'rectifier linear unit', which computes $\\max(x, 0)$ elementwise (you can use `jax.nn.relu(x)` to implement this, if you want).\n",
        "* We compute a vector of action preferences as a linear function of `h`, such that `p = h.dot(w_p) + b_p`.\n",
        "* Similarly, we compute a scalar state value `v` as a linear function of `h`.\n",
        "* Finally, we return the scalar value and vector preferences as a tuple.\n",
        "\n",
        "Further, make sure that:\n",
        "* The hidden representation should be a vector of 50 elements.\n",
        "* The action preferences should be a vector of 3 elements (one per each available action).\n",
        "* The value should be a scalar (not a vector with one element).\n",
        "* All parameters should be initialised randomly as follows:\n",
        "```\n",
        "rng_key, param_key = jax.random.split(rng_key)\n",
        "parameter = jax.random.truncated_normal(param_key, -1, 1, shape)\n",
        "```\n",
        "where `shape` is the relevant shape for this `parameter` (e.g., `parameter` is `w` or `b`, etc.).  The first line is important: it 'splits' the random key into a temporary random key `param_key` that should **only** be used for this parameter, and a new `rng_key` that can be split again later for the next parameters, etc.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "dF-6IWP30nip"
      },
      "outputs": [],
      "source": [
        "def create_parameters(rng_key, observation):\n",
        "    # Returns a dictionary with the desired parameters for the network\n",
        "    params = {}\n",
        "    rng_key, param_key = jax.random.split(rng_key)\n",
        "    params['w'] = jax.random.truncated_normal(\n",
        "        param_key, -1, 1, (jnp.size(observation), 50)\n",
        "    )\n",
        "    rng_key, param_key = jax.random.split(rng_key)\n",
        "    params['b'] = jax.random.truncated_normal(\n",
        "            param_key, -1, 1, (50,)\n",
        "    )\n",
        "    rng_key, param_key = jax.random.split(rng_key)\n",
        "    params['w_p'] = jax.random.truncated_normal(\n",
        "            param_key, -1, 1, (50, 3)\n",
        "    )\n",
        "    rng_key, param_key = jax.random.split(rng_key)\n",
        "    params['b_p'] = jax.random.truncated_normal(\n",
        "            param_key, -1, 1, (3,)\n",
        "    )\n",
        "    rng_key, param_key = jax.random.split(rng_key)\n",
        "    params['w_v'] = jax.random.truncated_normal(\n",
        "            param_key, -1, 1, (50,)\n",
        "    )\n",
        "    return params"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "vRBP0xjtQvTi"
      },
      "outputs": [],
      "source": [
        "def network(params, observation):\n",
        "    # Implement forward pass here\n",
        "    h = jax.nn.relu(observation.flatten() @ params['w'] + params['b'])\n",
        "    p = h @ params['w_p'] + params['b_p']\n",
        "    v = h @ params['w_v']\n",
        "    return v, p"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ImJUgzFosvD"
      },
      "source": [
        "### Choosing actions\n",
        "\n",
        "A critical component of an actor-critic agent is a (stochastic) policy, mapping `observations` to `actions`.\n",
        "\n",
        "In deep RL, this mapping is conventionally parametrised by a deep neural network."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1MVXNWwlYW24"
      },
      "source": [
        "Here we provide a softmax policy parametrised by the neural network above (i.e., using the `network` function). The function has signature `action = softmax_policy(parameters, key, obs)`, taking the current network parameters `parameters`, a JAX random `key` and the current `observation`.\n",
        "\n",
        "### Softmax definition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "qSOO10b20yD5"
      },
      "outputs": [],
      "source": [
        "#DO NOT MODIFY\n",
        "# Functions to perform random sampling in JAX (e.g. those in `jax.random`) take\n",
        "# a random key as input, and they are deterministic function of such a key. In\n",
        "# general, in a JAX program you need to use the `jax.random.split` function to\n",
        "# generate new random keys before every new sampling. The run loop that runs the\n",
        "# experiment later on will split and provides the keys for the function defined\n",
        "# here.\n",
        "\n",
        "# Note that we 'jit' the function.  This means the function will be compiled,\n",
        "# which will make it run faster. This does also suppress print statements, so if\n",
        "# you are debugging and want to print please comment out the `@jax.jit` line,\n",
        "# but don't forget to put it back before running the experiment below, and\n",
        "# especially before submitting your assignment.\n",
        "\n",
        "@jax.jit\n",
        "def softmax_policy(parameters, key, obs):\n",
        "  \"\"\"Sample action from a softmax policy.\"\"\"\n",
        "  _, p = network(parameters, obs)\n",
        "  return jax.random.categorical(key, p)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iMYcb7Y9krnT"
      },
      "source": [
        "### Learning values and policies\n",
        "\n",
        "An actor-critic agent requires to update the parameters of the network so as to simultaneously improve the value predictions and the policy.\n",
        "\n",
        "In the next section you will define the gradient updates for each of these two components."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GsIlpmNEk5fv"
      },
      "source": [
        "### Q3 [4 marks]\n",
        "\n",
        "Implement a function to compute a stochastic estimate of the policy gradient from a 1 step transition in the environment.\n",
        "\n",
        "* You will use $R_{t+1} + \\gamma v(S_{t+1})$ as an estimate of $q_{\\pi}(S_t, A_t)$\n",
        "* You will use $v(S_{t})$ as a baseline to reduce the variance of the updates.\n",
        "\n",
        "In the code we actually use names `obs_tm1`, `a_tm1` (where `tm1` stands for '$t$ minus one') for the observation and action at time $t-1$, and `r_t`, `discount_t`, `obs_t` for the reward, discount, and observation at time $t$. So the code is offset a single time step in terms of naming as compared to the typical mathematical formulations.  This is just a naming convention, and should not impact the algorithm.\n",
        "\n",
        "The function below must therefore have signature `grads = policy_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)`.\n",
        "* Where the inputs are:\n",
        "  * `parameters`: the parameters of the network,\n",
        "  * an observation `obs_tm1`\n",
        "  * the action `a_tm1` selected after observing `obs_tm1`,\n",
        "  * the resulting reward `r_t` and discount `discount_t` and observation `obs_t`, as obsesrved after taking action `a_tm1`.\n",
        "\n",
        "This function should return a stochastic estimate of the policy gradient, where `grads` has the same structure as `parameters` and contains an estimate of the gradient of the expected episodic return wrt to each parameter.\n",
        "\n",
        "The policy-gradient estimate should use bootstrapping, using the value estimates that can be gotten using the saame `parameters` as used for the policy.  So the output of this function can be used in a one-step actor-critic update."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "02RJAKiX85Wx"
      },
      "source": [
        "### Jax hint:\n",
        "Note that you can use `jax.grad(f)` to get the gradient of any (pure) jax function with a scalar output.  For instance, consider:\n",
        "\n",
        "        def f(w, x, y):\n",
        "          # w, x, and y are all vectors\n",
        "          return jnp.sum(w*x + y)\n",
        "\n",
        "        df = jax.grad(f)\n",
        "    \n",
        "then calling `df(w, x, y)` will give the gradient of the output of `f(w, x, y)` with respect to the first input argument --- here called `w`. You can use this new function `df` as just a normal function. For instance, it can be called from other functions, as usual.\n",
        "\n",
        "Run the cell below to see a concrete example in action.  Note that `df(w, x, y)` in the example below evaluates to the same values as `x`.  This is correct, because the gradient of `f` with respect to `w` is indeed `x`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "t1TjveqqGnNA"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "f(w, x, y):  31.0\n",
            "df(w, x, y): [3. 5.]\n"
          ]
        }
      ],
      "source": [
        "def f(w, x, y):\n",
        "  return jnp.sum(w*x + y)\n",
        "\n",
        "df = jax.grad(f)\n",
        "\n",
        "w = jnp.array([1., 2.])\n",
        "x = jnp.array([3., 5.])\n",
        "y = jnp.array([7., 11.])\n",
        "\n",
        "print(f'f(w, x, y):  {f(w, x, y)}')\n",
        "print(f'df(w, x, y): {df(w, x, y)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wngNEiwrQeF0"
      },
      "source": [
        "### Jax hint:\n",
        "You network will have a dictionary `params` as input.  Suppose you have a function that computes the output of a network, and then uses this to do some stuff, and you want the gradient of that new function.  That is, suppose your code looks something like this:\n",
        "\n",
        "        # Define network\n",
        "        def network(params, ...):\n",
        "          ...\n",
        "\n",
        "        # Define a new function\n",
        "        def function(params, x, y, z, ...):\n",
        "           ...\n",
        "           output = network(params, x)\n",
        "           ...\n",
        "           return ...(some function of output)...        \n",
        "\n",
        "Now,\n",
        "```\n",
        "grads = jax.grad(function)(params, x, y, z, ...)\n",
        "```\n",
        "will give the gradients of `function` with respect to the first input argument, `params`.  These gradients `grads` will have exactly the same shape as the input argment `params`.\n",
        "\n",
        "But note that we cannot do things like `params + grads`, because `params` and `grads` are both dictionaries, not just `jnp.array`s.  Instead, we could explicitly traverse the dictionary.  But it is perhaps even easier to use in-built tree utils in Jax.  Specifically, the util `jax.tree_map(f, x, y)` applies function f to all the elements in `x` and `y`.\n",
        "\n",
        "For instance, to add the gradients to the parameters, we can use:\n",
        "```\n",
        "def add_gradient_to_weight(w, g, learning_rate=0.1):\n",
        "  return w + learning_rate * g\n",
        "new_params = jax.tree_map(add_gradient_to_weight, params, grads)\n",
        "```\n",
        "The above snippet would apply the function `add_gradient_to_weight` to the elements in `params` and `grads`, here adding each element in `grads` to each corresponding element in `weights` (in this case using the default learning rate `learning_rate=0.1`, as specified in the function definition).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "AHLGjy8he6vh"
      },
      "outputs": [],
      "source": [
        "def policy_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t):\n",
        "\n",
        "    def log_policy(parameters, obs, a):\n",
        "        _, p = network(parameters, obs)\n",
        "        return jax.nn.log_softmax(p)[a]\n",
        "\n",
        "    v_tm1, _ = network(parameters, obs_tm1)\n",
        "    v_t, _ = network(parameters, obs_t)\n",
        "    td_error = r_t + discount_t * v_t - v_tm1\n",
        "    policy_grad = jax.grad(log_policy)(parameters, obs_tm1, a_tm1)\n",
        "    return jax.tree_map(lambda x: x * td_error, policy_grad)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5XgjefrBlIGN"
      },
      "source": [
        "### Q4 [4 marks]\n",
        "\n",
        "Implement a function to compute a TD(0) update for the parameters of the value function.\n",
        "\n",
        "It must have signature `td_update = value_update(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)`.\n",
        "* Where the inputs are:\n",
        "  * the current parameters `parameters` of the network,\n",
        "  * an observation `obs_tm1`\n",
        "  * the action `a_tm1` selected after observing `obs_tm1`,\n",
        "  * the resulting reward `r_t` and environment discount `discount_t`\n",
        "  * and the following observation `obs_t`\n",
        "* Returns a stochastic TD(0) semi-gradient update: `td_update` has the same structure as `parameters`. This contains a stochastic estimate of the negative semi-gradient of the expected value prediction loss: a TD(0) update."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "CAONu72iTpzx"
      },
      "outputs": [],
      "source": [
        "def value_update(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t):\n",
        "\n",
        "    def value(parameters, obs):\n",
        "        v, _ = network(parameters, obs)\n",
        "        return v\n",
        "\n",
        "    v_tm1, _ = network(parameters, obs_tm1)\n",
        "    v_t, _ = network(parameters, obs_t)\n",
        "    td_error = r_t + discount_t * v_t - v_tm1\n",
        "    value_grad = jax.grad(value)(parameters, obs_tm1)\n",
        "    return jax.tree_map(lambda x: x * td_error, value_grad)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAXgLZg8mfMd"
      },
      "source": [
        "### Updating shared parameters\n",
        "\n",
        "The policy gradient identifies the direction of change in the parameters that most steeply improve the policy.\n",
        "The value update identifies the direction of change in the parameters that improves the value predictions (according to TD).\n",
        "\n",
        "However, the value and policy share some of the parameters of the network.  How do we combine the two gradient updates?\n",
        "\n",
        "In this assignment, we simply sum the policy and value components.\n",
        "The function that combines the two gradients is implemented for you in the cell below.  Note the use of `jax.tree_map` to facilitate adding the structured parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "uhKCLe8jjkdZ"
      },
      "outputs": [],
      "source": [
        "@jax.jit\n",
        "def compute_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t):\n",
        "  pgrads = policy_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)\n",
        "  td_update = value_update(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)\n",
        "  return jax.tree_map(lambda pg, td: pg + td, pgrads, td_update)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tYaVb6GcpCRe"
      },
      "source": [
        "### Optimisation\n",
        "\n",
        "In deep learning, gradient updates are typically rescaled and modifed to avoid taking too large a step on a single update (e.g., due to large variance), and to facilitate the optimisation process (it turns out raw stochatic gradients are often not the most effective for updating neural networks).\n",
        "\n",
        "For instance given a candidate gradient update $\\nabla$ we may update our parameters $\\theta$ by;\n",
        "$$\\Delta \\theta = \\theta + \\alpha * \\nabla\\,,$$\n",
        "where $\\alpha$ is a small number between 0 and 1 (e.g., $\\alpha=0.01$ or $\\alpha=0.001$), referred to as `step_size` or `learning_rate`\n",
        "\n",
        "The gradients with respect to each weight of a neural network may however have very different magnitudes. This can make it hard to set a suitable learning rate $\\alpha$.\n",
        "\n",
        "In deep learning, and deep RL, we typically use adaptive learning rates, for instance by rescaling each component of the gradient using statistics tracking the typical size of the updates to that weight. Then the entire update is rescaled using a global `learning_rate` $\\alpha$.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbFePWfApaMU"
      },
      "source": [
        "### Q5 [2 marks]\n",
        "\n",
        "A popular approach to adaptive gradient rescaling was introduced by the `Adam` algorithm.\n",
        "This algorithm implements the following procedure before applying each update:\n",
        "* Increase an update counter $k \\gets k+1$ (starting at k=0 before any updates),\n",
        "* Update the first moment of each gradient component $\\mu \\gets (1 - \\beta_1) g + \\beta_1 \\mu$ where $g$ is the latest stochastic gradient, where $\\beta_1$ is a parameter for the moving average.\n",
        "* Update the second moment of each gradient component $\\nu_i = (1 - \\beta_2) g_i ^ 2 + \\beta_2 \\nu_i $ where $g$ is the latest gradient update, where $\\beta_2$ is a parameter for the moving average.\n",
        "* Use the following update to update the weights:\n",
        "$$\\Delta w = \\alpha \\frac{\\mu / (1 - \\beta_1 ^ {k})}{\\epsilon + \\sqrt{\\nu / (1 - \\beta_2 ^ {k})}}$$\n",
        "* $\\alpha$ is a global `learning rate`\n",
        "* $\\beta_1$ and $\\beta_2$ define a soft horizon for the per-weight statistics.\n",
        "* $\\epsilon$ makes the rescaling more robust to numerical issues.\n",
        "\n",
        "(See [Kingma et al, 2014](https://arxiv.org/abs/1412.6980) for details, if you are interested.)\n",
        "\n",
        "In the next cell define a pair of functions (`opt_init`, and `opt_update` --- in each case `opt` is short for 'optimiser'), where:\n",
        "\n",
        "The `opt_init` function has signature `opt_state = opt_init(parameters)`.\n",
        "* Takes the network parameters as inputs\n",
        "* Initialises an `optimiser state` holding the per weight statistics.\n",
        "\n",
        "The `opt_update` function has signature `updates, opt_state = opt_update(grads, opt_state)`.\n",
        "* Takes a `gradient` and an `optimisers state`,\n",
        "* and returns the transformed gradient and the updated `optimiser state`.\n",
        "\n",
        "The optimiser state `opt_state` should contain:\n",
        "* The first-order momentum $\\mu$, as updated with a moving-average-parameter $\\beta_1$ which we call `b1` in the code.\n",
        "* The first-order momentum $\\nu$, as updated with a moving-average-parameter $\\beta_2$ which we call `b2` in the code.\n",
        "\n",
        "We will ignore the initial correction Adam typically uses, and will instead use the simpler transformation:\n",
        "$$\\Delta w = \\alpha \\frac{\\mu}{\\epsilon + \\sqrt{\\nu}}$$\n",
        "\n",
        "Set the algorithm's hyper-parameters to $\\alpha=0.003$, $\\beta_1=.9$ and $\\beta_2=.999$, $\\epsilon=10^{-4}$.  You are allowed to hard-code these in, or make them configurable (e.g., pass them as additional arguments to `opt_update`, which is better if you want to play around, of course).  Set the initial moving averages to zero for $\\mu$ and one for $\\nu$.  E.g.,\n",
        "\n",
        "    mu = jax.tree_map(jnp.zeros_like, parameters)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "017XRA_BpbZx"
      },
      "outputs": [],
      "source": [
        "def opt_init(parameters):\n",
        "    k = 0\n",
        "    mu = jax.tree_map(jnp.zeros_like, parameters)\n",
        "    nu = jax.tree_map(jnp.zeros_like, parameters)\n",
        "    opt_state = (k, mu, nu)\n",
        "    return opt_state\n",
        "\n",
        "def opt_update(grads, opt_state, alpha=3e-3, b1=0.9, b2=0.999, eps=1e-4):\n",
        "    k, mu, nu = opt_state\n",
        "    k += 1\n",
        "    mu = jax.tree_map(lambda m, g: b1 * m + (1 - b1) * g, mu, grads)\n",
        "    nu = jax.tree_map(lambda n, g: b2 * n + (1 - b2) * g ** 2, nu, grads)\n",
        "    mu_hat = jax.tree_map(lambda m: m / (1 - b1 ** k), mu)\n",
        "    nu_hat = jax.tree_map(lambda n: n / (1 - b2 ** k), nu)\n",
        "    updates = jax.tree_map(lambda m, n: alpha * m / (eps + jnp.sqrt(n)), mu_hat, nu_hat)\n",
        "    opt_state = (k, mu, nu)\n",
        "    return updates, opt_state"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DczWvZfNSnTj"
      },
      "source": [
        "### Run experiments\n",
        "\n",
        "Run the cell below to show the performance of the resulting agent.\n",
        "\n",
        "You may also use this section for debugging your implementations.\n",
        "\n",
        "Note however, that most functions are `jitted` for performance,\n",
        "* either using the `@jax.jit` decorator in the function definition\n",
        "* or calling explicitly `fn = jax.jit(fn)`\n",
        "\n",
        "When jitting, the code is compiled on the first time the function is executed\n",
        "* and execution is much faster on subsequent calls.\n",
        "* a notable side effect is that print statements in a jitted function will only execute on the first execution of the function.\n",
        "* to drop into a debugger or print on each function execution you will have to disable the `@jax.jit` annotations and jax.jit calls."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "Fz837XTkLxE8"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:3: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  mu = jax.tree_map(jnp.zeros_like, parameters)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:4: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  nu = jax.tree_map(jnp.zeros_like, parameters)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/3568513996.py:11: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda x: x * td_error, policy_grad)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/2734106140.py:5: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda pg, td: pg + td, pgrads, td_update)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:11: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  mu = jax.tree_map(lambda m, g: b1 * m + (1 - b1) * g, mu, grads)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:12: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  nu = jax.tree_map(lambda n, g: b2 * n + (1 - b2) * g ** 2, nu, grads)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:13: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  mu_hat = jax.tree_map(lambda m: m / (1 - b1 ** k), mu)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:14: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  nu_hat = jax.tree_map(lambda n: n / (1 - b2 ** k), nu)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:15: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  updates = jax.tree_map(lambda m, n: alpha * m / (eps + jnp.sqrt(n)), mu_hat, nu_hat)\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training agent for 2500 episodes...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/3413641202.py:21: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda p, u: p + u, params, updates)\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# DO NOT CHANGE THIS CELL\n",
        "\n",
        "# Experiment configs.\n",
        "train_episodes = 2500\n",
        "discount_factor = .99\n",
        "\n",
        "# Create environment.\n",
        "env = catch.Catch(seed=42)\n",
        "\n",
        "# Build and initialize network.\n",
        "rng = jax.random.PRNGKey(44)\n",
        "rng, init_rng = jax.random.split(rng)\n",
        "sample_input = env.observation_spec().generate_value()\n",
        "parameters = create_parameters(init_rng, sample_input)\n",
        "\n",
        "# Initialize optimizer state.\n",
        "opt_state = opt_init(parameters)\n",
        "\n",
        "# Apply updates\n",
        "def apply_updates(params, updates):\n",
        "  return jax.tree_map(lambda p, u: p + u, params, updates)\n",
        "\n",
        "# Jit.\n",
        "opt_update = jax.jit(opt_update)\n",
        "apply_updates = jax.jit(apply_updates)\n",
        "\n",
        "print(f\"Training agent for {train_episodes} episodes...\")\n",
        "all_episode_returns = []\n",
        "\n",
        "for _ in range(train_episodes):\n",
        "  episode_return = 0.\n",
        "  timestep = env.reset()\n",
        "  obs_tm1 = timestep.observation\n",
        "\n",
        "  # Sample initial action.\n",
        "  rng, policy_rng = jax.random.split(rng)\n",
        "  a_tm1 = softmax_policy(parameters, policy_rng, obs_tm1)\n",
        "\n",
        "  while not timestep.last():\n",
        "    # Step environment.\n",
        "    new_timestep = env.step(int(a_tm1))\n",
        "\n",
        "    # Sample action from agent policy.\n",
        "    rng, policy_rng = jax.random.split(rng)\n",
        "    a_t = softmax_policy(parameters, policy_rng, new_timestep.observation)\n",
        "\n",
        "    # Update params.\n",
        "    r_t = new_timestep.reward\n",
        "    discount_t = discount_factor * new_timestep.discount\n",
        "    dJ_dtheta = compute_gradient(\n",
        "        parameters, obs_tm1, a_tm1, r_t, discount_t,\n",
        "        new_timestep.observation)\n",
        "    updates, opt_state = opt_update(dJ_dtheta, opt_state)\n",
        "    parameters = apply_updates(parameters, updates)\n",
        "\n",
        "    # Within episode book-keeping.\n",
        "    episode_return += new_timestep.reward\n",
        "    timestep = new_timestep\n",
        "    obs_tm1 = new_timestep.observation\n",
        "    a_tm1 = a_t\n",
        "\n",
        "  # Experiment results tracking.\n",
        "  all_episode_returns.append(episode_return)\n",
        "\n",
        "# Plot learning curve.\n",
        "plot_learning_curve(all_episode_returns)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9dowFJ_l-32A"
      },
      "source": [
        "# B) An alternative update\n",
        "\n",
        "You are going to implement a different kind of agent.\n",
        "\n",
        "Like an actor-critic, it learns online from a single stream of experience, updating the parametes after each transition in the environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aQD0Qw8-_QJy"
      },
      "source": [
        "### Neural networks\n",
        "\n",
        "\n",
        "The agent will reuse the same neural network we defined for the actor-critic:\n",
        "* the scalar output will be trained via TD to estimate state values\n",
        "* the vector preferences `p` will be updated according to a different rule."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6j0AIF8GhdR"
      },
      "source": [
        "### Choosing actions\n",
        "\n",
        "As in actor-critics, the (stochastic) mapping from `observations` to `actions` depends on the vector of preferences `p` from the network."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jE00LhDL_nbC"
      },
      "source": [
        "### Q6 [2 marks]\n",
        "\n",
        "The new agent's policy will have the signature `action = epsilon_greedy_policy(parameters, key, observation)`,\n",
        "* Take as inputs the current network parameters `parameters`, a JAX random `key` and the current `observation`\n",
        "* Return with probability `0.9` the greedy `action` with respect to the preferences `p`, ties must be broken at random.\n",
        "* Return an action uniformly at random with probability `0.1`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "8IwTDROL_Lx5"
      },
      "outputs": [],
      "source": [
        "@jax.jit\n",
        "def epsilon_greedy_policy(parameters, key, observation, epsilon=0.1):\n",
        "    \"\"\"Sample action from an epsilon-greedy policy.\"\"\"\n",
        "    policy_rng, eps_rng = jax.random.split(key)\n",
        "    _, p = network(parameters, observation)\n",
        "\n",
        "    preferences = jnp.where(jax.random.uniform(eps_rng) < epsilon,\n",
        "                            jnp.ones(3),      # Random preferences\n",
        "                            p == jnp.max(p))  # Greedy preferences\n",
        "\n",
        "    probs = preferences / jnp.sum(preferences)\n",
        "    actions = jnp.arange(3)\n",
        "\n",
        "    return jax.random.choice(policy_rng, actions, p=probs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l1zQiRX5BfeA"
      },
      "source": [
        "### Q7 [3 marks]\n",
        "\n",
        "The parameters $w_p$ of the preferences $p_{w_p}(s, a)$ will be update according to the following gradient-based update:\n",
        "\n",
        "$$\\Delta w_p = \\alpha (R_{t+1} + \\gamma v(S_{t+1}) - p(S_{t}, A_t)) \\nabla p(S_t, A_t))$$\n",
        "\n",
        "where `v` is the state value trained by TD as in the actor critic.\n",
        "\n",
        "You musy implement this in the function `preference_gradient`, with the same signature as `policy_gradient`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "6fQhAWXqLNt-"
      },
      "outputs": [],
      "source": [
        "def preference_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t):\n",
        "\n",
        "    def preference(parameters, obs, a):\n",
        "        _, p = network(parameters, obs)\n",
        "        return p[a]\n",
        "\n",
        "    v_t, _ = network(parameters, obs_t)\n",
        "    td_error = r_t + discount_t * v_t - preference(parameters, obs_tm1, a_tm1)\n",
        "    p_grad = jax.grad(preference)(parameters, obs_tm1, a_tm1)\n",
        "    return jax.tree_map(lambda x: x * td_error, p_grad)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hz4RFKnVF8E8"
      },
      "source": [
        "### Updating shared parameters\n",
        "\n",
        "Just like in the actor critic the overall update to the parameters is a combination of two quantities:\n",
        "* the new update we defined for the vector of preferences\n",
        "* the same TD update to the scalar output that we used in the actor critic"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "QnghCzKhF-gI"
      },
      "outputs": [],
      "source": [
        "@jax.jit\n",
        "def compute_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t):\n",
        "  pgrads = preference_gradient(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)\n",
        "  vgrads = value_update(parameters, obs_tm1, a_tm1, r_t, discount_t, obs_t)\n",
        "  return jax.tree_map(lambda pg, td: pg + td, pgrads, vgrads)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "44QBKEF4HFK8"
      },
      "source": [
        "### Optimisation\n",
        "\n",
        "The gradient updates are rescaled using the same optimiser used for the actor-critic."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dbdHQo23FJit"
      },
      "source": [
        "### Run experiments\n",
        "\n",
        "Run the cell below to show the performance of the new agent."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "ept5NG1oFLnu"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:3: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  mu = jax.tree_map(jnp.zeros_like, parameters)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/646829693.py:4: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  nu = jax.tree_map(jnp.zeros_like, parameters)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/53484793.py:10: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda x: x * td_error, p_grad)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/3457865811.py:11: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda x: x * td_error, value_grad)\n",
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/2854361996.py:5: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda pg, td: pg + td, pgrads, vgrads)\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training agent for 2500 episodes...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/q2/8wf0yv5n1v10zmfqwf0b2zxm0000gn/T/ipykernel_66523/1434496577.py:21: DeprecationWarning: jax.tree_map is deprecated: use jax.tree.map (jax v0.4.25 or newer) or jax.tree_util.tree_map (any JAX version).\n",
            "  return jax.tree_map(lambda p, u: p + u, params, updates)\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# DO NOT CHANGE THIS CELL\n",
        "\n",
        "# Experiment configs.\n",
        "train_episodes = 2500\n",
        "discount_factor = .99\n",
        "\n",
        "# Create environment.\n",
        "env = catch.Catch(seed=42)\n",
        "\n",
        "# Build and initialize network.\n",
        "rng = jax.random.PRNGKey(44)\n",
        "rng, init_rng = jax.random.split(rng)\n",
        "sample_input = env.observation_spec().generate_value()\n",
        "parameters = create_parameters(init_rng, sample_input)\n",
        "\n",
        "# Initialize optimizer state.\n",
        "opt_state = opt_init(parameters)\n",
        "\n",
        "# Apply updates\n",
        "def apply_updates(params, updates):\n",
        "  return jax.tree_map(lambda p, u: p + u, params, updates)\n",
        "\n",
        "# Jit.\n",
        "opt_update = jax.jit(opt_update)\n",
        "apply_updates = jax.jit(apply_updates)\n",
        "\n",
        "print(f\"Training agent for {train_episodes} episodes...\")\n",
        "all_episode_returns = []\n",
        "\n",
        "for _ in range(train_episodes):\n",
        "  episode_return = 0.\n",
        "  timestep = env.reset()\n",
        "  obs_tm1 = timestep.observation\n",
        "\n",
        "  # Sample initial action.\n",
        "  rng, policy_rng = jax.random.split(rng)\n",
        "  a_tm1 = epsilon_greedy_policy(parameters, policy_rng, obs_tm1)\n",
        "\n",
        "  while not timestep.last():\n",
        "    # Step environment.\n",
        "    new_timestep = env.step(int(a_tm1))\n",
        "\n",
        "    # Sample action from agent policy.\n",
        "    rng, policy_rng = jax.random.split(rng)\n",
        "    a_t = epsilon_greedy_policy(parameters, policy_rng, new_timestep.observation)\n",
        "\n",
        "    # Update params.\n",
        "    r_t = new_timestep.reward\n",
        "    discount_t = discount_factor * new_timestep.discount\n",
        "\n",
        "    dJ_dtheta = compute_gradient(\n",
        "        parameters, obs_tm1, a_tm1, r_t, discount_t,\n",
        "        new_timestep.observation)\n",
        "    updates, opt_state = opt_update(dJ_dtheta, opt_state)\n",
        "    parameters = apply_updates(parameters, updates)\n",
        "\n",
        "    # Within episode book-keeping.\n",
        "    episode_return += new_timestep.reward\n",
        "    timestep = new_timestep\n",
        "    obs_tm1 = new_timestep.observation\n",
        "    a_tm1 = a_t\n",
        "\n",
        "  # Experiment results tracking.\n",
        "  all_episode_returns.append(episode_return)\n",
        "\n",
        "# Plot learning curve.\n",
        "plot_learning_curve(all_episode_returns)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g80tBzfsBgya"
      },
      "source": [
        "### Q8 [6 marks]\n",
        "\n",
        "[2pts]: What is the best asymptotic average return that can be achieved by the actor-critic agent described in `Part 2A)`? Can this be further improved, and if so: how? Explain your answer.\n",
        "\n",
        "> The best asymptotic average return is 1. As $t \\rightarrow \\infty$, the agent would prefer taking the action with optimal value, i.e. the probability of taking non-optimal actions would vanish. Eventually, the agent always take action that have a reward of 1.\n",
        ">\n",
        "> It cannot be further improved as it is the highest achievable average return since the highest reward for each step is 1.\n",
        "\n",
        "[2pts] What is the best asymptotic average return that can be achieved by the second agent described in `Part 2B)`? Can this be further improved, and if so: how? Explain your answer.\n",
        "\n",
        "> The second agent always randomly sample an action for 10% of the time as it adopts the $\\epsilon$-greedy policy. For 90% of the time it would take the optimal value action. For the remaining 10%, 2 out of 3 actions would give 0 reward and 1 action is the optimal value action with reward 1. Hence, the best asymptotic average return is given by\n",
        "> $$ 0.9 (1) + 0.1 [(1/3)(1) + (2/3)(0)] = 0.9333 $$\n",
        ">\n",
        "> To improve the average return, the exploration rate should decrease over time, for example setting $\\epsilon = 1/t$ where $t$ is the number of steps. Thus, the algorithm would turn into a greedy policy eventually.\n",
        "\n",
        "\n",
        "[2pts] What quantity do the preferences `p` estimate in the second agent described in Part B?\n",
        "\n",
        "> For the second agent, the preferences $p(S, A)$ is indeed an estimate of the state-action value $Q(S, A)$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0BJrDzXJxTl7"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "UCL RL CW 2024, part III",
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}