Project_Mohinga(2).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "9Hal1ZMSs8Tq"
      },
      "source": [
        "# Using RL to Model Cognitive Tasks\n",
        "\n",
        "**By Neurmatch Academy**\n",
        "\n",
        "__Content creators:__ Morteza Ansarinia, Yamil Vidal\n",
        "\n",
        "__Production editor:__ Spiros Chavlis\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "10cSGTbGs8Tw"
      },
      "source": [
        "<p align='center'><img src='https://github.com/NeuromatchAcademy/widgets/blob/master/sponsors.png?raw=True'/></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "zHRGJ1UVs8Tx"
      },
      "source": [
        "---\n",
        "# Objective\n",
        "\n",
        "- This project aims to use behavioral data to train an agent and then use the agent to investigate data produced by human subjects. Having a computational agent that mimics humans in such tests, we will be able to compare its mechanics with human data.\n",
        "\n",
        "- In another conception, we could fit an agent that learns many cognitive tasks that require abstract-level constructs such as executive functions. This is a multi-task control problem.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "AyAKhaHYs8Tz"
      },
      "source": [
        "---\n",
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "NFAKtF0ls8T4",
        "outputId": "27be7119-76b6-4eec-86d7-02f0b0225f63",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[33mWARNING: dm-acme 0.4.0 does not provide the extra 'tensorflow'\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "# @title Install dependencies\n",
        "# !pip install --upgrade pip setuptools wheel --quiet\n",
        "!pip install dm-acme[jax,tensorflow] --quiet\n",
        "!pip install dm-acme[envs] --quiet\n",
        "!pip install dm-sonnet --quiet\n",
        "!pip install trfl --quiet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "execution": {},
        "id": "4-yCX1uRs8T5"
      },
      "outputs": [],
      "source": [
        "# Imports\n",
        "\n",
        "import time\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import sonnet as snt\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import dm_env\n",
        "\n",
        "import acme\n",
        "from acme import specs\n",
        "from acme import wrappers\n",
        "from acme import EnvironmentLoop\n",
        "from acme.agents.tf import dqn\n",
        "from acme.utils import loggers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "cellView": "form",
        "execution": {},
        "id": "IWegMEq6s8T7"
      },
      "outputs": [],
      "source": [
        "# @title Figure settings\n",
        "from IPython.display import clear_output, display, HTML\n",
        "%matplotlib inline\n",
        "sns.set()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "uhplmwR_s8T9"
      },
      "source": [
        "---\n",
        "# Background\n",
        "\n",
        "- Cognitive scientists use standard lab tests to tap into specific processes in the brain and behavior. Some examples of those tests are Stroop, N-back, Digit Span, TMT (Trail making tests), and WCST (Wisconsin Card Sorting Tests).\n",
        "\n",
        "- Despite an extensive body of research that explains human performance using descriptive what-models, we still need a more sophisticated approach to gain a better understanding of the underlying processes (i.e., a how-model).\n",
        "\n",
        "- Interestingly, many of such tests can be thought of as a continuous stream of stimuli and corresponding actions, that is in consonant with the RL formulation. In fact, RL itself is in part motivated by how the brain enables goal-directed behaviors using reward systems, making it a good choice to explain human performance.\n",
        "\n",
        "- One behavioral test example would be the N-back task.\n",
        "\n",
        "  - In the N-back, participants view a sequence of stimuli, one by one, and are asked to categorize each stimulus as being either match or non-match. Stimuli are usually numbers, and feedback is given at both timestep and trajectory levels.\n",
        "\n",
        "  - The agent is rewarded when its response matches the stimulus that was shown N steps back in the episode. A simpler version of the N-back uses two-choice action schema, that is match vs non-match. Once the present stimulus matches the one presented N step back, then the agent is expected to respond to it as being a `match`.\n",
        "\n",
        "\n",
        "- Given a trained RL agent, we then find correlates of its fitted parameters with the brain mechanisms. The most straightforward composition could be the correlation of model parameters with the brain activities."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "6dHJz-Bus8T-"
      },
      "source": [
        "## Datasets\n",
        "\n",
        "- HCP WM task ([NMA-CN HCP notebooks](https://github.com/NeuromatchAcademy/course-content/tree/master/projects/fMRI))\n",
        "\n",
        "Any dataset that used cognitive tests would work.\n",
        "Question: limit to behavioral data vs fMRI?\n",
        "Question: Which stimuli and actions to use?\n",
        "classic tests can be modeled using 1) bounded symbolic stimuli/actions (e.g., A, B, C), but more sophisticated one would require texts or images (e.g., face vs neutral images in social stroop dataset)\n",
        "The HCP dataset from NMA-CN contains behavioral and imaging data for 7 cognitive tests including various versions of N-back."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "ofnFkglVs8UB"
      },
      "source": [
        "## N-back task\n",
        "\n",
        "In the N-back task, participants view a sequence of stimuli, one per time, and are asked to categorize each stimulus as being either match or non-match. Stimuli are usually numbers, and feedbacks are given at both timestep and trajectory levels.\n",
        "\n",
        "In a typical neuro setup, both accuracy and response time are measured, but here, for the sake of brevity, we focus only on accuracy of responses."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "U8OvGFSys8UE"
      },
      "source": [
        "---\n",
        "# Cognitive Tests Environment\n",
        "\n",
        "First we develop an environment in that agents perform a cognitive test, here the N-back."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "bTtJSNmHs8UF"
      },
      "source": [
        "## Human dataset\n",
        "\n",
        "We need a dataset of human perfoming a N-back test, with the following features:\n",
        "\n",
        "- `participant_id`: following the BIDS format, it contains a unique identifier for each participant.\n",
        "- `trial_index`: same as `time_step`.\n",
        "- `stimulus`: same as `observation`.\n",
        "- `response`: same as `action`, recorded response by the human subject.\n",
        "- `expected_response`: correct response.\n",
        "- `is_correct`: same as `reward`, whether the human subject responded correctly.\n",
        "- `response_time`: won't be used here.\n",
        "\n",
        "Here we generate a mock dataset with those features, but remember to **replace this with real human data.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "execution": {},
        "id": "n96txMZFs8UW",
        "outputId": "295a3459-08fb-40bf-ca00-87b532c6e24d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFtCAYAAADLbydyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deVhUZf8/8DfDpj6iCA6IS5rU4CQuAyiWogmaZCL2Lb4hgZWaj2nGo6GgJiimhJgJqaVfLXMpW1xQyyU1K0xNUlQEXBABBUVAVFzY5v794Y95HFlkOTjD8H5dl9flnHPucz73zJl5z7nP4YyREEKAiIhIQjJdF0BERIaH4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4SMzBwQGxsbG6LkNjy5YteO6556p8LKXLly/DwcEB8fHxlT6W2tGjR+Hg4ICrV682yPprq7CwEJMnT4azszMcHBxw+fLlGrcNCQnB22+/3XDF6cDnn3+OoUOHPtFtPqnnUar3eUBAAGbPni1BRfqH4VJHb7/9NkJCQipMj4uLg6enpw4qqpnhw4fjjz/+qPHyVfWzMnZ2doiLi0OvXr3qWl6VnnvuOWzZskVrmkqlQlxcHGxsbCTfXl18++23SEhIwLfffou4uDjY2dlVWCY+Pr7WwdOUbNmyBQ4ODvDx8akwb+jQofj88891UJX+uHr1KhwcHHD06NEnvu3a7ru1Dpfi4uJaF9WUyOVymJub67qMKjVr1gxt27aVfL3FxcUwNjaGXC6Hqamp5OuvjJmZGeRyOWQy/fiOlJ6ejmeeeQYODg6Qy+UwNjbWdUmNkpGREVJSUvDzzz/ruhSqh8e+KwMCAjBr1iwsXboUAwYMwODBgwE8eCNNmTIFLi4u6NOnD8aOHYuzZ89q2hUWFmLmzJno378/HB0dMWjQIERERGitd+bMmVi8eDFcXV3h5OSEOXPmoKioSLNMSUkJFi9eDDc3Nzg6OmL48OHYsWOHVn0ODg7YuHEjpk+fDpVKhYEDB2LlypVay+zbtw+jRo1Cr1694OLigtdffx1JSUma+Y/ry6NCQkJw+PBhbN26FQ4ODlrfJB49XHZwcMD69evxn//8B71798aLL76I3bt34/bt2/jwww+hUqng4eGBPXv2aG0jNzcXISEh6NevH1QqFXx9fXHs2LFqXyu1Wo2lS5fi+eefh0qlwn/+8x/cunVLa5lHh8Wqe52q6mf5cNf27dvx7rvvonfv3oiOjq5yGOzKlSt466230LNnT3h4eGh9aFTV5uFvqe7u7igrK8PMmTM1dQCVD4slJCTgzTffRM+ePdGnTx98+OGHyMvL08wvH6rZt28fPD090bt3bwQEBODSpUvVPreP2xfd3d3x008/4ciRI3BwcEBAQECFdVy+fBlvvvkmAMDDw6PS5b7//nsMHjwYTk5OmDhxInJzc7XmHzp0CL6+vujZsyfc3Nwwc+ZM3Lhxo9ra67oPXrx4ERMmTIBKpYJKpcLEiRORnp6utUxiYiLGjRsHJycnqFQqvP766zh58mSldRQUFGD06NEICAhAYWFhlfXKZDL4+/tjyZIldf4yu3btWri5uaFXr1744IMPUFBQoJl35swZjB8/XvM+ee211yoczZeWlmLZsmUYMmQIHB0d4ebmhvnz51e5vdjYWKhUKuzatavKZa5cuYJx48ahZ8+eGDRoENavX19hmR07dsDHxwfOzs5wdXXFhAkTkJaWppk/aNAgAMCYMWPg4OAAd3d3AEBmZibef/99DBgwAL169YKXlxe2bdumte74+Hj4+vpqXs+RI0fizz//1Myv7jOnJvtuBeIx/P39Re/evcWcOXPE+fPnRUpKirh+/bp44YUXRGhoqEhJSRGpqakiPDxc9O3bV+Tl5QkhhJg/f77w8vISCQkJ4sqVK+Kff/4R33//vdZ6VSqVmD17trhw4YLYv3+/6Nevn1iwYIFmmU8++UT07dtX/PLLL+LixYviiy++EA4ODuKvv/7SLKNQKMTzzz8vvv/+e5Geni42bNggFAqFZpmcnBzRvXt3sWrVKpGRkSEuXLggtm/fLlJSUoQQokZ9edStW7eEn5+fCAwMFDk5OSInJ0cUFRVp6tm2bZtWfS+88ILYsmWLuHTpkggLCxM9evQQ48aNE5s3bxaXLl0S4eHholevXiI/P18IIcS9e/fEyy+/LN5//31x6tQpcenSJbFixQrRvXt3ceHChSpfq7Vr14pevXqJLVu2iIsXL4pVq1YJZ2dnoVQqNcts3rxZ63F1r1NV/czMzBQKhUK4ubmJ2NhYkZGRITIyMjTTjx07JoQQmsf9+/cXsbGxIjU1VSxZskR069ZNnDlzRmuZ8jblhgwZImJiYoQQQuTl5QmlUinWrl2rqUMIIY4cOSIUCoXIzs7WvNYqlUpMmzZNpKSkiGPHjokRI0YIPz8/zXpjYmJEr169xNixY8Xp06dFcnKyePXVV8Xo0aOrfF6FePy+mJeXJwIDA4Wfn5/IyckRN27cqLCO0tJSsW/fPqFQKMTJkye1lgsODhZOTk5i6tSp4uzZs+L48eNi8ODBIigoSNP+r7/+Ej179hTr1q0TaWlp4uTJk8Lf31+8+eabQq1WV1l7XffBF198UYwZM0acPn1anD59Wvj7+4shQ4Zo9vVz586JXr16ialTp4pTp06JtLQ0sWPHDnH8+HHNcz1kyBAhhBBXrlwRnp6e4oMPPtC0r0z5/nnz5k3Rt29fsWbNGs28h/eJqgQHBwuVSiX+/e9/i5SUFHHkyBExdOhQMWnSJM0yR44cEZs3bxbnzp0TFy9eFEuWLBHdu3cXFy9e1CwzY8YM0a9fP7F161aRnp4uTpw4Ib7++mut57T8fV7+Pjt8+HCVdanVajFq1CjxP//zPyIhIUEkJSWJt99+W6hUKjFr1izNcj/99JPYv3+/SE9PF2fOnBH//ve/xdChQzXP2ZkzZ4RCoRB79uwROTk5ms+olJQUsX79epGcnCzS09PFunXrhFKp1NRUUlIi+vTpIxYuXCjS0tJEWlqa2Lt3r+Z997jPnOr23arUKFxeeuklUVZWppkWExMjfHx8Kjx5Hh4emhdg4sSJIjg4uNr1Dh48WJSWlmqmbdq0STg6Ooo7d+6Iu3fviu7du4sNGzZotZs0aZIICAjQPFYoFGL+/Play3h6eorFixcLIf77YmRmZlZaR036Upm33nqr0v5VFi4ff/yx5nFeXp5QKBQiPDxcM62goEAoFApx4MABIcSDN5ibm5soKSnRWndAQIDWuh7l5uYmlixZojVtypQp1YbL416nyvpZHgjLli2rdPqj4fLZZ59pLffGG29oPjRrEi5CCKFUKsXmzZu1lnk0XD777DPh5uam9eGVnJwsFAqF+Pvvv4UQD15vpVKp9cXh559/Fg4ODuL+/fuVPgc13ReDg4PFW2+9Vek6yh07dqzS/TE4OFj069dPq/aVK1eK/v37ax77+/uLqKgorXZXrlwRCoVCJCUlVbnNuuyDP/zwg+jZs6fW83T9+nXRo0cPsXXrViGEEEFBQcLLy0vrs+Fh5eGSnJwsBgwYIMLDw6tcttzD++fatWtFnz59NB9iNQ2X3r17i1u3bmmm/fnnn0KhUIhLly5V2c7Ly0usWLFCCCHEpUuXhEKhELt27apyeYVCIbZu3Srmz58v+vfvL5KTk6ut69ChQ0KhUGgFWF5enujRo4dWuDzqxo0bQqFQiPj4eCGEENnZ2UKhUIgjR45Uuz0hHry3Z8+eLYT47+tbVbuafOZUte9WxaT645oHunfvrjWuffr0aZw5cwYqlUprufv372sOm/38/PDBBx8gMTER/fr1g5ubG9zc3LTW06NHD61xaScnJxQXFyMjIwPAg6GIPn36aG2jT58+WLVqlda0bt26aT22sbHRDCc4ODhgwIAB8PLywgsvvIC+ffvipZde0pxsrUlf6uvh+qysrGBsbKwZ2gGA1q1bw9TUVDN8c/r0aeTm5lboe3FxMZo1a1bpNgoLC3Ht2rUK/XBycsK+ffuqrK0mr1NVevbs+dhlAFSoSaVS4ciRIzVqWxsXLlxA7969YWZmppnWrVs3WFhY4Pz585rn08bGBlZWVpplbGxsIIRAXl4e2rdvX2G96enpNd4X66Nr165atT+8HwMP9ouEhARs3LixQttLly5BqVRWue7a7oMXLlyAvb291vPUtm1bPP300zh//jyAB8NLj9tX8vPz4e/vDx8fHwQHB1fX/Qr8/PywYcMGfPHFF5g5c6bWvO3btyMsLEzzeN68eRg5ciQAwN7eHhYWFpp5Tk5Omj517twZ+fn5iImJwZEjR5Cbm4uysjIUFRUhKytL0y8AGDBgQLX1LV26FPfv38dPP/2Ejh07VrvshQsX0KZNGzz99NOaaVZWVlqPASA5ORnLli1DcnKy1nBnVlYWnJ2dq1z/vXv3sHz5cvz222+4fv06SkpKUFxcDFdXVwAPXl8fHx+MGzcO/fr1Q9++fTFkyBB07doVQN0+cx6nRuHSvHlzrcdqtRr9+vVDaGhohWXLX1Q3Nzf89ttviIuLw99//40ZM2ZAoVBg7dq1kp/ofPQEspGREcT/v9mzsbExVq9ejdOnT+Ovv/7C3r178emnnyI6OhqDBw+uUV/qy8Sk4tP86LSHa1ar1bC3t8eyZcsqtKvrC12V+rxOj+4XdVHVB1NpaWm9112Vqi44UKvVDbbNmqhuPwYe1Pfuu+/C29u7QtvHXaRR231QKq1atYKDgwP279+Pt956C+3atatxW1NTU3z44YcICgqCv7+/1jx3d3etqxKtra1rvN6QkBBkZ2dj+vTp6NixI5o1a4apU6eipKSkxusAgOeffx67du3CL7/8ggkTJtSqbWXu3buHsWPHwtnZGREREZrX9JVXXnlsbYsWLcL+/fsREhKCrl27onnz5vjkk0+0zm19/PHHGDNmDA4dOoRDhw4hOjoac+bMga+vb4N85tTpMhtHR0dcuHAB7dq1Q+fOnbX+PfxNx9LSEiNGjEB4eDhWrlyJv//+GxcuXNDMP336NMrKyjSPT5w4ATMzMzz11FPo3LkzzMzMKpzEPnbsGJ599tla1WtkZISePXti4sSJ2LhxI/r06aO5rLWmfXmUqampVu1ScnR0RGZmJlq2bFmhJltb20rbtGzZEra2tjhx4oTW9OPHjz92e9W9TlL0MyEhQevxiRMnYG9vDwCa5zgnJ0czPy8vD9euXdNqU5M6nnnmGSQkJGidBE5JScHt27ehUCjqXL+U+2L5kUldgqx8X310n+jcuTP+9a9/1Xp91XnmmWeQmpqK/Px8zbTc3FykpaVp+ty9e3ccPny42r6YmJjg888/h0KhgL+/P65cuVKrOjw9PeHo6IjFixdrTX/0vdGyZUvNvNTUVK0P1fL3xDPPPAPgwes2evRozYlpuVyudXlt9+7dATz4s4Lq9OvXD6tWrcIXX3yB5cuXV7vsM888gxs3bmhdOJKfn691sr78+Z46dSpcXV1hb2+PmzdvagV++ReQR5/z+Ph4eHl5Yfjw4ejWrRs6depU6UUqCoUC77zzDlavXo3XXnsNP/zwA4CafebUdt+tU7j4+/ujrKwMkyZNQnx8PC5fvoz4+Hh89tlnmg+zzz77DHv37sXFixdx6dIl7NixAy1atNAadigoKMC8efOQmpqKgwcPIjo6Gm+88QZatGiB5s2bIyAgADExMdi1axfS0tLw5ZdfYv/+/Zg4cWKNaz1+/DiWL1+OkydPIisrC4cPH8bZs2c1H2416UtlOnbsiDNnziAjIwP5+fm1/tZTnZEjR6Jjx46YMGEC4uLicPnyZZw8eRIrV66sdohr7NixWLduHbZt24ZLly7hq6++wuHDh6vd1uNeJyn6+dNPP2HHjh1IS0tDdHQ0EhIS8M477wB48K3IyckJq1evRkpKChITEzFjxgyt4aHyOo4ePYpr165pfeA9zN/fX3P127lz5xAfH4/p06fDxcUFLi4uta67nFT7IgC0b98eMpkMv//+O/Ly8nD79u0at/3ggw+wf/9+REREIDk5GRkZGfjjjz8wa9Ys3L9/v7bdqpaXlxesrKwwdepUnDlzBomJiZg6dSpsbW0xfPhwAMD48eORnp6OoKAgnD59GhkZGdi1a1eFLzimpqZYunQpHB0dERAQgMzMzFrVEhwcjD179lT4wlEVIyMjzJgxA+fOncOxY8cQHh4Od3d3dO7cGQDw9NNPY8eOHTh79iySk5Mxbdo0rS8unTt3hpeXF+bNm4fY2FhkZGTg1KlT+Oabbypsq2/fvli9ejXWrFmD6OjoKmt6/vnn0a1bN0yfPh2nTp1CcnIypk+frnX02L59e5iZmWH9+vXIyMjA4cOHsWDBAhgZGWmWadOmDVq0aIG4uDhcv34dN2/e1PRp//79OHXqFC5cuIA5c+ZofWFLT09HVFQU4uPjceXKFZw4cQL//POP5nOwJp85td13azQs9qi2bdvi+++/x5IlS/D++++jsLAQcrkczs7OkMvlAB6kXExMDK5cuQKZTAalUon/+7//0xpqGjZsGP71r3/Bz88PxcXFGD58OIKCgjTzp06dCplMhoULF+LGjRt46qmnEBUVheeff77GtVpYWGj+sO3mzZuQy+Xw8vLCpEmTatyXyowdOxbnzp2Dt7c37t69i3Xr1mnGN+vL3Nwc69evx9KlSzWXmrZp00Zz+WlVxowZg/z8fERERKCoqAgDBw7E5MmTsWjRoirbPO51qqyfHTp0qFV/PvzwQ/zwww+YNWsW5HI5oqKiNN8OAWDhwoWaw3MbGxsEBQVpzruVCw4ORkREBDw8PFBSUlLppeJt27bFV199haioKLz++uswMzPDoEGDMGvWrFrVWxkp9sXyGqdNm4ZVq1Zh4cKFcHFxqfSS1Mr069cP33zzDZYtWwY/Pz8IIWBnZ4cBAwZUOuxVH82aNcOaNWsQERGhGZIq/yAtD/7yS5yXLFmCgIAAGBkZ4dlnn8VHH31UYX0mJib49NNPERwcDH9/f3zzzTfo0qVLjWpRqVR46aWXKlwqXZWePXvC2dkZY8eOxe3btzFw4ECEh4dr5kdERCAsLAw+Pj5o27Ytxo0bVyGcIyIisHz5ckRHRyMnJwdWVlYYNmxYpdtzdnbG119/jXHjxqGkpETrM6yckZERli9fjtDQULz55pto06YNxo0bp3WUbWVlhaioKCxZsgSbN2+Gvb09Zs2apXXHAZlMhrCwMMTExODrr79Gu3btcODAAcycORMfffQRxowZg5YtW+J///d/MWzYME2QN2/eHOnp6Zg2bRry8/NhaWmJF198UXMerCafObXdd42E1IOsNRQQEICnnnoKCxYs0MXmiYioAenHnzYTEZFBYbgQEZHkdDYsRkREhotHLkREJDmGCxERSU7a6xf1zOXLlzF58mTN49u3b6OwsBB///030tLSEBISgoKCAlhaWiIyMrLGl0YSEVH1mtQ5lwULFqCsrAyhoaEYM2YMXnvtNXh7eyM2NhabN2/GunXrdF0iEZFBaDLhUlxcjIEDB2LNmjVo164dhg0bhqNHj8LY2BhlZWVwdXXF3r17q73ly8Py8gqhVtfuqWvTpgVu3Lhbl/L1liH2CWC/Ghv2C5DLpbkXolSazDmXAwcOwNbWFt27d0d2djZsbW01N2Y0NjaGjY0NsrOzG7QGExPD+2VCQ+wTwH41NuyX/jHocy4P27x5M1577TXJ1mdt3fLxC1VC375dSMEQ+wSwX40N+6VfmkS4XLt2DceOHdPcY8vOzg7Xrl1DWVmZZlgsJydH8xsvNVGXYTG53ALXr9f8RoWNgSH2CWC/Ghv2S/9CqEkMi23duhWDBg1CmzZtADz47QelUomdO3cCAHbu3AmlUlnj8y1ERFS9JhMujw6JzZ07Fxs2bMCwYcOwYcMGzJs3T0fVEREZniYxLFbZrbrt7e3x448/6qAaIiLD1ySOXIiI6MliuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkuSbxdy76oqRUXadbNBQVl+LWzXsNUBERUcNguDxBpiYyTI/+vdbtogIHNUA1REQNh8NiREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5Ex0XUBDKioqwsKFC3H48GGYm5ujd+/emD9/PtLS0hASEoKCggJYWloiMjISXbp00XW5REQGw6DDJSoqCubm5tizZw+MjIyQm5sLAAgLC4Ofnx+8vb0RGxuL0NBQrFu3TsfVEhEZDoMdFrtz5w62bduGwMBAGBkZAQDatm2LvLw8JCUlYcSIEQCAESNGICkpCfn5+bosl4jIoBjskUtmZiYsLS2xbNkyHD16FP/6178QGBiIZs2awdbWFsbGxgAAY2Nj2NjYIDs7G1ZWVjqumojIMBhsuJSVlSEzMxPPPfccgoODcfLkSUycOBHR0dGSrN/aumWd2pma1u0pl8st6tTuSdDn2uqD/Wpc2C/9YrDhYmdnBxMTE83wV69evdCmTRs0a9YM165dQ1lZGYyNjVFWVoacnBzY2dnVav15eYVQq0Wt2sjlFigpKa1Vm3LXr9+uU7uGJpdb6G1t9cF+NS7sl/6FkMGec7GysoKrqysOHToEAEhLS0NeXh66dOkCpVKJnTt3AgB27twJpVLJITEiIgkZ7JELAMybNw+zZs1CZGQkTExMsGjRIrRq1Qpz585FSEgIVqxYgVatWiEyMlLXpRIRGRSDDpdOnTph/fr1Fabb29vjxx9/1EFFRERNg8EOixERke4wXIiISHIMFyIikpxBn3MxFCWl6jpdZlhUXIpbN+81QEVERNVjuDQCpiYyTI/+vdbtogIHNUA1RESPx2ExIiKSHMOFiIgkx3AhIiLJMVyIiEhyDBciIpIcw4WIiCTHcCEiIskxXIiISHIMFyIikhzDhYiIJMdwISIiyTFciIhIcgwXIiKSHMOFiIgkx3AhIiLJMVyIiEhyDBciIpIcw4WIiCTHcCEiIskxXIiISHIMFyIikhzDhYiIJMdwISIiyTFciIhIcgwXIiKSHMOFiIgkx3AhIiLJMVyIiEhyJrouoKG5u7vDzMwM5ubmAICgoCC4ubkhISEBoaGhKCoqQocOHRAVFQVra2sdV0tEZBgMPlwAICYmBgqFQvNYrVZj+vTpiIiIgIuLC1asWIHFixcjIiJCh1USERmOJjkslpiYCHNzc7i4uAAAfH19sXv3bh1XRURkOJrEkUtQUBCEEHB2dsa0adOQnZ2N9u3ba+ZbWVlBrVajoKAAlpaWOqyUiMgwGHy4bNy4EXZ2diguLsaCBQsQHh6OoUOH1nu91tYt69TO1LRuT3ld28nlFnVqp2/b0AX2q3Fhv/SLwYeLnZ0dAMDMzAx+fn547733MGbMGGRlZWmWyc/Ph0wmq9VRS15eIdRqUata5HILlJSU1qpNubq2u379dp3a1ZRcbtHg29AF9qtxYb/0L4QM+pzL3bt3cfv2gxdGCIFffvkFSqUSjo6OuH//PuLj4wEAmzZtgqenpy5LJSIyKAZ95JKXl4cpU6agrKwMarUa9vb2CAsLg0wmw6JFixAWFqZ1KTIREUnDoMOlU6dO2LZtW6XznJycsGPHjidc0ZNVUqqu06FyUXEpbt281wAVEVFTYdDh0tSZmsgwPfr3WreLChzUANUQUVNi0OdciIhINxguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJrEuGybNkyODg44Ny5cwCAhIQEjBw5EsOGDcPYsWORl5en4wqJiAyLwYfLmTNnkJCQgA4dOgAA1Go1pk+fjtDQUOzZswcuLi5YvHixjqskIjIsBh0uxcXFCA8Px9y5czXTEhMTYW5uDhcXFwCAr68vdu/eraMKiYgMk4muC2hI0dHRGDlyJDp27KiZlp2djfbt22seW1lZQa1Wo6CgAJaWljVet7V1yzrVZGpat6f8SbeTyy0aZNnGhP1qXNgv/WKw4XLixAkkJiYiKCioQdafl1cItVrUqo1cboGSktI6be9Jt7t+/XaNlpPLLWq8bGPCfjUu7Jf+hZDBhsuxY8eQmpoKDw8PAMDVq1cxbtw4BAQEICsrS7Ncfn4+ZDJZrY5aiIioegZ7zmXChAmIi4vDgQMHcODAAbRr1w5r1qzB+PHjcf/+fcTHxwMANm3aBE9PTx1XS0RkWAz2yKUqMpkMixYtQlhYGIqKitChQwdERUXpuiwiIoOi1+Gya9cuvPzyyxWm7969u9ZHGwcOHND838nJCTt27Kh3fYaqpFRdpxP6RcWluHXzXkOVRUSNiF6Hy+zZsysNl9DQUA5lNSBTExmmR/9es2VNTTQXDUQFDmrIsoioEdHLcMnMzAQACCE0/394npmZmS7KIiKiGtLLcBk6dCiMjIwghMDQoUO15rVt2xZTpkzRUWVERFQTehkuKSkpAAB/f39s2LBBx9UQEVFt6fWlyAwWIqLGSS+PXMplZmZi6dKlSE5Oxt27d7XmHTx4UDdFERHRY+l1uAQFBaFTp04IDg5G8+bNdV0OERHVkF6Hy/nz5/Hdd99BJtPr0TsiInqEXn9q9+nTB0lJSboug4iIakmvj1w6dOiA8ePHY+jQoWjbtq3WvMDAQB1VRUREj6PX4XLv3j0MHjwYpaWluHr1qq7LISKiGtLrcImIiNB1CUREVAd6HS6P3vrlYZ06dXqClRARUW3odbg8fBuYckZGRgCA5ORkXZVFRESPodfhUvI7FHEAABUkSURBVH4bmHLXr1/HsmXL4OLioqOKiIioJvT6UuRHyeVyzJ49G0uWLNF1KUREVI1GFS4AcPHiRdy7xx+kIiLSZ3o9LObn56c5xwI8uDT5woULmDx5sg6rIiKix9HrcPHx8dF63Lx5c3Tr1g1dunTRTUFERFQjeh0ur776qq5LICKiOtDrcy4lJSWIiYmBh4cHevToAQ8PD8TExKC4uFjXpRERUTX0+sglKioKp06dwrx589C+fXtkZWVhxYoVKCwsxKxZs3RdHhERVUGvw2X37t2IjY1FmzZtAABdu3bFc889B29vb4YLEZEe0+thsYf/Mr8m04mISD/odbh4enrivffew59//onU1FT88ccfmDx5Mjw9PXVdGhERVUOvh8WmT5+OL774AuHh4cjJyYGtrS1eeeUVvPfee7oujYiIqqGXRy7//PMPoqKiYGZmhsDAQPz66684efIk9u7di+LiYv46JRGRntPLcFm5ciX69OlT6TxXV1d8+eWXT7giIiKqDb0Ml+TkZLi5uVU674UXXkBiYuITroiIiGpDL8OlsLAQJSUllc4rLS3FnTt3nnBFRERUG3oZLl27dkVcXFyl8+Li4tC1a9cnXBEREdWGXobL22+/jbCwMOzduxdqtRoAoFarsXfvXsydOxfvvPOOjiskIqLq6OWlyF5eXsjNzUVwcDBKSkpgaWmJgoICmJqa4oMPPsCIESNqvK5Jkybh8uXLkMlkaNGiBebMmQOlUom0tDSEhISgoKAAlpaWiIyM5N2WiYgkopfhAgDvvPMOfHx8cOLECU0AqFQqtGzZslbriYyMhIWFBQBg3759mDVrFrZu3YqwsDD4+fnB29sbsbGxCA0Nxbp16xqiK0RETY7ehgsAtGzZssqrxmqqPFiABxcKGBkZIS8vD0lJSfj6668BACNGjMD8+fORn58PKyurem2PiIj0PFykMnv2bBw6dAhCCKxevRrZ2dmwtbWFsbExAMDY2Bg2NjbIzs5muBARSaBJhMuCBQsAANu2bcOiRYsQGBhY73VaW9dueK6cqWndnnJ9bvfwsnK5RTVLNi6G1JeHsV+NS2PtV5MIl3KjRo1CaGgo2rVrh2vXrqGsrAzGxsYoKytDTk4O7OzsaryuvLxCqNW1uzuzXG6BkpLS2pYNAHrbztTURGvZ69dv12l7+kYutzCYvjyM/WpcatMvfQshvbwUWSp37txBdna25vGBAwfQunVrWFtbQ6lUYufOnQCAnTt3QqlUckiMiEgiBn3kcu/ePQQGBuLevXuQyWRo3bo1vvzySxgZGWHu3LkICQnBihUr0KpVK0RGRuq6XCIig2HQ4dK2bVv88MMPlc6zt7fHjz/++IQrIiJqGgx6WIyIiHSD4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJzkTXBTSkGzduYMaMGcjIyICZmRk6d+6M8PBwWFlZISEhAaGhoSgqKkKHDh0QFRUFa2trXZdMRGQQDPrIxcjICOPHj8eePXuwY8cOdOrUCYsXL4Zarcb06dMRGhqKPXv2wMXFBYsXL9Z1uUREBsOgw8XS0hKurq6ax71790ZWVhYSExNhbm4OFxcXAICvry92796tqzKJiAyOQYfLw9RqNb777ju4u7sjOzsb7du318yzsrKCWq1GQUGBDiskIjIcBn3O5WHz589HixYt4O/vj19//bXe67O2blmndqamdXvK9bld+bIlpWrI5Ra13lZJqRqmJvr3PacufWkM2K/GpbH2q0mES2RkJNLT0/Hll19CJpPBzs4OWVlZmvn5+fmQyWSwtLSs8Trz8gqhVota1SGXW6CkpLRWbcrpaztTUxPNsqYmMkyP/r3W24oKHITr12/Xul1Dksst9K4mKbBfjUtt+qVvIaR/XxcltmTJEiQmJmL58uUwMzMDADg6OuL+/fuIj48HAGzatAmenp66LJOIyKAY9JHL+fPnsXLlSnTp0gW+vr4AgI4dO2L58uVYtGgRwsLCtC5FJiIiaRh0uDz77LM4e/ZspfOcnJywY8eOJ1wREVHTYPDDYkRE9OQxXIiISHIMFyIikhzDhYiIJGfQJ/TJsLVq3RzmZrXfhYuKS3Hr5r0GqIiIyjFcqNEyNzOp8x9tElHD4rAYERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5ERCQ5hgsREUmO4UJERJJjuBARkeRMdF0AUWPRqnVzmJvV/i1TVFyKWzfvNUBFRPqL4UJUQ+ZmJpge/Xut20UFDmqAaoj0G4fFiIhIcgwXIiKSHMOFiIgkx3AhIiLJMVyIiEhyDBciIpKcQV+KHBkZiT179uDKlSvYsWMHFAoFACAtLQ0hISEoKCiApaUlIiMj0aVLF90W24SVlKohl1vougwikpBBh4uHhwfGjBmDN998U2t6WFgY/Pz84O3tjdjYWISGhmLdunU6qpJMTWT8+xEiA2PQw2IuLi6ws7PTmpaXl4ekpCSMGDECADBixAgkJSUhPz9fFyUSERkkgw6XymRnZ8PW1hbGxsYAAGNjY9jY2CA7O1vHlRERGQ6DHhZrSNbWLevUztS0bk+5Prd7eFl9rvNhNTnHU9kyDbm9J0WfapES+6Vfmly42NnZ4dq1aygrK4OxsTHKysqQk5NTYfjscfLyCqFWi1q1kcstUFJSWqs25fS1nampiday+lrno65fv13tfLncosIy9Xn9Hre9J6WyfhkC9kv/QqjJDYtZW1tDqVRi586dAICdO3dCqVTCyspKx5URERkOgz5y+fjjj7F3717k5ubinXfegaWlJX7++WfMnTsXISEhWLFiBVq1aoXIyEhdl0pEZFAMOlw++ugjfPTRRxWm29vb48cff9RBRURETYNBhwtRZWr6R5v6NoZN1JgwXKjJqckfbT56oQLAP9okqo0md0KfiIgaHsOFiIgkx3AhIiLJMVyIiEhyDBciIpIcw4WIiCTHcCEiIskxXIiISHIMFyIikhzDhYiIJMdwISIiyTFciIhIcgwXIiKSHMOFiIgkx1vuEzWwmv5+zKOKiktx6+a9BqiIqOExXIgaWE1+P6Yy/P0Yasw4LEZERJJjuBARkeQYLkREJDmGCxERSY7hQkREkmO4EBGR5BguREQkOf6dCxHVS6vWzWFuVvuPEv6RqGFjuBBRvZibmfCPRKkCDosREZHkGC5ERCQ5DosR6am63vCypLQMpibGVc6vap08ByKtpn4uiuFCpKfqc8PLqtqZmpqgpKS0ynYknaZ+LorDYkREJDmGCxERSa7JDoulpaUhJCQEBQUFsLS0RGRkJLp06aLrsoiaDKnPKT1uXYZyLqOxaLLhEhYWBj8/P3h7eyM2NhahoaFYt26drssiajKkPKdU3bmkh9vRk9Mkh8Xy8vKQlJSEESNGAABGjBiBpKQk5Ofn67gyIiLD0CSPXLKzs2Frawtj4weH1sbGxrCxsUF2djasrKxqtA6ZzKhO225jYW5Q7UxMTVBa8t8hCn2ts7btHu1XQ2/vSbWrql/lGut+/bh+latr/+qqrv17uM4nXbNUjIQQQtdFPGmJiYkIDg7Gzz//rJk2fPhwREVFoXv37jqsjIjIMDTJYTE7Oztcu3YNZWVlAICysjLk5OTAzs5Ox5URERmGJhku1tbWUCqV2LlzJwBg586dUCqVNR4SIyKi6jXJYTEASE1NRUhICG7duoVWrVohMjISXbt21XVZREQGocmGCxERNZwmOSxGREQNi+FCRESSY7gQEZHkGC5ERCQ5hgsREUmO4fIEpKWl4Y033sCwYcPwxhtv4NKlS7ouqd4iIyPh7u4OBwcHnDt3TtflSObGjRt49913MWzYMHh5eeH99983iHvOTZo0CSNHjsSoUaPg5+eH5ORkXZckqWXLlhnUvuju7g5PT094e3vD29sbf/75p65Lqj1BDS4gIEBs27ZNCCHEtm3bREBAgI4rqr9jx46JrKwsMXjwYHH27FldlyOZGzduiCNHjmgef/LJJ2LmzJk6rEgat27d0vz/119/FaNGjdJhNdJKTEwU48aNM6h90RD6wiOXBmaod2B2cXExyNvlWFpawtXVVfO4d+/eyMrK0mFF0rCw+O9vnRQWFsLIqHHeDPFRxcXFCA8Px9y5c3VdCj2iSd4V+UmS4g7MpBtqtRrfffcd3N3ddV2KJGbPno1Dhw5BCIHVq1fruhxJREdHY+TIkejYsaOuS5FcUFAQhBBwdnbGtGnT0KpVK12XVCs8ciGqwvz589GiRQv4+/vruhRJLFiwAAcPHsTUqVOxaNEiXZdTbydOnEBiYiL8/Px0XYrkNm7ciO3bt2Pz5s0QQiA8PFzXJdUaw6WB8Q7MjVNkZCTS09OxdOlSyGSG9TYZNWoUjh49ihs3bui6lHo5duwYUlNT4eHhAXd3d1y9ehXjxo1DXFycrkurt/LPBzMzM/j5+eH48eM6rqj2DOtdo4d4B+bGZ8mSJUhMTMTy5cthZmam63Lq7c6dO8jOztY8PnDgAFq3bg1LS0sdVlV/EyZMQFxcHA4cOIADBw6gXbt2WLNmDQYMGKDr0url7t27uH37NgBACIFffvkFSqVSx1XVHm9c+QQY4h2YP/74Y+zduxe5ublo06YNLC0ttX58rbE6f/48RowYgS5duqBZs2YAgI4dO2L58uU6rqzucnNzMWnSJNy7dw8ymQytW7dGcHCwwf0wnru7O7788ksoFApdl1IvmZmZmDJlCsrKyqBWq2Fvb4+PPvoINjY2ui6tVhguREQkOQ6LERGR5BguREQkOYYLERFJjuFCRESSY7gQEZHkGC5EBmb79u0YO3asrsugJo6XIhM1YpcvX4aHhwfOnDkDExPeKpD0B49cyKCVlpbqugSiJonhQgbH3d0dq1atgpeXF3r37o34+Hj4+vrCxcUFI0eOxNGjRzXLbtmyBR4eHlCpVHB3d8f27ds10319fREeHg5nZ2d4enri8OHDmnbXrl3DxIkT0bdvXwwdOhQ//PCDZt7nn3+OwMBAzJgxAyqVCq+88gpOnz6tmb9q1Sq4ublBpVJh2LBhmvWq1WqsWrUKQ4YMgaurKwIDA1FQUFBtX8tvqtmnTx+oVCqcOHECW7ZswejRozXLODg4YOPGjXjppZegUqmwdOlSZGRkwNfXF05OTggMDERxcbFm+d9++w3e3t5wcXGBr68vUlJS6vIyUFOnqx+SIWoogwcPFiNHjhRZWVni6tWrom/fvuLgwYOirKxMxMXFib59+4q8vDxx584doVKpRGpqqhBCiGvXrolz584JIYTYvHmzUCqV4uuvvxbFxcXi559/Fk5OTuLGjRtCCCH8/PxEWFiYuH//vkhKShKurq7ir7/+EkIIERMTIxwdHcXBgwdFaWmpWLx4sfDx8RFCCJGamioGDhworl69KoQQIjMzU6SnpwshhFi7dq3w8fER2dnZoqioSMyZM0dMnTq12r5mZmYKhUIhSkpKNNM2b94sfH19NY8VCoWYOHGiuH37tjh37pzo3r27GDNmjMjIyBC3bt0SL7/8stiyZYsQQogzZ86Ifv36iYSEBFFaWiq2bNkiBg8eLIqKiur9ulDTwiMXMkgBAQGws7NDbGwsBg4ciEGDBkEmk6F///5wdHTE77//DgCQyWQ4f/487t+/DxsbGzz77LOadVhZWeGtt96Cqakphg8fjqeffhoHDx5EdnY2jh8/jqCgIJibm0OpVMLHxwexsbGats7Ozhg0aBCMjY3h7e2t+fZvbGyM4uJipKamoqSkBB07dsRTTz0FANi0aROmTp2Kdu3awczMDO+//z727NkjydDe+PHj0bJlSzz77LNQKBTo378/OnXqBAsLCwwcOBBJSUkAgO+//x5vvPEGevXqBWNjY7z66qswNTVFQkJCvWugpoVnAMkgld+yPCsrC7t378Zvv/2mmVdaWgpXV1e0aNECn332Gb766ivMnj0bTk5OCA4Ohr29PQDA1tZW6xcb27dvj5ycHOTk5KB169Zo2bKl1rzExETN47Zt22r+36xZMxQVFaG0tBSdO3fGrFmz8Pnnn+PChQsYMGAAQkJCYGtri6ysLEyePFnrFv8ymQx5eXmwtbWt1/PxcD3m5uYVHufm5mqer23btmHDhg2a+SUlJcjJyanX9qnpYbiQQSoPBTs7O3h7e+Pjjz+udDk3Nze4ubnh/v37WLp0KebMmYNvv/0WwIPzKkIIzbqys7Ph7u4OGxsb3Lx5E4WFhZqAKf/F0Zrw8vKCl5cXCgsLERoaisWLFyMqKgrt2rXDwoUL4ezsXOt+SsXOzg4TJ07Ee++9J+l6qenhsBgZtJEjR+K3337Dn3/+ibKyMhQVFeHo0aO4evUqcnNzsW/fPty9exdmZmZo0aKF1lFDfn4+1q1bh5KSEuzatQupqakYNGgQ7OzsoFKpsGTJEhQVFSElJQU//fQTRo4c+dh6Ll68iMOHD6O4uBhmZmYwNzfXbHP06NFYunQprly5otn+vn37ql2flZUVZDIZMjMz6/Es/ZePjw82bdqEkydPQgiBu3fv4uDBgygsLJRk/dR08MiFDJqdnR1WrFiBqKgofPjhh5DJZOjZsyfmzp0LtVqNtWvXIjg4GEZGRlAqlZg7d66mbc+ePZGeno5+/fqhbdu2iImJQZs2bQA8+EGxsLAwuLm5oVWrVpgyZQpeeOGFx9ZTXFyMTz/9FKmpqTA1NYVKpdL8hO2YMWMghMDYsWORk5MDa2trDB8+HEOGDKlyfc2bN8fEiRMxevRolJaWYvXq1fV6vnr06IH58+cjPDwc6enpaNasGZycnODi4lKv9VLTwz+iJKrEli1b8OOPP+K7777TdSlEjRKHxYiISHIcFiPSc9u3b0dYWFiF6e3btzeIn5Ymw8RhMSIikhyHxYiISHIMFyIikhzDhYiIJMdwISIiyTFciIhIcgwXIiKS3P8DWJQc+sH8sk8AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAFACAYAAACr5pu4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de1zO9/8/8EfXVTnTQbUaY+JKIirHEUM+WUpOLUuxmQxz+BhWZisx0mzMeQ7DaPaxhJTjmM1qzocxlQ0dHC5FCZHK1ev3h5/316WD3qmra/a4327drq739Xq934/rfR2e1/tsIIQQICIiKidFdQcgIqJ/FhYOIiKShYWDiIhkYeEgIiJZWDiIiEgWFg4iIpKFheMfbOvWrWjVqlWp9yvT1atXYWdnhxMnTpR4v7IdPXoUdnZ2uHHjRpWMX67c3Fx8+OGHcHFxgZ2dHa5evVruvsHBwXj33XerLlw1WLJkCfr06aPTaepqPtrZ2SEmJuaFxxMQEIAZM2ZUQiL9o7eFIyMjA61bt0a3bt3w6NGj6o7zj+Dh4YFDhw6Vu/27776L4ODgcrW1trZGfHw82rZtW9F4pWrVqhW2bt2qNczJyQnx8fGwtLSs9OlVxKZNm3DmzBls2rQJ8fHxsLa2LtbmxIkTsovKv8nWrVthZ2cHHx+fYo/16dMHS5YsqYZU+uPGjRuws7PD0aNHdT5tue9dvS0cUVFR6NmzJ+rXr4+DBw9WdxwAQGFhYXVHKFPNmjXRsGHDSh9vQUEBlEolLCwsYGRkVOnjL4mxsTEsLCygUOjHWzQtLQ3NmzeHnZ0dLCwsoFQqqzvSP5KBgQGSk5Oxc+fO6o5CL0A/PpXPKCoqQnR0NAYOHIgBAwZg8+bNxdpkZWVh+vTpeOONN9CmTRu4u7tjy5Yt0uPp6emYOHEiOnbsiLZt28LLy0sqQCWt0nm22j9ZVfLLL7/gnXfeQZs2bRAVFYU7d+5g6tSpePPNN+Ho6Ah3d3esXbsWzx6Av2vXLgwaNAht2rRBp06dMGrUKNy5cwdbt25F+/btkZeXp9V+6dKl+M9//lNsPE/Pk6+//hpdunSBk5MT/vvf/+Lu3btabZ59Xrm5uZg+fTq6du2K1q1bo0ePHggPDwfweLH/8OHD2LZtG+zs7KTn/mQV1I4dOxAYGIh27dph0aJFpa6aunbtGkaMGAFHR0f07t1b6wuhtD5P/7rs1asXNBoNpk+fLuV4ev4/varqzJkzGDZsGBwdHdGhQwdMmTIFWVlZ0uNPVp/s378fffv2Rbt27RAQEIDU1NQS5+kThYWF+PLLL+Hq6orWrVvDw8MDsbGx0uO9evXCli1bcOTIEdjZ2SEgIKDYOK5evYphw4YBAHr37l1iu82bN6Nnz55wdnbGmDFjcOvWLa3HExISMHToUDg6OsLV1RXTp0/H7du3y8xuZ2eHjRs34r///S/atWuHN998E3v27MG9e/cwZcoUODk5oXfv3ti7d69Wv8uXL2P06NFwcnKCk5MTxowZg7S0NK02f/75J95//304OzvDyckJQ4YMwR9//FFijpycHLzzzjsICAhAbm5uqXkVCgX8/f2xYMECFBQUlPncSrN+/Xq4urqibdu2mDhxInJycqTHzp8/j1GjRkmfk8GDBxdbCn/06BGWLl0KNzc3tG7dGq6urpg9e3ap04uJiYGTkxN2795daptr167h/fffh6OjI3r06IGNGzcWaxMbGwsfHx+4uLigU6dOGD16NFJSUqTHe/ToAQAYPnw47Ozs0KtXLwDAlStXMH78eHTr1k36Ltu+fbvWuE+cOIGhQ4dKr2f//v3x22+/SY/funULwcHB6Ny5M5ycnDB06FAcP34cQPneu8UIPXTw4EHxxhtviMLCQnHjxg3h4OAgrly5Ij2el5cn+vbtKwYMGCASEhJEenq6+O2330RcXJwQQojMzEzRpUsXMWLECHH8+HGRlpYmfvrpJ/HLL78IIYSIjo4W9vb2WtNUq9VCpVKJI0eOCCGEOHLkiFCpVMLd3V0cOHBApKenC7VaLTIzM8XKlSvFn3/+KdLT08X27dtFu3btxJYtW6RxbdmyRbRq1UosXbpU/P333yIpKUmsX79eZGVliby8PNG+fXuxdetWqb1GoxE9e/YUK1euLHWerF+/XrRt21Zs3bpVXL58WaxatUq4uLhoPY9nn9fs2bOFl5eXOHPmjLh27Zo4efKk2Lx5sxBCiLt37wo/Pz8xadIkkZmZKTIzM0V+fr64cuWKUKlUwtXVVcTExIj09HSRnp4uDT9+/LgQQkj3u3btKmJiYsSlS5fEggULRMuWLcX58+e12jzp84Sbm5tYvHixEEKIrKwsYW9vL9avXy/leHr+q9Vq6TV1cnISH330kUhOThbHjx8Xnp6ews/PTxrv4sWLRdu2bcXIkSPFuXPnRFJSkhg4cKB45513Sp2vQggxb9480bFjR7Fr1y5x+fJlsWLFCmFnZyd+//13KeOkSZOEn5+fyMzMFLdv3y42jkePHon9+/cLlUol/vjjD612QUFBwtnZWUyePFlcuHBBnDp1SvTs2VNMnTpV6v/7778LR0dHsWHDBpGSkiL++OMP4e/vL4YNGyaKiopKza5SqcQbb7whtm7dKlJTU0VoaKho06aNeP/990V0dLRITU0Vs2bNEm3bthXZ2dlCiMefnzfffFMMHz5cnDt3Tpw7d074+/sLNzc3kZ+fL4QQ4q+//hJt27YVkydPFmfPnhUpKSkiNjZWnDp1SprXbm5uQgghrl27Jvr27SsmTpwo9S/Jk/fnnTt3RMeOHcW3334rPfb0e6I0QUFBwsnJSXzwwQciOTlZHDlyRPTp00eMGzdOanPkyBERHR0t/vrrL3H58mWxYMEC4eDgIC5fviy1+fjjj0Xnzp3Ftm3bRFpamjh9+rRYt26d1jzdvn27EEJIn7PDhw+XmquoqEgMGDBADBo0SJw5c0YkJiaKd999Vzg5OYlPPvlEardlyxZx4MABkZaWJs6fPy8++OAD0adPH2menT9/XqhUKrF3716RmZkpsrKyhBBCJCcni40bN4qkpCSRlpYmNmzYIOzt7aVMhYWFokOHDmLu3LkiJSVFpKSkiH379kmfu7y8PPHWW2+J8ePHi7Nnz4rU1FSxfPly4eDgIC5evFjme7c0elk4xowZI8LDw6X7I0eOFAsWLJDu//jjj6J169bSl8qzFi5cKN544w1x//79Eh+XUzi2bdv23LyzZ88W7777rnS/R48eIiwsrMz2Q4cOle4fOnRIODg4iFu3bpXax9XVVWseCCHEhAkTyiwcY8aMEUFBQaWOc8SIEcUef/Jlv3Tp0hKHP1s4Fi5cqNXO19dX+kIsT+EQQgh7e3sRHR2t1ebZwrFw4ULh6uqq9cWUlJQkVCqVOHbsmBDi8ZeZvb299IETQoidO3cKOzs78fDhwxLnwYMHD4SDg4OIjIzUGj5u3DgREBAg3Q8KChIjRowocRxPHD9+XKhUKq0fOU/6du7cWSv7ypUrRdeuXaX7/v7+Yv78+Vr9rl27JlQqlUhMTCx1miqVSnz++efS/aysLKFSqcSsWbOkYTk5OUKlUomff/5ZCPH48+Po6Kg1n27evCnatGkjvd+nTp0qvLy8hEajKXG6TwpHUlKS6Natm5g1a1apbZ94+v25fv160aFDB+kLqryFo127duLu3bvSsN9++02oVCqRmppaaj8vLy+xfPlyIYQQqampQqVSid27d5fa/snnfvbs2aJr164iKSmpzFwJCQlCpVJpFaesrCzRpk0brcLxrNu3bwuVSiVOnDghhCj+HVSWMWPGiBkzZggh/u/1La1fdHS0cHV1FYWFhVrDAwICpPdOae/d0hiWvTyiexkZGfj111+xbds2adjAgQMxb948TJgwAYaGhjh//jyaN2+OV155pcRxnD9/Hk5OTqhdu/YL53F0dNS6X1RUhDVr1mDnzp24ceMGCgoKUFhYiFdffRXA41VoarUaXbt2LXWcvr6+8PT0xKVLl2Bra4uoqCj06tUL5ubmJbbPzc1FRkYGnJyctIY7Oztj//79pU7Hz88PEydOxJ9//onOnTvD1dUVrq6u5dpu8OzzLs2zmZycnHDkyJFy9ZXj4sWLaNeuHYyNjaVhLVu2RL169fD333+jQ4cOAABLS0uYmZlJbSwtLSGEQFZWFmxsbIqNNy0tDYWFhVL/Jzp06IBVq1ZVWv5mzZppZbe0tNRaVXXu3DmcOXMG33//fbG+qampsLe3L3XcLVu2lP43MzODUqmUVvkBQIMGDWBkZCSt1rt48SJsbW215lPDhg3x+uuv4++//wbw+DP0vPdKdnY2/P394ePjg6CgoLKefjF+fn6IjIzEihUrMH36dK3HduzYgdDQUOl+WFgY+vfvDwCwtbVFvXr1pMecnZ2l59SkSRNkZ2dj8eLFOHLkCG7dugWNRoP8/Hxcv35del4A0K1btzLzff3113j48CG2bNmCRo0aldn24sWLMDU1xeuvvy4NMzMz07oPAElJSVi6dCmSkpK0VkFev34dLi4upY4/Ly8Py5Ytw8GDB3Hz5k0UFhaioKAAnTp1AvD49fXx8cH777+Pzp07o2PHjnBzc0OzZs0APH5v3bp1q9h7vKCgADVr1izzuZVG7wpHVFQUNBoNBg4cqDVco9Hg4MGDlbILYEkfhtI2fD9bfNauXYuVK1di+vTpaNWqFerUqYP169fj119/Lff0W7RoARcXF/z4448YPXo0fv75Z3zzzTfynkQ5uLq64uDBg4iPj8exY8fw8ccfQ6VSYf369c/duFurVq0Xnn5pXzpVuZdcaRvvi4qKqmya5fFsLgMDA63tWUVFRQgMDIS3t3exvs/b4cHQsPjH+Nlhz06vMtSvXx92dnY4cOAARowYUeoPuZIYGRlhypQpmDp1Kvz9/bUe69Wrl9bee6X9oCpJcHAw1Go1pk2bhkaNGqFmzZqYPHmy7B1bunTpgt27d2PXrl0YPXq0rL4lycvLw8iRI+Hi4oLw8HDpNe3Xr99zs33xxRc4cOAAgoOD0axZM9SqVQvz5s3T2pb0+eefY/jw4UhISEBCQgIWLVqEzz77DEOHDkVRURFsbW2xdOnSYuOuaOHQq43jTzaKjxkzBtu3b9f68/T0lDaSOzg44OLFi6Xu4+/g4IDTp0/jwYMHJT5uZmYGjUaj9YsvMTGxXBlPnDgBV1dXDBkyBK1atUKTJk20Niqam5vjlVdeQUJCQpnj8fX1xfbt27F582ZYWlqWuYRSt25dWFlZ4fTp01rDT5069dy8JiYm8PT0xKxZs7By5UocO3YMFy9eBPD4w6vRaJ47jrKcOXNG6/7p06dha2sLANIv2szMTOnxrKwsZGRkaPUpT47mzZvjzJkzWhtUk5OTce/ePahUqgrnb9KkCYyNjaUNhU8cP34cLVq0kDWuJ0sUFSlSrVu3ln41P/tXp04d2eMrS/PmzXHp0iVkZ2dLw27duoWUlBTpOTs4OODw4cNlPhdDQ0MsWbIEKpUK/v7+uHbtmqwcffv2RevWrfHll19qDa9bt67W869bt6702KVLl7S+MJ98Jpo3bw7g8ev2zjvvSBt5LSwstHYxdXBwAADEx8eXma1z585YtWoVVqxYgWXLlpXZtnnz5rh9+7bWThjZ2dlaG76fzO/JkyejU6dOsLW1xZ07d7SK+ZMfF8/O8xMnTsDLywseHh5o2bIlGjduXOIOHyqVCu+99x7WrFmDwYMH48cffwTw+L115cqVYvO1SZMmsLKyAiD/vatXhePQoUNQq9Xw9fWFSqXS+hs4cCASEhJw9epVeHp6wsbGBmPHjsXvv/+OK1eu4PDhw9i1axeAx4vBRUVFGDduHE6ePIkrV67g4MGD0lKBo6Mj6tSpg6+++gqpqak4dOjQc98cT7z++us4duwYjhw5gpSUFCxcuLDYnibjx4/H5s2bsWzZMly6dAl///03IiMjtT6offv2BQAsX74cPj4+MDAwKHO6I0eOxIYNG7B9+3akpqZi7dq1OHz4cJl9Fi5ciH379uHy5ctITU1FbGwsateuLa2yadSoEc6fP4/09HRkZ2dXaHfjLVu2IDY2FikpKVi0aBHOnDmD9957D8DjXzPOzs5Ys2YNkpOT8eeff+Ljjz/WWmXzJMfRo0eRkZGhNY+e5u/vL+0l9tdff+HEiROYNm0a2rdvj/bt28vO/UStWrUQEBCAxYsXY/fu3UhJScE333yDAwcOYMyYMbLGZWNjA4VCgV9//RVZWVm4d+9euftOnDgRBw4cQHh4OJKSkpCeno5Dhw7hk08+wcOHD+U+rTJ5eXnBzMwMkydPxvnz5/Hnn39i8uTJsLKygoeHBwBg1KhRSEtLw9SpU3Hu3Dmkp6dj9+7dxX68GBkZ4euvv0br1q0REBCAK1euyMoSFBSEvXv3FvsxURoDAwN8/PHH+Ouvv3D8+HHMmjULvXr1QpMmTQA8/nzGxsbiwoULSEpKwkcffaT1o6RJkybw8vJCWFgYYmJikJ6ejrNnz+K7774rNq2OHTtizZo1+Pbbb7Fo0aJSM3Xp0gUtW7bEtGnTcPbsWSQlJWHatGlaS302NjYwNjbGxo0bkZ6ejsOHD2POnDlan3tTU1PUrl0b8fHxuHnzJu7cuSM9pwMHDuDs2bO4ePEiPvvsM60fY2lpaZg/fz5OnDiBa9eu4fTp0zh58qT0A65///5o1KgRRo8ejfj4eFy9ehV//PEHVq5cKa3qlvve1avCsXnzZrRt27bEddGdO3dGgwYNEBUVhVq1aiEyMhItWrTA5MmT4eHhgbCwMOkDZmlpiU2bNqFOnToYPXo0PD09sXDhQmlcJiYmWLBgAc6cOYP+/ftj+fLlmDZtWrkyjhs3Dh06dMC4ceMwdOhQ3L17t9iuaz4+PggPD8fevXvh7e0Nf39/HDp0SOuNVKNGDXh7e0MIgcGDBz93usOHD0dAQADCw8MxYMAAnDlzBh9++GGZfYyNjbF48WIMHjwYgwcPxoULF7B69WppHfHIkSNhamoKb29vdOnSpVxLMM+aMmUKfvzxR/Tv3x8xMTGYP3++9KsOAObOnYvatWtj6NCh+Oijj+Dr6wsLCwutcQQFBeH8+fPo3bs3unTpUuJ0GjZsiLVr1+LGjRsYMmQIxowZA5VKhcWLF8vO/KzJkyfDx8cHc+fOhZeXF3bs2IH58+eXmqU0DRs2xEcffYRVq1ahW7duGDduXLn7du7cGd999x0uXLgAPz8/9O/fH+Hh4ahTp06Jq6JeRM2aNfHtt9/C2NgY/v7+CAgIQO3atbFmzRqpqD/ZzTc7OxsBAQHw9vbGunXrSlzFaWhoiK+++grOzs7w9/d/7u7PT3NycsJ//vMf5Ofnl6u9o6MjXFxcMHLkSIwaNQoqlQpz586VHg8PD4cQAj4+Pvjwww/h6uqKNm3aaI0jPDwcvr6+WLRoETw8PDB+/PhSD3xzcXHBunXrsHHjxmJLRk8YGBhg2bJlqFevHoYNG4YPPvgA3bt31/ocmJmZYf78+fj999/Rr18/REREICgoSGt1rkKhQGhoKHbv3o0ePXpIq+unT5+OV199FcOHD8e7774LKysruLu7S/1q1aqFtLQ0fPTRR3B3d8eECRPg5OSEkJAQAI+/azZu3IjWrVtj+vTp6Nu3L8aPH4+zZ89K37Vy37sGorJXfFK5TZo0CY8ePSr30g4RkT7Qu43j/wZ37tzB2bNnsX//fqxfv7664xARycLCUQ0GDhyI27dvY9SoUcV2kSMi0ndcVUVERLLo1cZxIiLSfywcREQkCwsHERHJwsJBRESysHAQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJAsLBxERycLCQUREsrBwEBGRLCwcREQkCwsHERHJwsJBRESysHAQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJAsLBxERycLCQUREsrBwEBGRLCwcREQkCwsHERHJwsJBRESysHAQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJAsLBxERycLCQUREsrBwEBGRLCwcREQki2F1B6hst2/fR1GRqO4YRET/CAqFAUxN68jq89IVjqIiwcJBRFSFuKqKiIhkYeEgIiJZWDiIiEgWFg4iIpKFhYOIiGRh4SAiIllYOIj+AU6dOoGwsBk4depEdUch0t1xHCkpKQgODkZOTg5MTEwQERGBpk2barXJysrC9OnToVar8ejRI3Tq1AmffvopDA1fusNNiGSJitqElJTLePgwD87O7as7Dv3L6WyJIzQ0FH5+fti7dy/8/PwQEhJSrM0333wDW1tbxMbGYseOHTh//jz27dunq4hEeisv76HWLVF10knhyMrKQmJiIjw9PQEAnp6eSExMRHZ2tlY7AwMD3L9/H0VFRSgoKEBhYSGsrKx0EZGIiMpJJ+uA1Go1rKysoFQqAQBKpRKWlpZQq9UwMzOT2o0bNw4TJkxAt27dkJeXh2HDhsHFxUXWtMzN61ZqdiJ9oFQaSLcWFvWqOQ392+nVxoM9e/bAzs4O3333He7fv4/AwEDs2bMHffv2Lfc4srJyea4qeuloNEK6vXnzXjWnoZeJQmEg+we3TlZVWVtbIyMjAxqNBgCg0WiQmZkJa2trrXaRkZHo378/FAoF6tWrh169euHo0aO6iEhEROWkk8Jhbm4Oe3t7xMXFAQDi4uJgb2+vtZoKABo1aoRDhw4BAAoKCnD48GG0aNFCFxGJiKicdLZX1cyZMxEZGQl3d3dERkYiLCwMABAYGIhz584BAD755BOcPHkSXl5eGDBgAJo2bYq3335bVxHpKTxugIhKo7NtHLa2toiKiio2fPXq1dL/r732GtatW6erSFQGHjdARKXhkeNUIh43QESlYeEgIiJZWDiIiEgWFg4iIpKFhYOIiGRh4SAiIllYOIiISBYWDiIikoWFg4iIZGHhICIiWVg4iIhIFhYOIiKShYWDiIhkYeEgIiJZWDhIb+nLNUH0JYc+4LwgQM+uOU70NH25Joi+5NAHnBcE6LBwpKSkIDg4GDk5OTAxMUFERASaNm2q1ebjjz/GhQsXpPsXLlzAsmXL0Lt3b13FJD2iL9cE0Zcc+oDzggAdFo7Q0FD4+fnB29sbMTExCAkJwYYNG7TafPHFF9L/ycnJGDFiBFxdXXUVkYiIykEn2ziysrKQmJgIT09PAICnpycSExORnZ1dap8tW7bAy8sLxsbGuohIRETlpJPCoVarYWVlBaVSCQBQKpWwtLSEWq0usX1BQQFiY2MxePBgXcQjIiIZ9HLj+P79+2FjYwN7e3vZfc3N61ZBon8fpdJAurWwqPevzaAvOfQhgz7loOqlk8JhbW2NjIwMaDQaKJVKaDQaZGZmwtrausT20dHRFV7ayMrKRVGReJG4BECjEdLtzZv3/rUZ9CWHPmTQpxxUeRQKA9k/uHWyqsrc3Bz29vaIi4sDAMTFxcHe3h5mZmbF2t64cQMnT56El5eXLqIREf1jVddxNTo7AHDmzJmIjIyEu7s7IiMjERYWBgAIDAzEuXPnpHbbtm1Dz5490aBBA11FIyL6R4qK2oSkpPOIitqk0+nqbBuHra0toqKiig1fvXq11v2xY8fqKhIR0T9adR1Xw1OOEBGRLCwcREQkCwsHERHJwsJBRESysHAQEZEsLBxERBXwb742iV6ecoToZdegvjGMa9Qod/sXOdVHQX4+7twtkNWHnu/ffG0SFg6iamBcowYWTP+g3O1zbmVKt3L6AcBH4SsBsHBUtn/ztUm4qoqIiGRh4SAiIllYOIiISBYWDiIikoWFg4iIZGHheMq/eb9sIqLy4u64T3lZ98uu36AGahgby+pT0eMG8gsKcPdOvqxpEdE/CwvHU17W/bJrGBvj3XWTZPXJuHtTupXTd/17iwCwcBC9zLiqioiIZNFZ4UhJSYGvry/c3d3h6+uL1NTUEtvt2rULXl5e8PT0hJeXF27duqWriEREVA46W1UVGhoKPz8/eHt7IyYmBiEhIdiwYYNWm3PnzmHp0qX47rvvYGFhgXv37sFY5rp5IiKqWjpZ4sjKykJiYiI8PT0BAJ6enkhMTER2drZWu/Xr12PkyJGwsLAAANSrVw81ZJwIjoiIqp5OljjUajWsrKygVCoBAEqlEpaWllCr1TAzM5PaXbp0CY0aNcKwYcPw4MED9OnTB2PHjoWBgUG5p2VuXrfCOV/kDKT0fypr3unL66EvOV7Ey/aa6AN9mBfVlUGv9qrSaDS4cOEC1q1bh4KCAowaNQo2NjYYMGBAuceRlZWLoiJRwekL6fbmzXsVGseLOnXqBGJjt8HLa2Cl7RKs6zd1Zc07fXg9qioHX5OKq4rPSEXow7yojAwKhYHsH9w6WVVlbW2NjIwMaDQaAI8LRGZmJqytrbXa2djYoG/fvjA2NkbdunXRu3dvnD17VhcR9UZU1CYkJZ1HVNSm6o5CpJf4Gal+Oikc5ubmsLe3R1xcHAAgLi4O9vb2WqupgMfbPuLj4yGEQGFhIY4cOYKWLVvqIqLeeFmPJSGqLPyMVD+d7Y47c+ZMREZGwt3dHZGRkQgLCwMABAYG4ty5cwCAfv36wdzcHB4eHhgwYACaN2+OIUOG6CoiERGVg862cdja2iIqKqrY8NWrV0v/KxQKTJ8+HdOnT9dVLCIikolHjhMRkSwsHEREJAsLBxERycLCQUREsujVAYD0cjOpZwyjmuU/hcyLHBVb+DAfOfcKig1vUL8WjGvIe9tXNEdB/iPcuZsna1q6ZNqgFgyNdTMvHhU8wu07+jsvSB4WDtIZo5o1sGv4e+Vu/+BGhnQrpx8AeGxYB5RQOIxrGGLujC2yxpWdlSvdyun7yRz93pXc0NgQfyz/RVafgv//5V9wJ09W37bj3pQ1HdJvXFVFRESysHAQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJIuswrF79+4Sh+/Zs6dSwhARkf6TVThmzJhR4vCQkJBKCUNERPqvXEeOX7lyBQAghJD+f/oxY2Pjyk9GRER6qVyFo0+fPjAwMIAQAn369NF6rA8TOKQAAB92SURBVGHDhhg/fvxzx5GSkoLg4GDk5OTAxMQEERERaNq0qVabJUuWYNOmTbC0tAQAODs7IzQ0tJxPhYiIdKFchSM5ORkA4O/vj8jIyApNKDQ0FH5+fvD29kZMTAxCQkKwYcOGYu0GDBiAoKCgCk2DiIiqnqxtHF9++SXu3LmjNezOnTvIyMgos19WVhYSExPh6ekJAPD09ERiYiKys7NlxiUiouomq3B8+OGHuHHjhtawGzduPHdVlVqthpWVFZRKJQBAqVTC0tISarW6WNudO3fCy8sLI0eOxOnTp+XEIyIiHZB1WvWUlBTY2dlpDbOzs8Ply5crJczQoUMxZswYGBkZISEhAePGjcOuXbtgampa7nGYm9et8PRf5PoPlUUfMrwofcmtDzkqK4NSqdC6ra4cL6Ly5kXlf0aKNIVQKI10kqOsaRVqimAk4zV+oWvWyJzW02QVDnNzc6SlpaFJkybSsLS0NJiYmJTZz9raGhkZGdBoNFAqldBoNMjMzIS1tbVWOwsLC+n/rl27wtraGn///Tc6duxY7oxZWbkoKhLlbv80jUZItzdv3qvQOF5UVWTQ9ZdGabn1IYc+ZKhIDlUjM1xW56CZddmfNTk59GVeyFVVn5FDcTNl9cm7ny3dyunb3XNmme+Lj7b9Wu5x3czNk27l9AOABQN74ObNe1AoDGT/4JZVbgYPHowJEybg4MGDuHjxIn7++WdMnDgRPj4+ZfYzNzeHvb094uLiAABxcXGwt7eHmZmZVrunt5UkJSXh2rVreP311+VEJHopWZnUQRf7V2FlUqe6oxDJW+IYPXo0DA0NERERgRs3bsDa2hpDhgzBe+89/+psM2fORHBwMJYvX4769esjIiICABAYGIiJEyeiTZs2WLBgAc6fPw+FQgEjIyN88cUXWkshRERU/WQVDoVCgVGjRmHUqFGyJ2Rra4uoqKhiw1evXi39/6SYEBGR/pJ9zfGEhATs3LkT2dnZ+Oabb3Du3Dnk5uaiS5cuVZGPiIj0jKxtHBs3bsTMmTPRtGlTHD9+HABQs2ZNLFq0qErCERGR/pFVOL777jusW7cOo0ePhkLxuGuzZs2QkpJSJeGIiEj/yCoc9+/fl3ahNTB4vP/wo0ePYGQkb/9nIiL655JVODp06IBVq1ZpDduwYQM6depUqaGIiEh/ydo4/umnn2LMmDGIiorC/fv34e7ujjp16mDlypVVlY+IiPRMuQtHUVERLl26hE2bNuGvv/7CtWvXYG1tDUdHR2l7BxERvfzKXTgUCgXGjRuH06dPw9HREY6OjlWZi4iI9JTsbRxnzpypqixERPQPIGsbh42NDQIDA9G7d2+88sor0p5VADBp0qRKD0dERPpHVuHIz8+Hm5sbADz34k1ERPRyKnfh0Gg0eOWVVzB27FgYGxtXZaZKUa9+TdSsoZvz6z/ML8S9uw9LfMy0gTEMjWtUeQYAeFSQj9t3CmT1KY2BkULrlqiqNGhQE8bG5f+svshnpKCgEHfulPxZpfIrd+FQKpX44YcfMGHChKrMU2lq1jCC38ffy+pz69bjc+TfuHVPVt9NXwzDPZT8ZjQ0roGTX5T/pJD5tzOkWzn9AMDl4zUAKqdwNHC0wr2kW6hn37BSxkdUGmNjI3z11Vflbn/79m3pVk4/AJgyZQpQymeVyk/Wz0lvb2/88MMPVZWF9EitRvVg2ed11GpU/VeOIyL9Imsbx9mzZxEZGYlvv/222Mbx77+X9+ueiIj+mWQVjrfffhtvv/12VWUhIqJ/AFmFY+DAgVWVg4iI/iFk7zITHR2N4cOHw93dHcOHD0d0dHS5+qWkpMDX1xfu7u7w9fVFampqqW0vX76Mtm3b8oqARER6SNYSx4oVK7B9+3aMHDkSNjY2uH79OtasWYPMzEyMHTu2zL6hoaHw8/ODt7c3YmJiEBISgg0bNhRrp9FoEBoaKh0vQkRE+kVW4YiKisLGjRvx6quvSsO6desGf3//MgtHVlYWEhMTsW7dOgCAp6cnZs+ejezsbJiZmWm1XbVqFd588008ePAADx48kBOPqEoYKo20bon+7WQVjry8vGJf9CYmJnj4sOz9otVqNaysrKBUKgE8PibE0tISarVaa3zJycmIj4/Hhg0bsHz5cjnRJObmdSvU70XJPRCpquhDDn3IAFRejmaNOiJNfQZNrNtVW4YXpQ859CEDoB859CEDUPEcsgqHq6srpk6diilTpsDGxgbXrl3D119/jW7dulVo4k8rLCzEZ599hvDwcKnAVERWVi6KioTOX5ibN++VOFwfcuhDBn3JUZEMDU2boKFpk0rLUNEcL4Lvi7Jz6EOG6sqhUBjI/sEtq3CEhIRg1qxZ6N+/PzQaDQwNDfHWW2/h008/LbOftbU1MjIyoNFooFQqodFokJmZKV2G9vETuIn09HSMHj0aAHD37l0IIZCbm4vZs2fLelJERFR1ZBWOunXr4osvvsC8efNw+/ZtmJqalusiTubm5rC3t0dcXBy8vb0RFxcHe3t7rdVUNjY2OHr0qHR/yZIlePDgAYKCguREJCKiKiZrd9zt27cjOTkZCoUC5ubmUCgUSE5Oxvbt25/bd+bMmYiMjIS7uzsiIyMRFhYGAAgMDMS5c+cqlp6IiHRO1hLHokWLihWJJ2fMHTBgQJl9bW1tERUVVWz46tWrS2z/TzmZIhHRv42sJY7c3FzUrau9EaVevXq4e/dupYYiIiL9Jatw2NraYu/evVrDfvrpJ9ja2lZqKCIAMFIYaN1S9athaKx1S/9OslZVTZ06FaNHj8bu3bvRuHFjpKen4/Dhw1i1alVV5aN/sa71TXDi3l20r1e/uqPQ/9e31Zs4+Pdh9GzRpbqjUDWSVTjat2+PuLg4xMXFQa1Ww9HRETNmzNDarZaosjSrWQvNataq7hj0lFbWLdDKukV1x6BqJqtwAI93m31yrEVJvLy8EBsb+0KhiIhIf1X6BaWvXr1a2aMkIiI9UumF4+mrAhIR0cun0gsHERG93Fg4iIhIlkovHEKIyh4lERHpkRcqHA8fPkRBQYHWsFmzZr1QICIi0m+yCkdERATOnj0LAPjll1/QsWNHdOjQAT///LPUxsvLq3ITEhGRXpFVOGJjY9GixeODf5YtW4b58+djxYoVWLhwYZWEIyIi/SP70rG1atXC7du3ceXKFbi7uwMArl27ViXhiIhI/8gqHE2bNsWOHTuQnp6Orl27AgCys7NRs2bNKglHRET6R1bhCA0Nxdy5c2FkZIQ5c+YAAOLj46UiQkREL7/nFo7jx4+jQ4cOAID79+9j0qRJAB6vnrp27RosLCwwaNCg504oJSUFwcHByMnJgYmJCSIiItC0aVOtNtHR0Vi/fj0UCgWKiorg4+OD4cOHV+BpERFRVXlu4QgLC0NcXBwAYMaMGTAwMCh2rIaBgQEOHDhQ5nhCQ0Ph5+cHb29vxMTEICQkBBs2bNBq4+7ujkGDBsHAwAC5ubnw8vJCx44d0bJlS7nPi4ioStUwVmrdVgelcQ2tW115buF4UjQAaO12K0dWVhYSExOxbt06AICnpydmz56N7OxsmJmZSe2evrrgw4cPUVhYyHNfEZFeerNLExw+eRVdXBpVW4ZXOvVA5unDsHTS7fVRZJ9WvSLUajWsrKygVD6uzEqlEpaWllCr1VqFAwAOHDiABQsWID09HVOmTIGdnZ0uIhIRyaJqZgZVM7PnN6xC9ZuqUL+pSufT1UnhkKN3797o3bs3rl+/jg8//BDdu3dHs2bNyt3f3Lzu8xtVAQuLetUy3WfpQw59yADoRw59yADoRw59yADoRw59yABUPIdOCoe1tTUyMjKg0WigVCqh0WiQmZlZ5pUDbWxs0KZNG/zyyy+yCkdWVi6KioTOX5ibN++VOFwfcuhDBn3JoQ8Z9CWHPmTQlxz6kKG6cigUBrJ/cOvk7Ljm5uawt7eXtpfExcXB3t6+2GqqS5cuSf9nZ2fj6NGjUKl0vxhGRESl09mqqpkzZyI4OBjLly9H/fr1ERERAQAIDAzExIkT0aZNG2zevBkJCQkwNDSEEAL+/v7o1q2briISEVE56Kxw2NraIioqqtjw1atXS/9/8sknuopDREQVxAs5PcVAaaR1Wx1qGCq0bolIm6GhodYt6R6/nZ5S18YZRnVfQV0b52rL8J/mpmhmWhP/aW5abRmI9JlKpYKZmRm3f1Yjluyn1GjQGDUaNK7WDPYWtWFvUbtaMxDpM0tLS1haWlZ3jH81LnEQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJAsLBxERycLCQUREsrBwEBGRLCwcREQkCwsHERHJwsJBRESysHAQEZEsLBxERCSLzk6rnpKSguDgYOTk5MDExAQRERFo2rSpVptly5Zh165dUCgUMDIywuTJk+Hq6qqriEREVA46KxyhoaHw8/ODt7c3YmJiEBISgg0bNmi1cXR0xMiRI1GrVi0kJyfD398f8fHxqFmzpq5iEhHRc+hkVVVWVhYSExPh6ekJAPD09ERiYiKys7O12rm6uqJWrVoAADs7OwghkJOTo4uIRERUTjpZ4lCr1bCysoJSqQQAKJVKWFpaQq1Ww8zMrMQ+27dvx2uvvYZXXnlF1rTMzeu+cN6KsLCoVy3TfZY+5NCHDIB+5NCHDIB+5NCHDIB+5NCHDEDFc+jlpWOPHTuGRYsWYe3atbL7ZmXloqhI6PyFuXnzXonD9SGHPmTQlxz6kEFfcuhDBn3JoQ8ZqiuHQmEg+we3TlZVWVtbIyMjAxqNBgCg0WiQmZkJa2vrYm1Pnz6NadOmYdmyZWjWrJku4hERkQw6KRzm5uawt7dHXFwcACAuLg729vbFVlOdPXsWkydPxuLFi+Hg4KCLaEREJJPOjuOYOXMmIiMj4e7ujsjISISFhQEAAgMDce7cOQBAWFgYHj58iJCQEHh7e8Pb2xsXLlzQVUQiIioHnW3jsLW1RVRUVLHhq1evlv6Pjo7WVRwiIqogHjlORESysHAQEZEsLBxERCQLCwcREcnCwkFERLKwcBARkSwsHEREJAsLBxERycLCQUREsrBwEBGRLCwcREQkCwsHERHJwsJBRESysHAQEZEsLBxERCQLCwcREcmis8KRkpICX19fuLu7w9fXF6mpqcXaxMfHY9CgQWjdujUiIiJ0FY2IiGTQWeEIDQ2Fn58f9u7dCz8/P4SEhBRr07hxY8yZMwfvv/++rmIREZFMOikcWVlZSExMhKenJwDA09MTiYmJyM7O1mrXpEkT2Nvbw9BQZ1e0JSIimXRSONRqNaysrKBUKgEASqUSlpaWUKvVupg8ERFVopfup725ed1qma6FRb1qme6z9CGHPmQA9COHPmQA9COHPmQA9COHPmQAKp5DJ4XD2toaGRkZ0Gg0UCqV0Gg0yMzMhLW1daVPKysrF0VFQucvzM2b90ocrg859CGDvuTQhwz6kkMfMuhLDn3IUF05FAoD2T+4dbKqytzcHPb29oiLiwMAxMXFwd7eHmZmZrqYPBERVSKd7VU1c+ZMREZGwt3dHZGRkQgLCwMABAYG4ty5cwCAEydOoHv37li3bh3+97//oXv37vjtt990FZGIiMpBZ9s4bG1tERUVVWz46tWrpf/bt2+PQ4cO6SoSERFVAI8cJyIiWVg4iIhIFhYOIiKShYWDiIhkYeEgIiJZWDiIiEgWFg4iIpKFhYOIiGRh4SAiIllYOIiISBYWDiIikoWFg4iIZGHhICIiWVg4iIhIFhYOIiKShYWDiIhk0VnhSElJga+vL9zd3eHr64vU1NRibTQaDcLCwuDm5oY+ffqUeOEnIiKqXjorHKGhofDz88PevXvh5+eHkJCQYm1iY2ORnp6Offv2YfPmzViyZAmuXr2qq4hERFQOOikcWVlZSExMhKenJwDA09MTiYmJyM7O1mq3a9cu+Pj4QKFQwMzMDG5ubtizZ48uIhIRUTnp5JrjarUaVlZWUCqVAAClUglLS0uo1WqYmZlptbOxsZHuW1tb48aNG7KmpVAYSP83NK3zgskrNt1nGdc3r/YcDeualThclxkAoFbD6p8XDUxqV3sGAKhvUv3zwqhezWrPAAD169ev9hw1aplUewYAMK1dQ6c5yspSGgMhhKiCPFr+/PNPBAUFYefOndIwDw8PzJ8/Hw4ODtIwLy8vzJkzB46OjgCA1atXIyMjA59++mlVRyQionLSyaoqa2trZGRkQKPRAHi8ETwzMxPW1tbF2l2/fl26r1ar8corr+giIhERlZNOCoe5uTns7e0RFxcHAIiLi4O9vb3WaioA6Nu3L6KiolBUVITs7Gzs378f7u7uuohIRETlpJNVVQBw6dIlBAcH4+7du6hfvz4iIiLQrFkzBAYGYuLEiWjTpg00Gg1mzZqFhIQEAEBgYCB8fX11EY+IiMpJZ4WDiIheDjxynIiIZGHhICIiWVg4iIhIFhYOIiKShYWDiIhkYeEAsHXrVkycOLFcbTMyMhAQEAAXFxcMGjRIb6b7448/ok+fPnBzc8OsWbNQVFRU5Zn279+PQYMGwdPTE/369cPatWsrNM0XzZGUlISBAwfC29sb/fr1w2effYaCggKdZngiPz8f/fr1e+H3RkVzHD16FG3btoW3tze8vb3h4+Oj8wzA49dk2LBh8PDwgIeHB3799VedZtiwYYM0D7y9veHs7Izw8PAXziA3R1FRET7//HN4eHjAy8sL77//PjIyMnSaQaPRYM6cOfD09IS7uzsiIiLwojvT6uRcVS+T2rVrY9KkScjNzcXixYv1YrpXrlzB0qVLsX37dpiYmCAwMBA7duzAgAEDqjSThYUFVqxYASsrK9y7dw+DBg2Co6Mj2rdvX6XTfdbrr7+OzZs3w9jYGEVFRZg0aRL+97//Yfjw4TrNAQALFy5E27ZtkZycrPNpP2Fra4utW7dW2/QfPHiA8ePH46uvvkK7du3w6NEj3Lt3T6cZhg8fLr3+hYWF6N69u3SSVV36+eefcfbsWezYsQOGhoYIDw/HihUrMHPmTJ1l2LJlCy5fvoxt27bBwMAAY8aMwa5du9CvX78Kj/OlLBx5eXkICgrCxYsXYWhoiNdffx09evTAL7/8In3pbt26Vev+vXv3MGbMGKSnp6Nhw4aYP38+rKysio27Xr16aN++PY4ePao30927dy/c3NykI/F9fHywdetWDBgwoEoztW3bViufra0trl27VmLhqMocNWv+34n6Hj16hIcPH0KhKL4wXZUZAODEiRNITU3Fe++9V2bhqOoc5VGVGeLi4uDi4oJ27doBAAwNDWFqalpt8+HgwYOwsLBAmzZtdD4vAKCgoAD5+flQKBS4f/8+GjVqpNMMycnJ6NKlC4yMjAAAXbt2RWxsLAvHs+Lj43H//n3s2rULAHDnzh0cOHCgzD4nT57E9u3b0axZMyxduhRz5syRvURRXdN99qzCNjY2UKvVOs106dIlnDlzBmFhYSU+XtU5MjIyMHr0aKSnp6NHjx54++23dZrhwYMHmDt3LlasWFHiRcp0lQMAUlNTMXDgQBgaGsLPzw8DBw7UaYYnX36BgYHIzMyEg4MDgoKC0KBBA53Ohyeio6PLXHVYlTl69eqFY8eOoVu3bqhZsyaaNWtW4rWIqjKDg4MDtm7dCj8/PwCPVzHfvXu3zHE/z0u5jaNly5a4dOkSwsLCsHv3bhgbGz+3j4uLC5o1awbg8S/2I0eO/GOmW92ZMjMzMW7cOISGhpb6q6uqc1hZWSEmJgYJCQkoLCzETz/9pNMMX3zxBfz8/Mq1FFCVORwcHPDrr79i27ZtWLBgAZYtW4bff/9dpxmKiopw5MgRzJkzB9u2bUOdOnUwb948nWZ4IjMzE0eOHEH//v1LbVOVOc6fP49Lly7h0KFDSEhIQMuWLXU+LwYNGoQOHTrgnXfeQWBgIBwdHWFo+GLLDC9l4WjcuDHi4uLQtWtXHD58GN7e3lAqlVobjPPz88s1rg8//FDawJabm6uX0332rMLXr1+Xzjxc1ZmysrLw3nvvYdSoUXjrrbdK7aureVO7dm14eHggNjZWpxlOnjyJ5cuXo1evXvjoo4/w119/wcvLq8S+VZmjbt26qFevnjQdNzc3nDp1SqcZrK2t0alTJ1haWkKhUMDLywvnzp3TaYYntm/fjh49ehQ7oaqucmzbtg2dO3dGvXr1oFAo0L9//xJXN1dlBoVCgcmTJyMmJgbff/89zMzMYGtrW65xlealXFV148YNNGjQAG5ubujatStcXV3RuHFjXLhwQdrbZu/evVoXjzl16hRSU1PRtGlTREdHo3PnzgCAZcuW6f103d3dMWzYMIwfPx4mJiaIioqSNgRWZabbt2/jvffew7Bhw567905V5rhy5QqsrKxgbGyMgoICHDhwACqVSqcZni5UR48eRURERKkbqKsyR2ZmJiwsLGBgYICcnBwkJCRg0qRJOs3w1ltvITAwUCpkhw4dgp2dnU4zPBEdHY1PPvmkxMd0kaNRo0ZISEjAu+++CyMjI/z6669o0aKFTjPk5+ejoKAA9erVw/Xr1/HDDz9gyZIlZc6T53kpC8eFCxfw1VdfAXi82Dx69Gg4OzujS5cu6NevHywtLdGyZUvcvHlT6uPs7IyIiAikpaVJG5pKotFo0LNnTxQUFCA3Nxfdu3eHj48PJkyYUG3Tbdy4McaNGyet1+/atau0aF6VmVatWoXU1FRs3rwZmzdvBvB4b5bBgwfr9DU5deoU1qxZAwMDAxQVFaFDhw4YN26cTjPIUZU59u3bhx9++AGGhobQaDQYMGAA3NzcdJrBxsYGgYGBGDp0KAwMDNCoUSPMnj1bpxmAx9sAHjx4gG7dupXapqpzDBs2DH///Tf69+8PQ0NDWFtb63xe3Lt3DwEBAdIOI1OnTtW6gF5F8Oy4REQky0u5jYOIiKoOCwcREcnCwkFERLKwcBARkSwsHEREJAsLB1E5ODk54cqVK2W2uX79OpycnKDRaHSU6vlOnDgBd3f3Uh8PDg7GwoULdZiIXgYsHETPCAgIQFRUlNaw06dPo3HjxmX2s7GxwenTp6FUKqsyHgDAzs4OaWlpz23Xvn177N27t8rz0L/LS3kAIFFFCCFe+DoFRP8GXOKgl0KvXr2wcuVKeHh4oEOHDpg+fTry8/Nx584dfPDBB+jcuTM6dOiADz74ADdu3JD6BQQEYOHChRg6dCjatm2LadOm4cSJE5g1axacnJwwa9YsANq/8B8+fIh58+ahZ8+ecHFxwTvvvIOHDx/i6tWrsLOzw6NHj6Rxf/XVVxgyZAicnZ0xduxY5OTkSNOeOHEiunbtChcXF+kI4yeCg4MRFhaG0aNHw8nJCT4+PkhPTwfw+GhkAPD29oaTk5N0RtWSHD16FN27d5fuJyYmYuDAgXBycsJ///vfcp//iOhpLBz00oiNjcW3336Ln376CSkpKVi+fDmKioowaNAgHDx4EAcPHkSNGjWkYvBETEwMZs+ejVOnTmHevHlo3749QkJCcPr06RJPgR0REYHz58/jf//7H44dO4Zp06aVeP0P4PFJ9ubOnYv4+HgYGhri888/lx7r3r079u7di8OHD6NVq1aYOnWqVt9du3Zh/PjxOH78OF577TVpW8T3338v5T59+jQ8PDzKNX8KCgqkE+AdO3YMffv2xb59+8rVl+hpLBz00hg2bBisra1hYmKCsWPHYufOnTA1NYW7uztq1aqFunXrYuzYsTh+/LhWv4EDB6JFixYwNDSULnZTmqKiIkRHR2PGjBmwsrKCUqmEs7NzqafB9vb2hkqlkq7guGfPHmnj+ZAhQ1C3bl0YGxtjwoQJSE5O1rpSnpubm3QK7P79+yMpKemF5s8ff/yBwsJCjBgxAkZGRujbt2+pFzciKgu3cdBL48mp5IHHG6ozMzORl5eH8PBw/Pbbb7hz5w4A4P79+9BoNNJG7Kf7Pc/t27eRn5//3A3lpWUqLCzE7du3YWpqioULF2LPnj3Izs6Wllhu374tnRa9YcOGUt+aNWviwYMH5c5ZkszMTFhZWcHAwEArE5FcXOKgl8aTqx4Cj3eNtbS0xNq1a5GSkoIff/wRp06dklbzPL0R/Okv0ucxNTVFjRo1nrtrbkmZ1Go1jIyMYGpqitjYWBw4cADr1q3DyZMn8fPPPxfLVdksLCyQkZGhNY2nr+NCVF4sHPTS2LRpE27cuIGcnBx888038PDwwP3791GjRg3Ur18fOTk5WLp06XPH07Bhw1ILg0KhwODBgxEeHo6MjAxoNBqcPn1aumbCs3bs2IGLFy8iLy8PixYtgru7O5RKJe7fvw9jY2OYmpoiLy8PCxYskPVcy8pYmnbt2sHQ0BAbNmxAYWEh9u3bV+IFloieh4WDXhqenp4YOXIk3Nzc8Nprr2Hs2LEYMWIE8vPz0blzZ/j6+sLV1fW54xk+fDj27t2LDh06aG3MfiIoKAgqlQpDhgxBx44d8eWXX2pdqe1p3t7eCA4ORteuXVFQUIAZM2YAAAYMGAAbGxu4urqiX79+aNeunaznOn78eAQHB6N9+/Zl7lX1NGNjYyxZsgTbtm1Dx44dsWvXLvTp00fWdIkAXo+DXhK9evXC559/jjfeeKO6o0gCAgLQv3//514dkeifhkscREQkC/eqIvqH++abb7By5cpiw11cXLBmzZpqSEQvO66qIiIiWbiqioiIZGHhICIiWVg4iIhIFhYOIiKShYWDiIhkYeEgIiJZ/h/uTmovhrIlcQAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "  participant_id  trial_index stimulus   response  response_time  \\\n",
              "0          sub-1            1        C       None            NaN   \n",
              "1          sub-1            2        B       None            NaN   \n",
              "2          sub-1            3        C      match       1.682183   \n",
              "3          sub-1            4        E      match       0.854319   \n",
              "4          sub-1            5        F  non-match       0.315646   \n",
              "\n",
              "  expected_response  is_correct  \n",
              "0              None           1  \n",
              "1              None           1  \n",
              "2             match           1  \n",
              "3         non-match           0  \n",
              "4         non-match           1  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-03c850f2-7310-4a35-bfbc-c7b2f5b7a3bf\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>participant_id</th>\n",
              "      <th>trial_index</th>\n",
              "      <th>stimulus</th>\n",
              "      <th>response</th>\n",
              "      <th>response_time</th>\n",
              "      <th>expected_response</th>\n",
              "      <th>is_correct</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>sub-1</td>\n",
              "      <td>1</td>\n",
              "      <td>C</td>\n",
              "      <td>None</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>sub-1</td>\n",
              "      <td>2</td>\n",
              "      <td>B</td>\n",
              "      <td>None</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>sub-1</td>\n",
              "      <td>3</td>\n",
              "      <td>C</td>\n",
              "      <td>match</td>\n",
              "      <td>1.682183</td>\n",
              "      <td>match</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>sub-1</td>\n",
              "      <td>4</td>\n",
              "      <td>E</td>\n",
              "      <td>match</td>\n",
              "      <td>0.854319</td>\n",
              "      <td>non-match</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>sub-1</td>\n",
              "      <td>5</td>\n",
              "      <td>F</td>\n",
              "      <td>non-match</td>\n",
              "      <td>0.315646</td>\n",
              "      <td>non-match</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-03c850f2-7310-4a35-bfbc-c7b2f5b7a3bf')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-03c850f2-7310-4a35-bfbc-c7b2f5b7a3bf button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-03c850f2-7310-4a35-bfbc-c7b2f5b7a3bf');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ],
      "source": [
        "def generate_mock_nback_dataset(N=2,\n",
        "                                n_participants=10,\n",
        "                                n_trials=32,\n",
        "                                stimulus_choices=list('ABCDEF'),\n",
        "                                response_choices=['match', 'non-match']):\n",
        "  \"\"\"Generate a mock dataset for the N-back task.\"\"\"\n",
        "\n",
        "  n_rows = n_participants * n_trials\n",
        "\n",
        "  participant_ids = sorted([f'sub-{pid}' for pid in range(1, n_participants + 1)] * n_trials)\n",
        "  trial_indices = list(range(1, n_trials + 1)) * n_participants\n",
        "  stimulus_sequence = np.random.choice(stimulus_choices, n_rows)\n",
        "\n",
        "  responses = np.random.choice(response_choices, n_rows)\n",
        "  response_times = np.random.exponential(size=n_rows)\n",
        "\n",
        "  df = pd.DataFrame({\n",
        "      'participant_id': participant_ids,\n",
        "      'trial_index': trial_indices,\n",
        "      'stimulus': stimulus_sequence,\n",
        "      'response': responses,\n",
        "      'response_time': response_times\n",
        "  })\n",
        "\n",
        "  # mark matchig stimuli\n",
        "  _nback_stim = df['stimulus'].shift(N)\n",
        "  df['expected_response'] = (df['stimulus'] == _nback_stim).map({True: 'match', False: 'non-match'})\n",
        "\n",
        "  df['is_correct'] = (df['response'] == df['expected_response'])\n",
        "\n",
        "  # we don't care about burn-in trials (trial < N)\n",
        "  df.loc[df['trial_index'] <= N, 'is_correct'] = True\n",
        "  df.loc[df['trial_index'] <= N, ['response', 'response_time', 'expected_response']] = None\n",
        "\n",
        "  return df\n",
        "\n",
        "\n",
        "# ========\n",
        "# now generate the actual data with the provided function and plot some of its features\n",
        "mock_nback_data = generate_mock_nback_dataset()\n",
        "mock_nback_data['is_correct'] = mock_nback_data['is_correct'].astype(int)\n",
        "\n",
        "sns.displot(data=mock_nback_data, x='response_time')\n",
        "plt.suptitle('response time distribution of the mock N-back dataset', y=1.01)\n",
        "plt.show()\n",
        "\n",
        "sns.displot(data=mock_nback_data, x='is_correct')\n",
        "plt.suptitle('Accuracy distribution of the mock N-back dataset', y=1.06)\n",
        "plt.show()\n",
        "\n",
        "sns.barplot(data=mock_nback_data, y='is_correct', x='participant_id')\n",
        "plt.suptitle('Accuracy distribution of the mock N-back dataset', y=1.06)\n",
        "plt.show()\n",
        "\n",
        "mock_nback_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "w4DNTzLps8Ud"
      },
      "source": [
        "## Implementation scheme\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "Q-8tXk_Bs8Uh"
      },
      "source": [
        "### Environment\n",
        "\n",
        "The following cell implments N-back envinronment, that we later use to train a RL agent on human data. It is capable of performing two kinds of simulation:\n",
        "- rewards the agent once the action was correct (i.e., a normative model of the environment).\n",
        "- receives human data (or mock data if you prefer), and returns what participants performed as the observation. This is more useful for preference-based RL."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "execution": {},
        "id": "oF0nWN9Hs8Un"
      },
      "outputs": [],
      "source": [
        "class NBack(dm_env.Environment):\n",
        "\n",
        "  ACTIONS = ['match', 'non-match']\n",
        "\n",
        "  def __init__(self,\n",
        "               N=2,\n",
        "               episode_steps=32,\n",
        "               stimuli_choices=list('ABCDEF'),\n",
        "               human_data=None,\n",
        "               seed=1,\n",
        "               ):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      N: Number of steps to look back for the matched stimuli. Defaults to 2 (as in 2-back).\n",
        "      episode_steps\n",
        "      stimuli_choices\n",
        "      human_data\n",
        "      seed\n",
        "\n",
        "    \"\"\"\n",
        "    # N back =2\n",
        "    self.N = N\n",
        "    self.current_episode = 0\n",
        "    # Number of episode steps = 32\n",
        "    self.episode_steps = episode_steps\n",
        "    # Stimuli choices = 0,1,2,3,4,5\n",
        "    self.stimuli_choices = stimuli_choices\n",
        "    # Stimuli - vector of size 32\n",
        "    self.stimuli = np.empty(shape=episode_steps)  # will be filled in the `reset()`\n",
        "    \n",
        "    self.n_s = len(self.stimuli_choices)\n",
        "    self.prob = 0.4 # 0.5 * (self.n_s - 2)/ (self.n_s - 1)\n",
        "\n",
        "\n",
        "    self._reset_next_step = True\n",
        "\n",
        "    # whether mimic humans or reward the agent once it responds optimally.\n",
        "    if human_data is None:\n",
        "      self._imitate_human = False\n",
        "      self.human_data = None\n",
        "      self.human_subject_data = None\n",
        "    else:\n",
        "      self._imitate_human = True\n",
        "      self.human_data = human_data\n",
        "      self.human_subject_data = None\n",
        "\n",
        "    # Action History is a plank vector\n",
        "    self._action_history = []\n",
        "\n",
        "  def reset(self):\n",
        "    self._reset_next_step = False\n",
        "    self._current_step = 0\n",
        "    self._action_history.clear()\n",
        "\n",
        "    # generate a random sequence instead of relying on human data\n",
        "    # generates an entire random sequence of 32 stimuli [................................]\n",
        "    if self.human_data is None:\n",
        "      # self.stimuli = np.random.choice(self.stimuli_choices, self.episode_steps)\n",
        "      # FIXME This is a fix for acme & reverb issue with string observation. Agent should be able to handle strings\n",
        "      self.stimuli = np.random.choice(len(self.stimuli_choices), self.episode_steps).astype(np.float32)\n",
        "      #self.stimuli = np.random.choice(len(self.stimuli_choices)).astype(np.float32)\n",
        "      #print(\"self.stimuli\", self.stimuli)\n",
        "\n",
        "      self.stimuli=np.ones(self.episode_steps)\n",
        "      # match prob will be slightly higher than non-match prob\n",
        "      for i in range(self.episode_steps):\n",
        "          if i<self.N:\n",
        "            self.stimuli[i]=np.random.choice(self.n_s)\n",
        "          else:\n",
        "            rand=np.random.random()\n",
        "            if rand < self.prob:\n",
        "              self.stimuli[i]=self.stimuli[i-self.N]\n",
        "            else:\n",
        "              self.stimuli[i]=np.random.choice(self.n_s)\n",
        "\n",
        "   \n",
        "    else:\n",
        "      # randomly choose a subject from the human data and follow her trials and responses.\n",
        "      # FIXME should we always use one specific human subject or randomly select one in each episode?\n",
        "      self.human_subject_data = self.human_data.query('participant_id == participant_id.sample().iloc[0]',\n",
        "                                                engine='python').sort_values('trial_index')\n",
        "      self.stimuli = self.human_subject_data['stimulus'].to_list()\n",
        "      self.stimuli = np.array([ord(s) - ord('A') + 1 for s in self.stimuli]).astype(np.float32)\n",
        "\n",
        "    # return the observation \n",
        "    return dm_env.restart(self._observation())\n",
        "\n",
        "\n",
        "  def _episode_return(self):\n",
        "    if self._imitate_human:\n",
        "      return np.mean(self.human_subject_data['response'] == self._action_history)\n",
        "    else:\n",
        "      return 0.0\n",
        "\n",
        "  def step(self, action: int):\n",
        "    if self._reset_next_step:\n",
        "      return self.reset()\n",
        "\n",
        "    agent_action = NBack.ACTIONS[action]\n",
        "    #print(\"Step action\" , agent_action)\n",
        "\n",
        "    if self._imitate_human:\n",
        "      # if it was the same action as the human subject, then reward the agent\n",
        "      human_action = self.human_subject_data['response'].iloc[self._current_step]\n",
        "      step_reward = 0. if (agent_action == human_action) else -1.\n",
        "    else:\n",
        "      # assume the agent is rationale and doesn't want to reproduce human, reward once the response it correct\n",
        "      # gives a reward based on the action chosen by the agent but it has access to all the stimuli \n",
        "      #print(\"Current Stimuli for reward\", self.stimuli[self._current_step])\n",
        "      expected_action = 'match' if (self.stimuli[self._current_step] == self.stimuli[self._current_step - self.N]) else 'non-match'\n",
        "      step_reward = 0. if (agent_action == expected_action) else -1.\n",
        "\n",
        "      # print(\"Current Step\", self._current_step)\n",
        "      # print(\" Stimulus current step\",self.stimuli[self._current_step])\n",
        "      # print(\" Stimulus two steps back\",self.stimuli[self._current_step - self.N])\n",
        "      # print(\"Agent action\", agent_action)\n",
        "      # print(\"Expected action\", expected_action)\n",
        "      # print(\"step_reward\",step_reward)\n",
        "      # print(\"\\n\")\n",
        "\n",
        "    self._action_history.append(agent_action)\n",
        "\n",
        "    self._current_step += 1\n",
        "\n",
        "    # Check for termination.\n",
        "    if self._current_step == self.stimuli.shape[0]:\n",
        "      self._reset_next_step = True\n",
        "      # self.current_episode += 1\n",
        "\n",
        "      # df=pd.DataFrame()\n",
        "      # # print(len(self.stimuli),len(self._action_history))\n",
        "      # df['episode']=np.ones(self.episode_steps)*self.current_episode\n",
        "      # df['stimuli']=self.stimuli\n",
        "      # df['action']=self._action_history\n",
        "      # df['reward']=self._reward_history\n",
        "      # if self.current_episode == 1:\n",
        "      #   mode='w'\n",
        "      #   header=True\n",
        "      # else:\n",
        "      #   mode='a'\n",
        "      #   header=False\n",
        "      # df.to_csv('data_lr.csv',header=header,index_label='trial',mode=mode)\n",
        "\n",
        "      # we are using the mean of total time step rewards as the episode return\n",
        "      return dm_env.termination(reward=self._episode_return(),\n",
        "                                observation=self._observation())\n",
        "    else:\n",
        "      return dm_env.transition(reward=step_reward,\n",
        "                               observation=self._observation())\n",
        "\n",
        "  def observation_spec(self):\n",
        "    return dm_env.specs.BoundedArray(\n",
        "        shape=self.stimuli[0].shape,\n",
        "        dtype=self.stimuli[0].dtype,\n",
        "        name='nback_stimuli', minimum=0, maximum=len(self.stimuli_choices)+ 1)\n",
        "\n",
        "  def action_spec(self):\n",
        "    return dm_env.specs.DiscreteArray(\n",
        "        num_values=len(NBack.ACTIONS),\n",
        "        dtype=np.int32,\n",
        "        name='action')\n",
        "\n",
        "  def _observation(self):\n",
        "\n",
        "    # agent observes only the current trial\n",
        "    #print(\"\\nCurrent Step\",self._current_step)\n",
        "\n",
        "    if self._current_step ==  self.episode_steps:\n",
        "      obs = self.stimuli[0]\n",
        "    else:\n",
        "      obs = self.stimuli[self._current_step]\n",
        "    # print(\"Observation agent sees\",obs)\n",
        "    # agents observe stimuli up to the current trial\n",
        "    #obs = self.stimuli[:self._current_step+1].copy()\n",
        "    #obs = np.pad(obs,(0, len(self.stimuli) - len(obs)))\n",
        "  \n",
        "    return obs\n",
        "\n",
        "  def plot_state(self):\n",
        "    \"\"\"Display current state of the environment.\n",
        "\n",
        "     Note: `M` mean `match`, and `.` is a `non-match`.\n",
        "    \"\"\"\n",
        "    stimuli = self.stimuli[:self._current_step - 1]\n",
        "    actions = ['M' if a=='match' else '.' for a in self._action_history[:self._current_step - 1]]\n",
        "    return HTML(\n",
        "        f'<b>Environment ({self.N}-back):</b><br />'\n",
        "        f'<pre><b>Stimuli:</b> {\"\".join(map(str,map(int,stimuli)))}</pre>'\n",
        "        f'<pre><b>Actions:</b> {\"\".join(actions)}</pre>'\n",
        "    )\n",
        "\n",
        "  @staticmethod\n",
        "  def create_environment():\n",
        "    \"\"\"Utility function to create a N-back environment and its spec.\"\"\"\n",
        "\n",
        "    # Make sure the environment outputs single-precision floats.\n",
        "    environment = wrappers.SinglePrecisionWrapper(NBack())\n",
        "\n",
        "    # Grab the spec of the environment.\n",
        "    environment_spec = specs.make_environment_spec(environment)\n",
        "\n",
        "    return environment, environment_spec"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "g2ZP20Bys8Uw"
      },
      "source": [
        "### Define a random agent\n",
        "\n",
        "For more information you can refer to NMA-DL W3D2 Basic Reinforcement learning."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "execution": {},
        "id": "r9PaTWJUs8Ux"
      },
      "outputs": [],
      "source": [
        "class RandomAgent(acme.Actor):\n",
        "\n",
        "  def __init__(self, environment_spec):\n",
        "    \"\"\"Gets the number of available actions from the environment spec.\"\"\"\n",
        "    self._num_actions = environment_spec.actions.num_values\n",
        "\n",
        "  def select_action(self, observation):\n",
        "    \"\"\"Selects an action uniformly at random.\"\"\"\n",
        "    action = np.random.randint(self._num_actions)\n",
        "    return action\n",
        "\n",
        "  def observe_first(self, timestep):\n",
        "    \"\"\"Does not record as the RandomAgent has no use for data.\"\"\"\n",
        "    pass\n",
        "\n",
        "  def observe(self, action, next_timestep):\n",
        "    \"\"\"Does not record as the RandomAgent has no use for data.\"\"\"\n",
        "    pass\n",
        "\n",
        "  def update(self):\n",
        "    \"\"\"Does not update as the RandomAgent does not learn from data.\"\"\"\n",
        "    pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "Wzxz-ccQs8Uy"
      },
      "source": [
        "### Initialize the environment and the agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "execution": {},
        "id": "gGGsAEtVs8Uy",
        "outputId": "2dd78be5-4c09-4555-e477-adb7f860b8d1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "actions:\n",
            " DiscreteArray(shape=(), dtype=int32, name=action, minimum=0, maximum=1, num_values=2)\n",
            "observations:\n",
            " BoundedArray(shape=(), dtype=dtype('float32'), name='nback_stimuli', minimum=0.0, maximum=7.0)\n",
            "rewards:\n",
            " Array(shape=(), dtype=dtype('float32'), name='reward')\n"
          ]
        }
      ],
      "source": [
        "env, env_spec = NBack.create_environment()\n",
        "agent = RandomAgent(env_spec)\n",
        "\n",
        "print('actions:\\n', env_spec.actions)\n",
        "print('observations:\\n', env_spec.observations)\n",
        "print('rewards:\\n', env_spec.rewards)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "R7h6KZEXs8U0"
      },
      "source": [
        "### Run the loop\n",
        "\n",
        "For more details, see NMA-DL W3D2."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "WTCqp0-ls8U0"
      },
      "outputs": [],
      "source": [
        "# fitting parameters\n",
        "n_episodes = 25000\n",
        "n_total_steps = 0\n",
        "log_loss = False\n",
        "n_steps = n_episodes * 32\n",
        "all_returns = []\n",
        "\n",
        "# main loop\n",
        "for episode in range(n_episodes):\n",
        "  episode_steps = 0\n",
        "  episode_return = 0\n",
        "  episode_loss = 0\n",
        "\n",
        "  start_time = time.time()\n",
        "\n",
        "  timestep = env.reset() \n",
        "\n",
        "  # Make the first observation.\n",
        "  agent.observe_first(timestep)\n",
        "\n",
        "  # Run an episode\n",
        "  while not timestep.last():\n",
        "\n",
        "    # DEBUG\n",
        "    # print(timestep)\n",
        "\n",
        "    # Generate an action from the agent's policy and step the environment.\n",
        "    #print(\"get observation\", timestep.observation)\n",
        "    action = agent.select_action(timestep.observation)\n",
        "    #action = 0\n",
        "    #print(\"get action:\", action)\n",
        "    timestep = env.step(action)\n",
        "    #print(\"take a step\")\n",
        "\n",
        "    # Have the agent observe the timestep and let the agent update itself.\n",
        "    agent.observe(action, next_timestep=timestep)\n",
        "    #print(\"timestep\", timestep)\n",
        "    agent.update()\n",
        "  \n",
        "\n",
        "    # Book-keeping.\n",
        "    episode_steps += 1\n",
        "    n_total_steps += 1\n",
        "    episode_return += timestep.reward\n",
        "\n",
        "    if log_loss:\n",
        "      episode_loss += agent.last_loss\n",
        "\n",
        "    if n_steps is not None and n_total_steps > n_steps:\n",
        "      break\n",
        "\n",
        "  # Collect the results and combine with counts.\n",
        "  steps_per_second = episode_steps / (time.time() - start_time)\n",
        "  result = {\n",
        "      'episode': episode,\n",
        "      'episode_length': episode_steps,\n",
        "      'episode_return': episode_return,\n",
        "  }\n",
        "  if log_loss:\n",
        "    result['loss_avg'] = episode_loss/episode_steps\n",
        "\n",
        "  all_returns.append(episode_return)\n",
        "\n",
        "  #display(env.plot_state())\n",
        "  # Log the given results.\n",
        "  #print(result)\n",
        "\n",
        "  if n_steps is not None and n_total_steps >= n_steps:\n",
        "    break\n",
        "\n",
        "#clear_output()\n",
        "\n",
        "# Histogram of all returns\n",
        "plt.figure()\n",
        "sns.histplot(all_returns, stat=\"density\", kde=True, bins=12)\n",
        "plt.xlabel('Return [a.u.]')\n",
        "plt.ylabel('Density')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "SfyTD1dRs8U2"
      },
      "source": [
        "**Note:** You can simplify the environment loop using [DeepMind Acme](https://github.com/deepmind/acme)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "eAmAnuJss8U5"
      },
      "outputs": [],
      "source": [
        "# init a new N-back environment\n",
        "env, env_spec = NBack.create_environment()\n",
        "\n",
        "# DEBUG fake testing environment.\n",
        "# Uncomment this to debug your agent without using the N-back environment.\n",
        "# env = fakes.DiscreteEnvironment(\n",
        "#     num_actions=2,\n",
        "#     num_observations=1000,\n",
        "#     obs_dtype=np.float32,\n",
        "#     episode_length=32)\n",
        "# env_spec = specs.make_environment_spec(env)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "tc_38V9ns8U_"
      },
      "outputs": [],
      "source": [
        "def dqn_make_network(action_spec: specs.DiscreteArray) -> snt.Module:\n",
        "  return snt.Sequential([\n",
        "      snt.Flatten(),\n",
        "      snt.nets.MLP([512, 512, action_spec.num_values]),\n",
        "  ])\n",
        "\n",
        "# construct a DQN agent\n",
        "agent = dqn.DQN(\n",
        "    environment_spec=env_spec,\n",
        "    network=dqn_make_network(env_spec.actions),\n",
        "    epsilon=[0.5],\n",
        "    learning_rate = 0.001,\n",
        "    min_replay_size = 32,\n",
        "    logger=loggers.InMemoryLogger(),\n",
        "    checkpoint=False,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "5uas7TK5s8VA"
      },
      "source": [
        "Now, we run the environment loop with the DQN agent and print the training log."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {},
        "id": "PlJEn19gs8VB"
      },
      "outputs": [],
      "source": [
        "# training loop\n",
        "loop = EnvironmentLoop(env, agent, logger=loggers.InMemoryLogger())\n",
        "loop.run(n_episodes)\n",
        "\n",
        "# print logs\n",
        "logs_dqn = pd.DataFrame(loop._logger._data)\n",
        "logs_dqn.tail()\n",
        "env.plot_state()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "logs_dqn.tail()"
      ],
      "metadata": {
        "id": "l_eYdFkXDYRI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "DRQN AGENT"
      ],
      "metadata": {
        "id": "-ZGNBSMaCbgS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#n_episodes = 10000\n",
        "\n",
        "from acme.agents.tf import r2d2\n",
        "def r2d2_make_network(action_spec: specs.DiscreteArray) -> snt.Module:\n",
        "  return snt.DeepRNN([\n",
        "            snt.Flatten(),\n",
        "            snt.LSTM(2),\n",
        "            snt.nets.MLP([512, 512, action_spec.num_values])\n",
        "            ])\n",
        "\n",
        "agent_r2d2 = r2d2.R2D2(\n",
        "    environment_spec=env_spec,\n",
        "    network=r2d2_make_network(env_spec.actions),\n",
        "    learning_rate = 0.001,\n",
        "    burn_in_length=10,\n",
        "    trace_length=2,\n",
        "    replay_period=10,\n",
        "    epsilon=[0.05],\n",
        "    logger=loggers.InMemoryLogger(),\n",
        "    min_replay_size = 32,\n",
        "    checkpoint=False,\n",
        ")\n",
        "\n",
        "loop = EnvironmentLoop(env, agent_r2d2, logger=loggers.InMemoryLogger())\n",
        "loop.run(n_episodes)\n",
        "\n",
        "# print logs\n",
        "logs_r2d2 = pd.DataFrame(loop._logger._data)\n",
        "logs_r2d2.tail()"
      ],
      "metadata": {
        "id": "YRsWvYv4CaoU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def moving_average(interval, window_size):\n",
        "    window = np.ones(int(window_size)) / float(window_size)\n",
        "    return np.convolve(interval, window, 'same')  \n",
        "r2d2_ma=moving_average(logs_r2d2['episode_return'],100)\n",
        "dqn_ma=moving_average(logs_dqn['episode_return'],100)\n",
        "all_returns=moving_average(all_returns,100)\n",
        "\n",
        "\n",
        "plt.plot(r2d2_ma)\n",
        "plt.plot(dqn_ma)\n",
        "#plt.plot(all_returns)\n",
        "\n",
        "plt.ylabel(\"episode_reward\")\n",
        "plt.xlabel(\"episode (N_steps per episode = 32)\")\n",
        "plt.legend(['DRQN','DQN','RANDOM'])"
      ],
      "metadata": {
        "id": "PD6frHOSCiXm"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Project Mohinga",
      "provenance": [],
      "toc_visible": true
    },
    "kernel": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}