Mohinga_Project_RL_Mult(1).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "Azi_bLWn6mAR"
      },
      "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": "t0JJoEeC6mAb"
      },
      "source": [
        "<p align='center'><img src='https://github.com/NeuromatchAcademy/widgets/blob/master/sponsors.png?raw=True'/></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "9HbuVnWO6mAc"
      },
      "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": "-hzSA9mE6mAd"
      },
      "source": [
        "---\n",
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "execution": {},
        "id": "zigNT_hI6mAd",
        "outputId": "9e35aa11-7aed-4892-9d74-d37b9d7e0ad2",
        "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": 3,
      "metadata": {
        "execution": {},
        "id": "IOdC2K-56mAk"
      },
      "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\n",
        "from acme.agents.tf import r2d2\n",
        "from tqdm import tqdm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "execution": {},
        "id": "VIvUNa5t6mAl"
      },
      "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": "-R0grYI-6mAm"
      },
      "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": "Jr2eTAmn6mAo"
      },
      "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": "hi23aJh46mAp"
      },
      "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": "0BCw1SqR6mAq"
      },
      "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": "H7aDZqad6mAr"
      },
      "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": "markdown",
      "metadata": {
        "execution": {},
        "id": "mvgbdQuK6mAs"
      },
      "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": 5,
      "metadata": {
        "execution": {},
        "id": "ufg4-znW6mAs"
      },
      "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",
        "               prob = None\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",
        "    self.N = N\n",
        "    self.episode_steps = episode_steps\n",
        "    self.stimuli_choices = stimuli_choices\n",
        "    self.stimuli = np.empty(shape=episode_steps)  # will be filled in the `reset()`\n",
        "    self.n_s = len(self.stimuli_choices)\n",
        "    if prob is None:\n",
        "      self.prob = 0.5 * (self.n_s - 2)/ (self.n_s - 1)\n",
        "    else:\n",
        "      self.prob = prob\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",
        "    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",
        "    if self.human_data is None:\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",
        "    else:\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 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",
        "\n",
        "    if self._imitate_human:\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",
        "      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",
        "    self._action_history.append(agent_action)\n",
        "\n",
        "    self._current_step += 1\n",
        "\n",
        "    if self._current_step == self.stimuli.shape[0]:\n",
        "      self._reset_next_step = True\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.shape,\n",
        "        dtype=self.stimuli.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",
        "    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(prob = None):\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(prob = prob))\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": "NQTnbj5V6mAt"
      },
      "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": 6,
      "metadata": {
        "execution": {},
        "id": "_h1bWf8D6mAu"
      },
      "outputs": [],
      "source": [
        "class RandomAgent(acme.Actor):\n",
        "\n",
        "  def __init__(self, environment_spec, action = None):\n",
        "    \"\"\"Gets the number of available actions from the environment spec.\"\"\"\n",
        "    self._num_actions = environment_spec.actions.num_values\n",
        "    self.action = action\n",
        "\n",
        "  def select_action(self, observation):\n",
        "    \"\"\"Selects an action uniformly at random.\"\"\"\n",
        "    if self.action is not None: \n",
        "      return self.action\n",
        "    return np.random.randint(self._num_actions)\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",
      "source": [
        "## Define Learnable Agents"
      ],
      "metadata": {
        "id": "_X_RIcItvaVU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def dqn_make_network(action_spec: specs.DiscreteArray) -> snt.Module:\n",
        "  return snt.Sequential([\n",
        "      snt.Flatten(),\n",
        "      snt.nets.MLP([128, 128, action_spec.num_values]),\n",
        "  ])\n",
        "\n",
        "def r2d2_make_network(action_spec: specs.DiscreteArray) -> snt.Module:\n",
        "  return snt.DeepRNN([\n",
        "            snt.Flatten(),\n",
        "            snt.LSTM(hidden_size = 10),\n",
        "            snt.nets.MLP([128, 128, action_spec.num_values])\n",
        "            ])"
      ],
      "metadata": {
        "id": "T6A2pa9Zvcpz"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "135ZABGG6mAw"
      },
      "source": [
        "### Get reward distribution and mean reward of the agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "execution": {},
        "id": "VPawgcGr6mAx"
      },
      "outputs": [],
      "source": [
        "def get_reward_distribution(agent, env, n_episodes = 25000,  episode_length = 32, log_loss = False):\n",
        "  # main loop\n",
        "  n_total_steps = 0\n",
        "  n_steps = n_episodes * episode_length\n",
        "  all_returns = []\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",
        "      # Generate an action from the agent's policy and step the environment.\n",
        "      action = agent.select_action(timestep.observation)\n",
        "      timestep = env.step(action)\n",
        "\n",
        "      # Have the agent observe the timestep and let the agent update itself.\n",
        "      agent.observe(action, next_timestep=timestep)\n",
        "      agent.update()\n",
        "\n",
        "      # Book-keeping.\n",
        "      episode_steps += 1\n",
        "      \n",
        "      n_total_steps += 1\n",
        "      print(n_total_steps)\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",
        "  return all_returns, np.mean(all_returns), np.std(all_returns)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training and Evaluation Script"
      ],
      "metadata": {
        "id": "DMxo_yt5uN5d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train_and_eval(env, agent, train , n_episodes,  episode_length, log_loss = False):\n",
        "  if train:\n",
        "    print(\"here\")\n",
        "    loop = EnvironmentLoop(env, agent, logger=loggers.InMemoryLogger())\n",
        "    loop.run(n_episodes)\n",
        "\n",
        "    return pd.DataFrame(loop._logger._data)\n",
        "  \n",
        "  else:\n",
        "    all_returns, mean_return, std_return = get_reward_distribution(agent, env, n_episodes = 25000,  episode_length = 32, log_loss = False)\n",
        "    clear_output()\n",
        "    print(f'Mean Return: {mean_return} | Standard Deviation: {std_return}')\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()\n",
        "\n",
        "    return None"
      ],
      "metadata": {
        "id": "_cxysHVguQOG"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "execution": {},
        "id": "_EGCq1_c6mAu"
      },
      "source": [
        "### Initialize the environments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "execution": {},
        "id": "tuD4BchT6mAv",
        "outputId": "aa98fe0a-fcc2-4773-a83c-3bada32d5e0a",
        "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=(32,), 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_balanced, env_spec_balanced = NBack.create_environment()\n",
        "env_unbalanced, env_spec_unbalanced = NBack.create_environment(prob = 0.)\n",
        "\n",
        "print('actions:\\n', env_spec_balanced.actions)\n",
        "print('observations:\\n', env_spec_balanced.observations)\n",
        "print('rewards:\\n', env_spec_balanced.rewards)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Define Agents"
      ],
      "metadata": {
        "id": "ukAvPj94hwOJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_agent = RandomAgent(env_spec_balanced)\n",
        "match_agent = RandomAgent(env_spec_balanced, 0)\n",
        "unmatch_agent = RandomAgent(env_spec_balanced, 1)\n",
        "\n",
        "dqn_agent_balanced = dqn.DQN(\n",
        "    environment_spec=env_spec_balanced,\n",
        "    network=dqn_make_network(env_spec_balanced.actions),\n",
        "    epsilon=[0.5],\n",
        "    learning_rate = 0.0001,\n",
        "    min_replay_size = 32,\n",
        "    logger=loggers.InMemoryLogger(),\n",
        "    checkpoint=False,\n",
        ")\n",
        "\n",
        "dqn_agent_unbalanced = dqn.DQN(\n",
        "    environment_spec=env_spec_unbalanced,\n",
        "    network=dqn_make_network(env_spec_unbalanced.actions),\n",
        "    epsilon=[0.5],\n",
        "    learning_rate = 0.0001,\n",
        "    min_replay_size = 32,\n",
        "    logger=loggers.InMemoryLogger(),\n",
        "    checkpoint=False,\n",
        ")\n",
        "\n",
        "drqn_agent_balanced = r2d2.R2D2(\n",
        "    environment_spec=env_spec_balanced,\n",
        "    network=r2d2_make_network(env_spec_balanced.actions),\n",
        "    learning_rate = 0.0001,\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",
        "drqn_agent_unbalanced = r2d2.R2D2(\n",
        "    environment_spec=env_spec_unbalanced,\n",
        "    network=r2d2_make_network(env_spec_unbalanced.actions),\n",
        "    learning_rate = 0.0001,\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",
        ")"
      ],
      "metadata": {
        "id": "XcvCnGfDhxIC"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n_episodes = 25000\n",
        "episode_length = 32"
      ],
      "metadata": {
        "id": "x4yOQ6aY6P9K"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Random Agent"
      ],
      "metadata": {
        "id": "tI_K_1zDyaz7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Balanced N-Back"
      ],
      "metadata": {
        "id": "SURbpHPeydLy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_balanced, random_agent, False, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "7KqHQnnXw-oX",
        "outputId": "cec74efb-0f2c-4f5a-a7f0-c334f0b40b84"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -15.49108 | Standard Deviation: 2.7835517659278404\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Un-Balanced N-Back"
      ],
      "metadata": {
        "id": "sPQgEENVyf8O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_unbalanced, random_agent, False, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "4eDnhTWYyBbM",
        "outputId": "11f7b62d-6b81-4fb1-b31c-c42a168840d4"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -15.53572 | Standard Deviation: 2.7719603318951016\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Matching Agent"
      ],
      "metadata": {
        "id": "KHlNxPbMyhzS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Balanced N-Back"
      ],
      "metadata": {
        "id": "uhblKbMfyjmh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_balanced, match_agent,False, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "iSwcN1cHyEJf",
        "outputId": "443e4f02-5743-46b2-da20-18edefdeb0ce"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -16.18816 | Standard Deviation: 2.733721970939986\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Un-Balanced N-Back"
      ],
      "metadata": {
        "id": "JO5ZCYnHylS0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_unbalanced, match_agent,False, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "AfdlslUeyEg3",
        "outputId": "4398d1c9-d03f-41a2-d919-a1366a0cd4ef"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -25.82376 | Standard Deviation: 2.072713068034261\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEMCAYAAADqG+D0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZgUhZ3//66qrj6ne86eobkRFEYBwaAGDfGCzKjAqL+wIJE8iYpGjWxMYmRNAkKiWdxN3MiK+wuJup4xbFxRRCREV0GNJ4I63M4wMMx99X1V1/eP7qqZnumjqma6p3vm83oeH4fuqurPHF3v/tyMKIoiCIIgCEIl7HAbQBAEQeQnJCAEQRCEJkhACIIgCE2QgBAEQRCaIAEhCIIgNEECQhAEQWiCBIQgCILQhG64DcgmXV0eRCK50fZSWlqAjg73cJuRlFy3D8h9G3PdPiD3bcx1+4CRbSPLMigutiR9flQJSCQi5oyAAMgpWxKR6/YBuW9jrtsH5L6NuW4fMHptpBAWQRAEoQkSEIIgCEITJCAEQRCEJkhACIIgCE2QgBAEQRCaIAEhCIIgNEECQhAEQWhiVPWBECMLQYjAbrdm9DWCIQE93d6MvgZB5CskIETewnEstr50IKOvsfqG8zN6fYLIZyiERRAEQWiCBIQgCILQBAkIQRAEoQkSEIIgCEITJCBE3nGisQcvvnkMQh5MQCWIkQxVYRF5x3tfNuOtTxtx1oTi4TaFIEY15IEQeUd7tx8A8N+v1cIfDA+zNQQxeiEBIfKO9h4fJlYUwB8Io77ZNdzmEMSohQSEyCsiooj2Hj8qJxWj2GaELyAMt0kEMWohASHyih53EKFwBGWFJhRbDQiESEAIYrggASHyivYeHwDAXmREkdWIQJAEhCCGCxIQIq+QEuhlhSaU2Izwk4AQxLBBAkLkFW0xD6Ss0IhiqwHBkABRpH4QghgOSECIvKK9249Cix56nkOx1QARQCAUGW6zCGJUQgJC5BXtPT6UFRkBAEW26P8pkU4QwwMJCJFXtHX7YS80AQCKrQYAoEQ6QQwTJCBE3iBEIuhyBWQPpCTmgfjJAyGIYYEEhMgbPL4wIqKIQkvU8ygqIA+EIIYTEhAi47R2efHCnmMIC4NLdnv8IQCA2RidAWo06KDjGBIQghgmSECIjPPeF83428encKKxZ1DX8fqjgxMtxt4h0gaegz9EAxUJYjjI2jj3uro6rF27Ft3d3SgqKsKmTZswefLkuGMee+wx7Ny5EyzLgud53HPPPViwYAEAYO3atXjvvfdQXBwd4V1dXY077rgjW+YTg+BkbODhl/WdmD5R+wh2T0xAzEZefsyo58gDIYhhImsCsn79eqxcuRI1NTXYvn071q1bh6effjrumNmzZ+Pmm2+GyWTC4cOHcdNNN2Hfvn0wGqPJ0ttuuw033XRTtkwmhoj6lqiA1NZ34YZvar+ONxbC6u+BOL3BQdlHEIQ2shLC6ujoQG1tLRYvXgwAWLx4MWpra9HZ2Rl33IIFC2AyRUs0p0+fDlEU0d3dnQ0TiQzR7Q6gxx2EzaJHXZNTFgEtJPJADHqOxpkQxDCRFQFpampCRUUFOI4DAHAch/LycjQ1NSU95+WXX8bEiRMxZswY+bEnn3wSS5YswZ133okTJ05k3G5i8Ej7OhbNGw9RBA43aP9A4A3EBMTQ64EY9RzCgghhkAl6giDUk5MrbT/88EP8/ve/xxNPPCE/ds8998But4NlWbz88su49dZbsWfPHlmUlFBaWpAJczVjt1uH24SUDIV97Z82gmGAby+cjtfeP4n6VjeqLj1L07VEhoGe5zDWUSg/ZjFHS3l5Aw+TITN/zoP5OeT67xjIfRtz3T5g9NqYFQFxOBxoaWmBIAjgOA6CIKC1tRUOh2PAsfv378e9996LLVu24Kyzem80FRUV8tfXXXcdfvOb36C5uRnjxo1TbEdHhxuRSG4M3rPbrWhry91tekNlX+1XHRhTYobPE0B5kQmnm12ar9ve5YXZwMnn2+1WRIRo+KrH6UPErB+0vYnQam+u/46B3Lcx1+0DRraNLMuk/OCdlRBWaWkpKisrsWPHDgDAjh07UFlZiZKSkrjjDh48iHvuuQePPvoozjvvvLjnWlpa5K/37t0LlmXjRIXITU62uDBpTPSTj9WiR49He8Lb6w/D0if/AQA8F/0TDgu58cGAIEYTWQthPfDAA1i7di22bNkCm82GTZs2AQBWr16NNWvWYNasWdiwYQP8fj/WrVsnn/fwww9j+vTpuO+++9DR0QGGYVBQUIDHH38cOl1ORuCIGBFRRI87iLLCaBWdzcyjpdOr+Xpef0huIpTQ6aICEgpTDoQgsk3W7sBTp07Ftm3bBjy+detW+eu//vWvSc9/6qmnMmEWkUF8gejokQJTNLRkNesHVXLr8YdRGpt/JdHrgQxOQLz+MI6e7sbZ4wphMfHpTyAIgjrRiczh8kZLdq2xG7LNokcwFNHc+Of1hwd4IPwQeCCdLj/eOXAGDS1unOnwaL4OQYw2SECIjOGOCUiBOSYgsSS3Vi/EG0gQwop5IKFBeCAnGp0Aot6M1GtCEER6SECIjOHyRYXCKgmIJfp/LQISiYjwBYS4HhAA0HEMACA8CA/EFwjDZtGjwMzL87YIgkgPCQiRMWQPJBbCssY8EJdHfTe61ETYvwqLYRjoOGZQHogkTGajTp74SxBEekhAiIzh8kk5kKhwDCaE1X+Ue194Has5iR6JiAiEBBgNHCxGHXwBIWd6hQgi1yEBITKG2xsCr2Oh56N/ZlIoy6VBQHpHuQ+skNJxLEJhbTd9XzB6XZNBJ8/YkrwdgiBSQwJCZAyXLwirmQfDRPMUep6DUc/BqSWEJQ9SHFoPxB+IVoSZDDpYYvkVyoMQhDJIQIiM4faG5PyHhE1jL4gnwSh3CZ5jNZfxSt6GSc/J16Y8CEEog1q5iYzh8oXkHhAJq4WHU8M4E2+CUe4SOo5FSNB20/f3CWFxLAOWZcgDIQiFkAdCZAy3N4SCfgMObWa9phxISg9Ex2ou4/UFBPA6FjqOBcMwsBh01AtCEAohASEyRkIPxKyH06stB6LjGLnzvC+8jkVIiEAU1SfSfYEwTIbelQBmo25QS68IYjRBAkJkhLAQgS8QlrvQJWwWHi5vEBGVN3tfIAyzQScn5Pui41iIIiBoKL/1BcIw6Xu9GrNRR1VYBKEQEhAiI7h98XOwJGxmPUQR8PjUfcr3BQUYkyyM4qVudA2VWL6gELeISq+LbjhUK3AEMRohASEygtSFbu2XA7HKzYTqBMTfz1Poi9aR7mEhglA4EhfCknpWaDw8QaSHBITICFIXev8yXqmPw6cyTOQLCjDqE68v1rpUSuoBMfYRJnm6b4gEhCDSQQJCZAQphNU/B2LW2KznD4aT7jzX6oEEw1EBMfB9PBAdF/ccQRDJIQEhMoJUqts/ByJ5IN6A2hCWEg9ErYBEj+9b2SV9HaQQFkGkhQSEyAhSL0X/7X6SB+LT4IEkTaJr9EBCCQRETwJCEIohASEygi8Qlhv0+iKFodSWyqbKgWhdKiUJiL6vgEhJ9BCFsAgiHSQgREaIVk0NvOFHRYVRJSBytVRSAdG2VErKc/T1QGQxIg+EINJCAkJkhGR9GwzDwGzQqQph+YMDq6X6X1PLUqlQOAI+NsKk77X0OpZCWAShABIQIiNER4QkvuGbjLwqD0QaeGg0JPZAgKjnoLaMNxiOgOcTj0ahKiyCSA8JCJERfElCWABgNnDqBETa2ZHEAwGilVhqq7BC4Uhc/kNCz3MIUh8IQaSFBITICL6AkNQDURvC8inyQBj1AhISEg5n1Ou07xchiNEECQiREYY2hJU6BwIAnNYQVrLpviQgBJEWEhAiI/iDyWdXmQ2cqk50X5+tgcnQaQ5hDbymnnIgBKEIEhBiyBFFEb6AkDTkZDbwqmZhKfFA1IawRFGMVmEl8kD42EReDePhCWI0kTUBqaurw/Lly1FVVYXly5ejvr5+wDGPPfYYrr32WixZsgQ33HAD9u7dKz/n8/nwox/9CIsWLUJ1dTXeeuutbJlOqCQYiiAiinLXeX9MRh2C4YjiMJFf8kCGsAorLIgQgaQ5EIB6QQgiHVnbib5+/XqsXLkSNTU12L59O9atW4enn3467pjZs2fj5ptvhslkwuHDh3HTTTdh3759MBqN+NOf/oSCggL87W9/Q319Pb7zne9g9+7dsFgs2foWCIX0Jr2TJ9EBqVtdn/CYvijzQNSFsEKxEFXCKix5nAmFsQgiFVnxQDo6OlBbW4vFixcDABYvXoza2lp0dnbGHbdgwQKYTCYAwPTp0yGKIrq7uwEAr7/+OpYvXw4AmDx5MmbOnIl33nknG+YTKkmXs+grIIquFwxDz7Ng2YHbCCV0HKNqK2GiQYoSvDyRlzwQgkhFVgSkqakJFRUV4LjoG5PjOJSXl6OpqSnpOS+//DImTpyIMWPGAADOnDmDcePGyc87HA40Nzdn1nBCEz6pbyNFCAtQPg/LHxRS9oAAvSNIlHohvXOwEifRAdoJQhDpyFoISw0ffvghfv/73+OJJ54Y0uuWlhYM6fUGi91uHW4TUqLVvsYuHwDAUWFLeI2xruiod97AK3oNEQwspsTHWiyG6P9jmw71ep38dSo6YjbYrEb5GvLrxUabMDFRGszvKdd/x0Du25jr9gGj18asCIjD4UBLSwsEQQDHcRAEAa2trXA4HAOO3b9/P+69915s2bIFZ511lvz42LFj0djYiJKSEgBRr+biiy9WZUdHhztnKmvsdiva2lzDbUZSBmNfc2v0PL83kPAaQX/05t3U6sL4ElPa63W7/OB17IBr2e1WeDwBAIAQy1c43QEwCvaZu6TzQmF4PPHPSUMZpWO0/hxy/XcM5L6NuW4fMLJtZFkm5QfvrISwSktLUVlZiR07dgAAduzYgcrKSlkMJA4ePIh77rkHjz76KM4777y456qrq/Hiiy8CAOrr6/H5559jwYIF2TCfUIkUmkpWhaU2B5Jssm9f1IewBk7i7b2Wtum+BDHayFoZ7wMPPIBnn30WVVVVePbZZ7FhwwYAwOrVq/H5558DADZs2AC/349169ahpqYGNTU1OHLkCADglltugdPpxKJFi3D77bdj48aNKCjIrZAUEUXeNZ4sB6Jyra0/KKSswAIAnS5201coIMFwBCzLgOMGvgW0TvcliNFG1nIgU6dOxbZt2wY8vnXrVvnrv/71r0nPN5vNePTRRzNiGzG0yGW8SbwGo54Dwyhfa+sLhlPOwQL6eiDKQpShUOJBihK8Tn1nO0GMNqgTnRhyfIFo2W3/bYQS0k4QNR7IkFdhCYm70PteLxTOjXwZQeQqJCDEkOMLpL/hmww65X0ggeTrbCXkvIWKMl4+icAB2sbDE8RogwSEGHL8wXDS/IeE2ajMAwkLEYSFSNrrqQ5hhSPQpfJAaCIvQaSFBIQYcryBMMxpchZmg05RI2HvGJPU12MZBizLKK6cCgnpPRBKohNEakhAiCHHH0hfNaU0hNU7FiV9vYeaibzhJJN45WvpWCrjJYg0kIAQA6hvduK23+xBe7dP0/m+YPJlUhJm49B6IIDyibyiKCIkRJIm+QGAj5XxigqaEglitEICQgzgpbe/QlO7B5/XdaY/OAHRbYTpQli8ohyI7IGkESRAuQciRESIIsDrkg9n5HUsRJFGuhNEKkhAiDhOnOnBFzHhOHa6W9M1lFRhmY06+INC2tEysgeSRpAA5R6IJDKpciCSd+LxK+tVIYjRCAkIEcfO90+iwMTjazPKcexUj+rzRVGMjh5J4zFIz0tNh8nwy02JSjwQZaW3kleRqgpLEhc1q3cJYrRBAkLEUdfkxPlTS3HBjHJ0OP3odPpVne8PChCRPuRkVjjORPJA0s3CAgAdqyyEJXkpKT2QmLh4fOSBEEQySEAImVA4gm53EPYiE86dXAoAON6ozgtRGnIyG5UJiJQDUeSB6JSFsNR5ICQgBJEMEhBCRvI2SguNmDLWBgPPqQ5j+dJM4pWQByqmqcRSX4WlIIQlJN9GKF9L8kAohEUQSVEsIHv27EE4TG+mkUxbT7Rst6zQCI5jMXmMFSdb1O0QUOoxKB3p7guEYeC5lOtsJXQcE6uwSu2FSP0d6RoJAcBLISyCSIpiAXn00UfxjW98Axs3bsSBAwcyaRMxTLT3RD0Qe1F0yVNpoRFdLnU5ECkpnraMV2EIyx8UFFVgAcrHmYQUVGFJJb5aPRCvP4T//38Pwk0CRIxgFAvIK6+8gqeeegoGgwF33303qqqqsGXLFpw+fTqT9hFZpKPHD45lUFQQXfFabDWg2x1EREUznT/NPnQJs8K96P5gWFH+A1A+kVfKgXBccq9GN8gcyO6PTmHHvjp8UNui6XyCyAdU5UBmzJiB++67D2+//TbWr1+PXbt2YdGiRfjOd76DV155BZEINV3lM23dPpTYDHK4qKjAACEiwuVVfhP1Khw9Ij2f7gYd7SlR6oEom8gbjo1yZ5jkAsIwDDiW0dQH4guE8fdPoh+sDp3sUn0+QeQLqhdKNTQ04JVXXsErr7wChmGwZs0aOBwOPPfcc9i9ezf+8z//MxN2Elmgo8ePssLeHeXF1qgn0uXyo9CiV3QNf0BZCItlGRj1HHwxjyXp9YJhRQl0oDcklTaElWaUu3w9HQuvT30I6+3PzsDjD2Pa+EIcPtmFSERUlMMhiHxDsYA899xz2L59O06ePImrr74aDz/8MObMmSM/X1VVhUsuuSQjRhLZob3Hj9lTS+V/9wpIAJPHKLuGT66aSv+nFZ2Hld4DsRcZFb22VDmVbopuWIjIK3BTwXOsJg/k4yOtmDrOhprLpuG3z32Cky0uTHHYVF+HIHIdxQLyzjvv4Pvf/z6uuuoq6PUDP42aTCZs3rx5SI0jskcwJKDHE0RZYe/NWhKQbldA8XV8gTAMemVVUyYFWwnVeCByDiTN/CqlHohOx2rKgbR2+TBvuh3nTysDEA1jkYAQIxHFOZCLLroIV1999QDxePLJJ+Wvv/GNbwydZURW6Yj1gPQNYdnMerAMgy63OgFRmrMwKxjpHq3CUvY5h1eaRE+zzrbv9dRWYfkCYbh9IdiLTCi2GTGuzEJ5EGLEolhAHnvssYSPP/7440NmDDF8SCW8ZX3CRSzLoLBAjy41HkhQUDQ5F1C2VMofDCvaBQJADkulDWGFxZSj3PteT20fSFtsBL5UCj2xwoqmDo+qaxBEvpD2nfn+++8DAARBwD/+8Y+4Jq3Tp0/DYrFkzjoia0hhquJYCa9EsdWgTkAUDFKUMBt1aGxPfnMNhSMIC6KGEFb6PhClHkiPigo0IBq+AnoFpMRmQLcrSIl0YkSS9p3+85//HAAQDAZx//33y48zDAO73Y5f/OIXmbOOyBqu2Cdtqzk+RFlcYMAZFZ+g/SpCWOm2EvqDyneBANG1thzLpPRARFFUlwNR64H09BcQIyKiiB5PUM4pEcRIIe0788033wQA/OxnP8PDDz+ccYOI4cHpCULPszD0u/kXWw2oPal8sZQvKCi+UUpbCUVRTNiT4VMxB0si3TwsIVbim2qQogTPsQiGI9GqLQWCAwBtXT4UmHi5UbIk9rPodPpJQIgRh+IcCInHyMblDcFqGlhdV2w1wBcQFO0vB6IhLKVJb7OBhyj2Dkzsj1/FJF4JXsekrMJSMsak91qxbnSF3zsQzYFI3gcQ9UAAoFNFGJAg8oWU78yrr74ar7/+OgDgsssuS9q5+3//939DbhiRXVy+IKxmfsDjRVIprzugKJQUrcJSngORz0lwbTXbCCV0HJsyhCU9p8QDkbwOXyAMm1lZI2Vrty+uZFfupVG5V4Ug8oGU7/Rf/epX8tf/9m//lnFjiOHD5Q0lvElKSfUuVwCO0tQFExFRhD8opO1ClzD1WSpVkqBNQs6BqPBA0q21DSmYxCvB9xEQJQiRCDp6Arj43F4PxGLUQc+z5IEQI5KU78x58+bJX1900UUZN4YYPtzeIMaVDRQIW2yEidMbTHsNpYMUJcxpdoJIY07U5EB4HYtAisS3LCBKPJDYMT6FvSAdzgAiogh7n14ahmFQYjWq3uxIEPmA4hzIk08+iUOHDgEAPvvsM1x++eW48sorsX//fkXn19XVYfny5aiqqsLy5ctRX18/4Jh9+/bhhhtuwMyZM7Fp06a45zZv3oz58+ejpqYGNTU12LBhg1LTiTSIoghnEg9EEhAlAxXVVk2lm8ir9npALISVKgeiQkD42HBGb5p5XRLt/XpAJEpsBvJAiBGJ4nfmU089hW9/+9sAgN/+9rf43ve+B4vFgoceegjbtm1Le/769euxcuVK1NTUYPv27Vi3bh2efvrpuGMmTJiABx98ELt27UIwOPAT73XXXYf77rtPqcmEQgIhAaFwJGEOxGzUgWUYuBR4IL6Auhu+dFyyT/iaPBAu9V50TR6IwhBWjzv6MyqyDuylqa2nbnRi5KHYA3G5XLBarXC73Thy5AhWrVqFZcuWoa6uLu25HR0dqK2txeLFiwEAixcvRm1tLTo748tDJ02ahMrKSuh0qocEE4NA8i4KEggIyzAoMOkUeSDSDV/NKBMgvQfSv7Q4FVIOJNlWQnUeiEoB8UQFpL8nV2I1otsdgEDrDogRhuI7tcPhwKefforjx49j3rx54DgObrcbHJf+zd3U1ISKigr5WI7jUF5ejqamJpSUlCg29rXXXsO+fftgt9tx9913Y+7cuYrPBYDS0gJVx2cau9063CYAALpiI8vHOwrjbJK+LrYZEQhH0trb0OEFADgqbIq+t6LiqOAwOjbh8QzHwWTgUFGefBChxRL/ad8cu3kbjDx43cC/TZFhoONYWAvST/g1RcSYfZyi7ycsRoVp4vgiuWLRbrdi0rhCiCLA6nnYi81pr5NtcuXvMBm5bh8wem1ULCA/+9nPsGbNGuj1ejz66KMAgLfeeguzZs0acqMSsWLFCvzgBz8Az/N49913ceedd2Lnzp0oLi5WfI2ODjciEeXb9TKJ3W5FW5u6feOZoqGxGwAQCYVlm/raZ9JzaO/2pbW3uTX6vN8XVPy96XUs2ju8CY/v7PbCwHNJr2W3W+HxxOcWxFj4qsfpTxhK8/qC4HXMgPOSYdBzaO/0KPp+mtvdsJl5tLe7Zfva2lzgY9Xvx+s7wISV5VOyRS79HSYi1+0DRraNLMuk/OCtWEAuu+wy7Nu3L+6x6upqVFdXpz3X4XCgpaUFgiCA4zgIgoDW1lY4HA6lLw+73S5/femll8LhcODYsWNUHTYESBVW/ceYSNgsepxscae9jpwDURFyMhmS7wRRM1dLIt1a21BY2RwsCYsx/cRgCacnKBcd9KXvXhWCGEmoene6XC7U1dXB44mfjTR//vyU55WWlqKyshI7duxATU0NduzYgcrKSlXhq5aWFlRUVAAADh06hMbGRkyZMkWN+UQS3LH8hi1BDgQArCY9XB4lSXR1ZbyANM4k8adyjz8MiymxTcngpYm8SSqxQkIEvIKwa699vCoBSTSuRC6FVvAzJIh8QvE7/aWXXsLGjRthNpthNPbGjxmGwd///ve05z/wwANYu3YttmzZApvNJpfprl69GmvWrMGsWbPw8ccf48c//jHcbjdEUcRrr72GBx98EAsWLMDvfvc7fPnll2BZFjzP4+GHH47zSgjtuLwh8DoWBj7xjdVq5uENhNPOhPIHw2CgLultNujgS7K0yeMLyaNAlKJLs9Y2FI7AYlQuShYVAtLjDWLSmIFx5gIjD4YBnCon+xJErqNYQB555BH8/ve/x2WXXabphaZOnZqw3Hfr1q3y1/PmzcM777yT8Pz+fSHE0OHyRseYJBtVY419gnb7QigqSD4Q0OuPzsFik1wnESajDp4kjX8efxjjy4c+hKVXEcIyG3XoUbBQKyKKcHlCCUNYLMvAauLhVlAKTRD5hOJ3kiAItHFwhOJMMkhRwhoLI6ULwXgDYViM6m745hRrbT3+kCpvAegtz00awlKZAzGblHkgHl8IEVFMKCBAVITJAyFGGorf7atXr8bjjz+OO++8Eyyr/A1I5D6SB5IM6TlXmt0YXn8YZoMOhUVm6JOEw/pTUmTG0VM9A0oMw0IE/qCA8jKLqvLDVB6IEBEhRESVSXRe0TReSVwLkwmIiVc0DoYg8glVnejt7e344x//iKKiorjnaBpvfuP2heAoTd6fII8zSeeB+EMwG3XQ8xy2vnRA0Wsfb+iE0xPAH/76WVwILRCKJtYPHm2Fy5V4jtTqG84f8JiOS77WNhQroVXlgSiswnImaSKUsFn0ONmc26WeBKEWxQJC03hHLm5fCAWpQlhmZfOwvIHwgDlQ6eB1LCIiEImI4LheAQmFlHeM94VhGOg4JmESXU0XuoTFxCMYSr9UqifmXSQNYZn1irr5CSKfUCwg1G8xMpFCRRZT8j8FeR6WL7UH4vGHMVllzkK6KYeECLg+N+hgzFtQk/Due81ES6UkAVGbRAeiu0kKTMnPc3pipdBJBMSmsJKNIPIJxX/JwWAQjzzyCK666ip87WtfAxCdnvvss89mzDgi80gVUAUp+i1YhkGBmZdvksnwBsLyDVcpyZLevd6C8pLgvtcMphAQJcukJKQkfro8iNMTBMcySYsIrCqmGhNEvqD4nfTQQw/h6NGj+Pd//3c5Vn322WfjhRdeyJhxROZxKxAQIJpITzWRV4hEEAgK8oBEpcgC0i9nEdQQbpIw8JzswfRF9kBUNhIC6XeCSF3oSUuhTdRMSIw8FL/b9+zZg927d8NsNstVWBUVFWhpacmYcUTm8cRujOnKZW1mfcoqLKkLXbUHIlVNJfFAtISw9Do2YcmsvA9dVQ6kd+1uKpzeYMq1tzZLrJKNKrGIEYTidxLP8xCE+E91nZ2dAyqyiPxClQeS4tOzJ9ZNrj2EFZ/01pLwltDzHIKhgR6IFq/GbIh5IGkEpCfJHCwJm8JCBILIJxS/k6qrq3Hffffh1KlTAIDW1lZs3LgR1157bcaMIzKPJCCpkuhAbB5Wipuf1Awo3XCVwnPJQlgCdByTNCSUCn0sB9J/J0goHAHHMmBZ5dQZj40AACAASURBVNc0m1LvLJGIhrBS9dIoXw1MEPmCYgG55557MGHCBCxduhROpxNVVVWw2+246667MmkfkWGUJNEBwGrprSJKhHSDVeuB6FIk0fUaEugA5CbG/ol0tV3oQG9oL5UHIooiXN7UHojJwIFjGRIQYkSh+N3e0NCAKVOm4Pbbb4cgCFi4cCGmT5+eSduILOD2h8CxTNJBihJ9e0ESTZyVPRCVAsKxDBgmsYBoCV8BgJ6PnhcMCXHfVygsqL6mWYGARIVVRGGKHAjDMLBZ9HClqWQjiHwi7btdFEXcf//9ePnllzFmzBiUl5ejpaUFjz32GGpqavDQQw9pCjMQuYHHF0KBKfkgRQlp1LvLm3hkuVfKgaiswmIYBjzHDvBsgoMSkMQeSFDlIEUgmi/R86xcbJAIuQs9hQcCpK9kI4h8I+27/cUXX8SHH36IF198EbNnz5YfP3jwIH7yk5/gz3/+M2688caMGklkDrcvnDZ8BaTvRtcawgKiN+mBHogAU4pP9Kkw6Ho9kL4EggIKC9Rf02Lk5SKBRCgVEJuZBioSI4u0H8e2b9+OX/ziF3HiAQCzZ8/G/fffj+3bt2fMOCLzuH0hRUubrObUZahefxgskz4UlggdxybsAxm0BxKKv6Y/KMDIqxe4AhMPjy+5B9JDHggxSkn7Dj1x4gQuvPDChM9deOGFOHHixJAbRWSP6Mj09DfVtB6IP9qFrqlqimfjvAVRFKNJdA1iBPT2jvRtJgyHIxAioqplVxIFJl6uVkuE8hCWnpLoxIgirYAIgoCCgsRL1QsKChCJJK7KIfIDdywHkg5pHlayG6CWMSYSJkP8xFtBECGK2npAAIDjWHAsg0AfD8QfjIqJUYOAWNIJiDcYHfeS5udos+gRDEU79gliJJD2HR8Oh/GPf/xjQE29RP/mQiJ/EEVRTqKnQ5qHldIDUZlAlzDpdQiEoh4CxzIIaugY709/r8YfigqUFgFR4oFYzXzaTYx9w4AGvbqpxQSRi6R9x5eWluL+++9P+nxJScmQGkRkj0BIQFgQFQkIEK3ESp4DURYKS4TJEL2p+wNhWEy8/AldSz5FQq/j4qqwBuOBFJh08PijGwcTiYQzySrb/vQ2E4ZQpnLsPUHkImnf8W+++WY27CCGASkxrCSJDqTeaeENhFFsM2qyw2TonTdlMfVWPGkVJGCgBxIYjIAYeYhizL4EM8PSjTGRsFE3OjHCoMUEoxh5jInCHR6pqogGFcKSBCR2k5eaEk0arwdI87DiPRCWZTTt4pAENlkYy+lJPUhRQu6loYm8xAiBBGQU4/ZLY0yU3aitKfoYBpVEj3kFUiLd6w/DwHODWrxk0MWPdI+W8HKaqsSkEF+iUl5RFOH0BpPuQu+LXMmWZrc8QeQLJCCjGKVzsCSsZh6+BPOwQmEBoXBEswfCcdFub0lAPP7woMJXQDSEFRZECJFo8UcgJGgq4QV6fz6JPBB/MPq9KwlhGfQcDDynaSdIa7cPT+w8RH0kRE5BAjKK8ciTeJUm0RP3gihtpEuFSa+Td4p4/SHN3oyE1EMSiuVB/EFBU/4D6P35eBIIiCQGUoVVOrQ2E766rw77DjbhmTeOJK2IJIhsQwIyinFp8ECAgd3oPe7ov5WEcZJhMujgC4YhRET4gsKgBcQYExBvMOrV+INhzQKSygORxFPp954qDJiMHncAHxxqQYnNgI+PtOGDQ7TEjcgNSEBGMS5vCCaDTnGuIVk3endMQIoKBg5ZVIrJwMEXCMthLKWJ/WRIuzmc7iDCQgRhQdQsIGaDDgwSC4jSLnTZLg0eyFv7GxEWRPxk+RyMs1vw1qeNqs4niExBAjKKcftCsCr0PoDem2SPJxD3uDP2by2DCiVMBh3Cgih7M4P1QEwGHXiORY8n2NtXotd2TZZlYDbq5KKDvnS5o997UYIJxYmwWlIv5krEe180Y+ZZJXCUWlA5sRgNLW5EIhTGIoafrAlIXV0dli9fjqqqKixfvhz19fUDjtm3bx9uuOEGzJw5E5s2bYp7ThAEbNiwAQsXLsSiRYuwbdu2LFk+cnF7g4pj9wDkMe6dzngB6XYHwUB5HiARptjNvcPpBzC4HhCgd/9GjyfY20Q4iMbE6EDFgTf+blcAOo5RLMRWMw+nJ6g4j+H2hdDe40flxGIAwGSHFYGQgKZOr3LjCSJDZE1A1q9fj5UrV+KNN97AypUrsW7dugHHTJgwAQ8++CBuueWWAc+9+uqraGhowO7du/Hiiy9i8+bNOH36dDZMH7G4FI4xkTDwHApMPDpjN3mJHk8AVoseHKv9z0kSn1OtbrAKFlwpobAgmm9o7fYBQMqVs+lINs6kyxVAUYFBcXmwzayP5nnSrMiVONXqBgBMKI/Oo5s0xgYAqG9yKjqfIDJJVgSko6MDtbW1WLx4MQBg8eLFqK2tRWdnZ9xxkyZNQmVlJXS6gZ8+d+7ciWXLloFlWZSUlGDhwoXYtWtXNswfsbh9IRSo9BpKbUZ09PNAetxBFA0igQ5Ew2NzppUCgKIFV0ootOgRiYioa3KirNAIo8YQFpB8oGKXK4ASheEroG83urIwliwgFVYAgKPEDAPPob7Zpfg1CSJTDC5OoJCmpiZUVFSA46KfKjmOQ3l5OZqamhTP0mpqasLYsWPlfzscDjQ3N2fE3pFMYZFZLnF1+8IoLy2A3W5NeGyixx12C860e+Ke8wTCKCsxJ72OUiZWWFFaaMRQValKlVFhQcS4MsugrlVg4tHY5h7weJcrgMkO5d+31dJbyTamxJz2+FOtLtgsevl7YVkGkyoKUN9MHggx/GRFQHKF0tLEY+mHi8HecLXy/BuHEQ5HEAwJ+KqxG8+/cVjxuZ1OP5raPXHnNLZ5IERE+bGVVTNgsWiryFJ7XqrjTSY9WJYBRBHTJhZr3i9it1thL7Fg/7G2uN+ZKIrodgcwrmKcYhGeGOt1YXScot9/U4cP08YXxR0746xS7Hr/JEpKLOAG0a2fzMZcI9ftA0avjVkREIfDgZaWFgiCAI7jIAgCWltb4XA4VF3jzJkz8mbE/h6JEjo6cqd6xW63oq0t+2EIu90Kjycgz5uCKMLTr6oKiN6YEz2uYxmEwhF09/jA61iIogh/IAwdy8Qdn+jcTJDudUqsBhh4DqFgGKGgsrxDf9raXGAhwhcQcKapRx4z7/aFEAxHYOCYhL/LRL9jIWbD6SYn2sakfkOHhQgaWpyYPmFC3HUqCo0IhgQcPNyC8eWD+1A0XH+HSsl1+4CRbSPLMik/eGclB1JaWorKykrs2LEDALBjxw5UVlaqGgVfXV2Nbdu2IRKJoLOzE3v27EFVVVWmTB7xSHOiDDp1n8r7Ts4FomtjRQxu9Hom+fp5FZh7Ttmgr1Mc63HpcvUWEHS5ouKlJgciFQsomcjb1OFFWBAxoSL+DTy2NBqOa6ZKLGKYyVoI64EHHsDatWuxZcsW2Gw2uUx39erVWLNmDWbNmoWPP/4YP/7xj+F2uyGKIl577TU8+OCDWLBgAWpqanDgwAF861vfAgDcddddmDBhQrbMz1nau314+8AZtHR6seyKabAr3DMhTarV8+o+Q0i7O3yBMGwWPfwh7WPSs0G6JU/pEIQI7HYrpk2KikUIjBwKONkevYFPmVCsKo9kMfEIi73PBUMCeroHisFpuQIr/hrlxdHfsVRdRhDDRdYEZOrUqQl7N7Zu3Sp/PW/ePLzzzjsJz+c4Dhs2bMiYffnKH16tRV2TExFRRGmhEcuvPFvRedKuDLV5AXOskskb80ACsZCM1kGFuQ7Hsdj60gE55Pc/e47ioy+aAECuhNr9fh32fnpqwLnJwoAQRXx6uAVbXzoAAFh9w/kJX7up0wuWYVBRHP+hwGTQocDEo40EhBhmqBM9j3F6gjjR2IMll0zG+VPL8OGhVkQUljBJ2/r0KtfGGvQcGAby4MOhaNLLB4wGDgx6hROIztcC1IfvDP12lSSjtcuL0kJDwlEz5cUmtHaRgBDDCwlIHnPwRAdEAOdPK8NFleXocgVw7FS3onODIQEM1O8dZxgmOjk3dvMMhKQxISNbQFiGgcmg6y0+AOAPCDDwXLTSSwV6npN/bqlo6fKhojhxqW95kYk8EGLYIQHJYw6caEdRgR4TKwow5+wy6HUsPjjUqujcQEgAz7OaGvakwYdAdPmTjtO26S/fMBt1cR6ILxiWc0JqMPBsWgERRRGtXd6kAmIvMqHD6R+wm4UgssnIf9ePUELhCL6o68T508rAMAyMeh1mTy3FZ8faFJ0fDEdUV2BJmI083N4QRFFEe48fJRp3oecbJoMubgSJ1h0jUggr1TwslzcEX0CQE+b9KS82QRSBjh5/wucJIhuQgOQpdU1OBIICZp9VKj82bVwhut1B9LjT92AEQ4LqCiyJ8iIjguEITrd54PGHUa6w8ivfMRt08AcFCJEIhEgkOgrGpH6Ei1S4IOWhEiHlNypKEv9spWo7qsQihhMSkDxFmpE0qU8zmvT1yZaBIzf6EwxHNHdmVxSbwTJAbX0XAMBeNDo8EGnEvC8goMcdhCgCxVb1AiIl3VOFsVq6omW95SlCWAAokU4MKyQgeUpjuwdmg04esQ709gucbEnfcRoICaorsCR0Ohb2IhMCoWgIR81E33xG2vnu9YflJVrFGpZoGWKeXzCYWkBYhkFZYWJxLirQQ69jKZFODCskIHnK6TY3xtktcUlws1GH8mITGtIISEQUEQxFBlU55YgNJywvMg3J5Nx8QPJAvIEwulwBGPUcjAb1rVT62M89kCaEVVZoTFqcwDAM7EVUyksMLyQgeYgoimhs82CcfeCMmkkVVpxMM+pb2tA3mPHmjhITbBYe48sHN+U2nzDGemBc3iC63IE4708NUvFCMFUIq9OXNIEuYS8yob2HBIQYPkhA8pAuVwC+QDjhiPJJY6xo7/HDk2D9qoTc/DcID4TXcbh8zjiUFY6OBDoQ/dQ/psSMk80ueP1hzTvgpeKFQJIQliiKaElRwisR3c1CVVjE8EECkoc0tnsAAOPtCQQktnioIYUXInVQm0Z4818mmD21FHzMg9DqgTAMA32KXhCXNwR/UEB5kgosidJCI3wBAd4UHxYIIpOQgOQhp2OLjRKFsKTJrQ2tySuxJA/EMIgQ1mjFwHP42jllsBcZUVygfQujgecQSDLORKrA6j8Dqz+lsQR7O/WCEMME3UHykMY2DwoL9Amrn2xmPWxmXvZSEuEPCmCY3mogQh1lRSaUDbL3Ra/j5JH6/WnpjPWAKAhhAUCH04+JFbm/0IgYedAdJA850+5JuaJ1bFl07Wwy/MEwjDw3aqqnchEDzybNgbR2R0t4S5OU8EpIz1M3OjFckIDkGdEEa/IhewAwrqwAZ9o9SUdl+ALaRnAQQ4dBHx2omOh31NKZuoRXwmbmwetYSqQTwwYJSJ7h9oXgC4RTxsfH2i3wBwV0OhOPNAkEBU39C8TQYTbqEBbEhONMWrq8aRPoQDQZX2ozUg6EGDZIQPKMlljjWHlJKg8kGt5KlgfxBcPkgQwzFmM0f9V3PDwgTeH1oaIodf5DorTQSCEsYtggAckzWhVU6IyVBWRgJZY/EEZYEElAhhlLrKvd44svwXUqLOGVoF4QYjghAckzWjp9YBikbOArMPEotOhxpm2gB9Lpit5sBtOFTgweaSyKp58H0tIpfUBQ7oG4vCFFC6oIYqghAckzWrq8KLUZ024SHFtmSRjCksId5IEMLxzLwqTnBkwMkMe4p+kBkSiLlfJ2khdCDAMkIHlGa5dP0c1lnD1ayhuJxFf5dJKA5AwWEz/AAznd5oaOY9OW8EpQMyExnJCA5BFSCW+qBLrEpAorguEImjrivZD22PhvCmENP2ajboAHUt/swsSKAsUrgqW9IO001p0YBkhA8gi5hFdBF/Tk2HKp+n4zsU42O2HUc2lDYETmsRh5BEMReZZVJCLiZItL/t0pobBADx3Hoq2bPBAi+9DH0DxCSQmvhKPUAj3P4mSLC5fOcsiP1zc5YTNrn+FEDB1SJVZjmxtnTyjGqRZXdE3xOeWw25WLyJhSM5z+UNpzgiEBPd3eQdlMEH0hAckjeit00nsgLMtgYnn8bpCwEMEplZ9wicwhCUhrlw//91GDvKb4syMt+OpUl+LrBEMCvjzRga0vHUh53OobztduLEEkgOIYeURrV7SE165wkN+kMVY0tLjlRHpzpxdhQYTNQh5ILiA1E37V2AMA6HYHwLEMrCpXBFtiuZRko2sIIlOQgOQRUgmv0gTr5DFWBEICmmOey+nYJ1wKYeUGOh2LskIj9n3WCFEU0e0OorBAr3rIpdkQHYsSSrEilyAyQdYEpK6uDsuXL0dVVRWWL1+O+vr6AccIgoANGzZg4cKFWLRoEbZt2yY/t3nzZsyfPx81NTWoqanBhg0bsmV6zqC0hFdikpxIdwIATrW5oeOYhGPgieFhfKzcuqnDix53QNOWQ3OSsSgEkWmylgNZv349Vq5ciZqaGmzfvh3r1q3D008/HXfMq6++ioaGBuzevRvd3d247rrrMH/+fIwfPx4AcN111+G+++7Llsk5hVTC+/XzKhSf4yg1w2bm8cmRNlwy04FTrW5MqLCCZWmMe67gKDXji7oufHK0DSzDYIpDfX5KHosSCKNI45ZEgtBCVjyQjo4O1NbWYvHixQCAxYsXo7a2Fp2dnXHH7dy5E8uWLQPLsigpKcHChQuxa9eubJiY87hUlPBKcCyLS2c5cOB4BzqdfpxqcWOyw5ZBKwm18DoO8yrLIYrAzCklcl5EDdJYFDWrbXvcAbz16WkcOdmJCOVOCI1kxQNpampCRUUFOC7a/cxxHMrLy9HU1ISSkpK448aOHSv/2+FwoLm5Wf73a6+9hn379sFut+Puu+/G3Llzs2F+1igsMkPPJ+4Q76iPiu3ZU0pVlXhed8XZeP2DBvz7i5+hxxPEheeOweGv2ofEXmJouKm6Ei53ABMrBq4oVoKOY6HnWcUhrEhExOMvf4Gjp3vwzO6juOqC8fjOt87R9NrE6CZvynhXrFiBH/zgB+B5Hu+++y7uvPNO7Ny5E8XFxYqvUVqq7Q2aKRIJwfNvHE54bN2ZaKXOp4dbcfxUt6rXKS82obnDi3MmFmHBnHE41eJKfxIAi0V7OGQw5+ba62T65zDJYcPsc8o1vwYAWM16+EORtK9nt1vx0lvHcPR0D1ZfNxMnTvfgrU9PY9m3pmOcPbfeHxJqPjANF6PVxqwIiMPhQEtLCwRBAMdxEAQBra2tcDgcA447c+YMZs+eDSDeI7Hb7fJxl156KRwOB44dO4aLLrpIsR0dHe4Bs6GGC7vdirY214DHPJ7ES6A6Y6MqmEgk6THJqJxYhCKLHueMLwQARedbLAbVr9OXwZyba6+j9TXU/AwH+32Y9Bzae/xpr1N/qhPP7jqMuWeX4evT7VgwZxzePXAGT2z/HD+omTkoGzJBovdJrjGSbWRZJuUH76zkQEpLS1FZWYkdO3YAAHbs2IHKysq48BUAVFdXY9u2bYhEIujs7MSePXtQVVUFAGhpaZGPO3ToEBobGzFlypRsmJ8TePxhmA06TQnwwgIDZkwqBks70EcsVrMe/qCQtpT3w9oWhMIRLL10ChiGQbHViIXzxuPDQ61oo3lahEqyFsJ64IEHsHbtWmzZsgU2mw2bNm0CAKxevRpr1qzBrFmzUFNTgwMHDuBb3/oWAOCuu+7ChAkTAAC/+93v8OWXX4JlWfA8j4cffjjOKxnpuH0hWEx5E3EksozNHE2+O71BlNqST/J994tmjLNb4vItC84fi9feP4lPj7ah6qKJGbeVGDlk7Y40derUuL4Oia1bt8pfcxyXtL9DEpzRiCiKcPtCmGTLzRg1MfxYY9MFXN5QUgE51eLCV2ec+KcrpsU1K5YXmTDeXoD9JCCESqgTPQ/w+sMQIiKs1EFOJMGk56DjGLi8waTH/N+np8EwwPwEvUQXnFOGY6d74PQkP58g+kMCkge4vNH6fquFOsiJxDAMA6tZn1IA3v/8DKZPKEJhgm73C86xQwTw2XEq8SaUQwKSBzhjnyqtJvJAiOTYzDxc3sRDFV3eIE61uPG16YnLhSeUF6Cs0IjPjpGAEMohAckDXN4QTAZaAkWkxmrWIxiOIBASBjwnDdSce3ZZwnMZhsF5U0pwuKELQoSGMhLKoDtSHuD0Bin/QaRFrsTyDBxp0tThxdkTilCSokLrvMkl8AcF1J3J7Z4GIncgAclxIpFoBZZ0cyCIZBQWGMAwQHtPfD+Hxx9CtzuI+bMcSc6MMmNSMRgAX9Z3pjyOICRIQHKc6KIgkAdCpIXXsSi1GeXVxxLSpsPLL5iQ8vwCE49JY6yoJQEhFEICkuNIVTXkgRBKqCg2weUNwRObzCuKIk61umEvMsKuYJfMeVNK8NUZJ3wB2i1CpIcEJMv0eII4eKJd3m+ejg5nbM0praElFFBRYgYAtHRGvZD2Hj98AQETypU1oZ47qRhCRMSRBnUDO4nRCc3GyCLHG3vwny99LnsVi+ZNwIqrpqVcYdrh9KPEZqA5VoQiCkw8Ckw6nOnwYFJFAQ43dIPnWDhiwpKOaeOLoNexqK3vxJwkFVsEIUEeSJZo6vDg4ef3w8hz+Odvz0bV1yfhbx+fwqvv1Sc9JxAS4PKGUFaYvHKGIPozeYwNnc4A/v5pI7pcAZw/rRQcp+ytzutYnDOhiBLphCLIA8kCoijiub8dBa9j8S83XYDCAgOuvHgynK4AXt5bh8pJxTh7fNGA8zqcfgBIORyPIPpz1lgbGAb44qtOTBtXiLFlFgCAIEQS7oTo/9iF5znw5I4vwfA6lKnYgAkAwZCAnm5l4Vki/yEByQKfHm1DbX0XVi48Wx4jwbIMvls1HUdPdeHpXUew/vsXDjivo8cPjmVQlGD0BEGkYorDhvH2grjmU45jsfWlA3HHJdpZ0hMLsf7+hU8wsULdEqLVN5yv0WIiH6EQVoYRRRHb99VhbJkFV1wwLu45g57Dd741HY3tHrzxYcOA89q7/Si2GjTtACEIrZMLbGYeep5FW7d/iC0iRhokIBmm9mQXTrd5UH3RRHDswB/3nGll+Np0O155tx7NHR758fYeP1y+kBx+IIhswTAMxhSb0dLlpbEmREpIQDLM3z46BZtFj4vPHThCW2LlwnPAsQwe+58D8iC8Y6d7YOA5xeWXBDGUjC2zICyIaOtK74VERBGHTnZh90en8P+t3YE/vPoljYUfJZCAZJAz7R4cPNGBKy8YlzKcUGw1YNkV0/DZ0TZ8fKQNxxt70N7jx9RxNnAUviKGgbJCI3gdi8Y+XnEiwkIE73/RgmOne1Bo0eOyuePw0aFWrHviQ7TTitwRDyXRFVBYZIae51Sf95e3vwKvY/HthdMT7mDoW/3yT9+aAb2Bx59e+QJNHV4UWw2YrDKBSRBDBcsycJSa0djmgSBEEpYBi6KI/cfa0eH0Y87ZZZhYXoDVN5yPb8wcg3997lM8+tfPcf+qC2DU021mpEK/WQXoeW5A9Uo6AiEBf/v4NCbYLfjL7sMDnk9U/bL6hvNx+Kt26DgmoeAQRDYZV2ZBQ4sbp9s8mDRm4IeZY6d70NThxbmTizGxT6h1QnkB7qg5D49sO4AX9hzD96+pzKbZRBahEFaGONnsQiQi4qyxNlXnlRYaSTyInKCs0IjiAj2OnuqGEIlfUtXc6cXhhm6Ms1swNcHf+MyzSlF90UTsPdiEwye7smUykWXIA8kAYSGCr844UV5soim6RN7CMAxmTCrG+1+24GSzS/4w1Ony49OjbSi06DFnamncKJ6+zYo3XzcLnx5rx3N7juLRn1yhKQwMDGx0BKhhMVcgAckAJ5tdCIYjOGd84XCbQhCDoqzQiLJCI76s64QQEcGxDA6d7IJRz+GiyvIBuZH+zYpTxljxj9oW/Mt/7sWMScWqXz9RqBeghsVcgUJYQ4wQieB4oxNlhcaU298IIh9gGAYXzihHRYkJh0524Yu6ThSYeFw6ywGTIf3nz/JiE8bbLTjW2AOnl0p7RxrkgQwxx073IBAS8LXxNMmUGBnwOhYXzihHpysAI8/BbNSlnCDdn/OmlKC1y4f9R9uxYLaDJiuMIMgDGUJc3iCOn+7BuDKL6iF0BJHLMAyDUpsRFhOvSjwAwMBzOH9aKXo8QRyihPqIgjyQISIUFvDp0XZwHIuZU0qG2xyCyCkcpRZMHuPHiTNOmI06THEkr07scQdwqs2DbncAYUGEXseiqMCA8eUW2KgoJacgAUnDyWYXfvuXA2jt9MBq1qPEakCJ1QBjn/ivxx/CJ0fa4PQGcVFlOQx6bdUmBDGSOW9KCXyBMD7/qhOBoIBp4wuhiyXh/cEwGts8ONXqhtMbAsNEJzTYLHq4vUGcaOzB8cYelBeZMGPiwNUHxPBAApIGPc/CYuQRDEVQ3+zCV2ecAACTgUOhRY9QWESn0w+GjSUbi5VtfiOI0QYXe498drwdR0/3oK7ZBauJRygcgcsX3eFeVKDHrLNKMK7MAj3PyVVYgaCAhlYXjjc68c7BJgSf/ADXXDQR41XMigsLEfiDAnQcAwPPqQ7FEQPJmoDU1dVh7dq16O7uRlFRETZt2oTJkyfHHSMIAn79619j7969YBgGt912G5YtW5b2uUziKLXgl7dcjK0vHUAkIqLHE0Sny48uZwAuXwg6jsVZY22YOtYW55UQBDEQlmVwwTl2TB5jxckWN7z+EMxGHcaWWTC2zJy0b8qg53D2+CJMHmPDV2ecOHi8HR980YyvTbfj0lkOzJhYHOf5O71BnGx2ob7JifpmF+qbXehy9ZYDG3gOY0rNmDa2EOdMLMI54wupgVcDWbvjrV+/HitXrkRNTQ22b9+OdevW4emnn4475tVXX0VDQwN2796N7u5uXHfddZg/fz7Gjx+f8rlswbIMiq0GFFsNxuVAEwAADghJREFUwNisvSxBjDhKbNrK3Hkdi+kTi7D+tvl49rVavP1ZIz4+0gYGQInNAI5j4fKG4AuE5XPGlJgxfWIRKorNMBt1CAsRdLkCaGzzYN/nTfj7p6cBABUlZkyfUIizxxdhbJkFhRY9OJYByzIQxWiYzR8UYv/1fs3xOvh9QViMOpiNPKxmHoUWPWwWvRyiG6lkRUA6OjpQW1uLJ598EgCwePFi/OpXv0JnZydKSnoTzjt37sSyZcvAsixKSkqwcOFC7Nq1C7feemvK55QymPLBAjOv+dxEmI08GHHgroWhfp1EKHmNZPYN5WsMBbny80qEmp/hcP28Bvt7VvIagyGZfWaDDncsm4Nbr5+NQ/UdqG90oq3Hh7AQQYGJh73IhIljbJg4xgqzMbk9YSGChmYXjjZ04WhDF46d6sbhhu6hs9+gg9Wih9XEw6TXgeUYcGzsP46FFEWT7kwM+tyj+t6uGICNHcyCAcNEK+MYRnou9u++58Wmz+g4FtWXTtF0/0t3TlYEpKmpCRUVFeC4qIvJcRzKy8vR1NQUJyBNTU0YO7b3o73D4UBzc3Pa55RSXKx9OdON1edqPjfXXmekvEa2XmekvEa2Xidb3wsQ9UhmT7Nj9jS7pvN1HIuzxhXirHGFqJ4/eWiNyzEspqGvYBvZ/hVBEASRMbIiIA6HAy0tLRAEAUA0Id7a2gqHwzHguDNnzsj/bmpqwpgxY9I+RxAEQWSfrAhIaWkpKisrsWPHDgDAjh07UFlZGRe+AoDq6mps27YNkUgEnZ2d2LNnD6qqqtI+RxAEQWQfRpSWcGeYEydOYO3atXA6nbDZbNi0aRPOOussrF69GmvWrMGsWbMgCAI2btyId999FwCwevVqLF++HABSPkcQBEFkn6wJCEEQBDGyoCQ6QRAEoQkSEIIgCEITJCAEQRCEJkhACIIgCE2QgGSRxx9/HEuWLMF1112Hmpoa7Ny5U37O5/PhRz/6ERYtWoTq6mq89dZbw2Ljhg0bUF1djaVLl2LFihX4/PPP5ec+++wzLFu2DDU1Nbj22mvxwgsv5JR9kUgE//Ef/4GqqiosWbIEt912W9btS2ejxP/+7/9i+vTpOfd7jkQiuPvuu1FVVYWlS5fi+9//PhoaGnLGPgBob2/HzTffLNt44MCBFFfKHNu3b8eSJUtw7rnn4tlnn417rq6uDqtWrUJNTQ2uvvpqbN68OafsA4BnnnkG1dXVWLJkCWpqarS9iEhkDafTKX/d3Nwszp07V+zu7hZFURQ3b94s/vznPxdFURTr6urESy65RHS73Vm38c033xSDwaD89VVXXSU/t3TpUvHNN98URVEUW1tbxTlz5ohtbW05Y98TTzwhrlmzRn4+27YpsVEURbGpqUlcvny5+E//9E/yzzPbJLNREARxz549oiAIoiiK4jPPPCN+97vfzRn7RFEU165dKz722GOiKIriRx99JC5atEiMRCJZt/HIkSPisWPHxHvvvVd85pln4p6744475Mfcbrd4+eWXiwcOHMgZ+9544w1x5cqVosvlEkVR+3uFPJAsYrVa5a+9Xi8YhkEkEh0U9/rrr8t9LZMnT8bMmTPxzjvvZN3GK664AjwfHT43Z84cNDc3yzYyDAOXywUA8Hg8sFgsMJmyu7o3lX1PPPEEfvrTn8rPl5UNz176VDYCwC9/+Uv8y7/8C/T64duul8xGlmVx1VVXgWVZ+bm+EyCG2z4A2LVrF1asWAEAmDdvHvR6fUIvL9Occ845mDZtmvyz6kvf94rf7wfDMAMap4fTvieeeAI//OEPUVAQ3aei9b1CApJlXnjhBVRXV+P666/Hr371KxQXFwMAzpw5g3HjxsnHaRkWOdQ899xzuPzyy+U/wN/85jd45JFHcPnll+P666/HAw88AItF+4DKobTP5XKhu7sbr7/+OpYtW4bly5djz549w2ZbIhsB4Pnnn8e0adNw/vnnD7NlvfS3sf9zV1555TBYFW+DZF9XVxdEUYy7GefCe6U/999/P3bu3IkFCxbgyiuvxC233JLV1RPpOHHiBA4cOIAVK1bghhtuwF/+8hdN16ENSEPI9ddfn/TT2nvvvQeO43DjjTfixhtvxJEjR/DTn/4U8+fPl0UkV2wEgNdeew2vvvoqnnvuOfn5P/7xj7j33ntxzTXX4KuvvsL3vvc9nHvuuXFTkofLPkEQEAwGEYlEsG3bNpw8eRIrV67EOeecg4kTJw6ZfYOx8dSpU/if//kfPP/880Nqz1Da2JetW7fixIkT+O///u+ctC/TKLUxES+++CJqampw6623orW1FatWrcLMmTOH9IPDYOwTBAFNTU14/vnn0dXVhRtvvBFTpkzBhRdeqM6IwcbZCO3cfPPN4q5du0RRFMVrrrlGPHjwoPzcbbfdJu7cuXNY7Nq9e7d41VVXiadOnZIf6+joEGfPnh133C233DIsNiayTxRFcc6cOWJjY6P871tvvVV8/fXXs22eKIqJbXzllVfESy65RLziiivEK664Qpw5c6Y4f/58cdu2bTljo8TTTz8tLl26VOzq6hoGy6Iks+/8888XOzo65H9fe+21Wc8v9OW+++4bkGOYM2eO2N7eLv973bp14tatW7NtmiiKie279tprxQ8//FD+9/r168U//vGPqq9NIawscvz4cfnrU6dO4dChQ5g2bRqA6LDIF198EQBQX1+Pzz//HAsWLMi6jW+99RZ+85vf4E9/+lOcy11YWAi9Xo+PPvoIANDW1obDhw/L9g+3fUB0UdnevXsBRJeYHT58GGeffXZW7Utl45IlS/Duu+/izTffxJtvvok5c+bgwQcfxLe//e2csREA/vznP+Mvf/kLnnzySRQVFWXdtnT2VVdX489//jMA4OOPP4bf78fMmTOHw8ykjB8/Xv5bdLvd+OSTT4blbzEZfd8rXq8Xn3zyCWbMmKH6OjQLK4v88z//M44fPw6dTgeO43DrrbfimmuuARD9Ja5duxaHDh0Cy7K49957sXDhwqzb+PWvfx08z8fFmJ966ikUFxdj3759+O1vfwtBEBCJRLBq1aqsD7RMZV9nZyfuv/9+nD59GgzD4Oabb8b111+fVfvS2diXVatW4eabb8YVV1yRbROT2sjzPObNm4exY8fKRR96vR7btm3LCfuKi4vR1taGe++9F2fOnIHBYMCGDRtwwQUXZNU+IDpV/OGHH4bT6QTP8zCZTHjiiScwbdo0fPHFF/j1r38Nr9eLcDiMa665Bj/84Q9zxj6/349f/vKXqK2tBQDU1NRoKnsnASEIgiA0QSEsgiAIQhMkIARBEIQmSEAIgiAITZCAEARBEJogASEIgiA0QQJCEARBaIIEhCBymA8++AAzZszA3LlzszJcc+3atZg9eza++c1vZvy1iPyHBIQYdVx55ZWYPXs25s6di0svvRRr166Fx+NRdO6qVauy3lRXXl6O/fv3Z+Wm/q//+q/YunVrxl+HGBmQgBCjkv/6r//C/v378fLLL6O2thZ/+MMfsvK64XA4K69DENmABIQY1djtdnzjG9/AoUOH5Mc+++wzrFixAvPmzcPSpUvxwQcfAAAeeeQRfPzxx9i4cSPmzp2LjRs34vTp05g+fXqcMPT1Ul566SWsWLECDz30EC6++GJs3rwZa9euxYYNG3Dbbbdh7ty5WLZsmaqtfw0NDfjud7+Liy++GBdffDF+8pOfwOl0Jjz2gw8+GOC5XHnllXjvvfcUvx5BJIMEhBjVNDc3Y+/evfLI95aWFtx+++2444478OGHH+K+++7DmjVr0NnZiXvuuQfz5s3DunXrsH//fqxbt07Raxw8eBATJkzAu+++izvuuAMAsHPnTvzwhz/ERx99hIkTJ+KRRx5RbLMoirj99tuxd+9evP7662hubh6WlakEQQJCjEruuusuzJ07F5dddhlKSkqwZs0aANE90t/85jdx2WWXgWVZXHrppZg5cybefvttza9VXl6OVatWQafTwWg0AgAWLlyI2bNnQ6fTYenSpXEeUDomTfp/7d1NS2JhGMbxvxtJQZGTUK6GPkLgCxXork2Q0AcopGjlzp0EQS+LNrnSFPIbtEk3hoGBIGSto0W7QBBFV0Zap2YxjIzMDMQhh5nx+u3Oee5znnt3cZ7Fub+wtLSE3W7HMAxisdjwL8kif5IGSslESqfTLC4uUq/XSSQSdLtd3G43jUaDUqlEpVIZ1r6+vhIKhSzvNTs7+9O9H0eITk1N8fT09OH3tdttDg8Pub29pdfr8f7+jtvtttyfiFUKEJlowWCQtbU1jo6OyGQy+Hw+otEoBwcHH3re6XQC3+Zef58v3Wq1RmpsNtun9nx8fIzNZqNYLOLxeLi8vGRvb++XtQ6Hg+fn5+G1aZp0Op1P7Ucml46wZOJtbGxQq9W4v79ndXWVSqVCtVrFNE36/T7X19fDmdter5fHx8fhs4ZhMDMzw/n5OaZpcnZ2NrI+Dr1eD6fTicvlotlscnp6+tvaubk5+v0+V1dXvLy8cHJywmAwGGt/MjkUIDLxDMMgGo2STqfx+XxkMhlyuRwLCwtEIhHy+Txvb28ArK+vc3FxQSAQGH6l7O/vk8/nCYVCPDw8MD8/P9Z+4/E4d3d3+P1+tre3WV5eHlnf2toim80C4HK52N3dZWdnh3A4jMPhGDlSKxQKrKysjLVf+X9poJTIX+zm5obNzU3sdjupVGrsY46TySSlUonp6WnK5fJY95J/nwJEREQs0RGWiIhYogARERFLFCAiImKJAkRERCxRgIiIiCUKEBERsUQBIiIilnwFZYWhIpV45KMAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Un-Matching Agent"
      ],
      "metadata": {
        "id": "v9KqkvKRyoO4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Balanced N-Back"
      ],
      "metadata": {
        "id": "-jRSzfu2yqQP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_balanced, unmatch_agent, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "CF2AnpQiyJxl",
        "outputId": "f00b2d32-82ab-4dc7-fbce-768e7b9676e7"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -14.84376 | Standard Deviation: 2.7230404077795103\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Un-Balanced N-Back"
      ],
      "metadata": {
        "id": "lziRjJDYyrD2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_and_eval(env_unbalanced, unmatch_agent, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "eULQxh4KyKGB",
        "outputId": "52c1e12b-d2d1-44d0-d7ea-611b10f511a8"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -5.1776 | Standard Deviation: 2.0764147562565625\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DQN Agent"
      ],
      "metadata": {
        "id": "ji6I5b0zys59"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Balanced N-Back"
      ],
      "metadata": {
        "id": "1tCSFK6RyuPb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "logs_dqn_balanced = train_and_eval(env_balanced, dqn_agent_balanced, True, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TR4-WWlQyOAc",
        "outputId": "af854e16-c3fd-4bd8-efc1-06e6b414e1dd"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "here\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mean_dqn = np.mean(logs_dqn_balanced['episode_return'])\n",
        "std_dqn = np.std(logs_dqn_balanced['episode_return'])\n",
        "\n",
        "print(f'Mean Return: {mean_dqn} | Standard Deviation: {std_dqn}')\n",
        "plot = logs_dqn_balanced.episode_return.hist(bins=12, density=True)\n",
        "plot.set_xlabel('Return [a.u.]')\n",
        "plot.set_ylabel('Density')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "OyJ9qlJIx1GN",
        "outputId": "7b7af4c2-c055-4961-fae0-64327a8f76d1"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -14.41136 | Standard Deviation: 2.78544483887224\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Density')"
            ]
          },
          "metadata": {},
          "execution_count": 97
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Un-Balanced N-Back"
      ],
      "metadata": {
        "id": "JRApxz2xyvIn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "logs_dqn_unbalanced = train_and_eval(env_unbalanced, dqn_agent_unbalanced, True, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "id": "RbHSBs9JyOPL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "665597f6-15ba-4c71-e2df-f6d2a0e5119c"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "here\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mean_dqn_ub = np.mean(logs_dqn_unbalanced['episode_return'])\n",
        "std_dqn_ub = np.std(logs_dqn_unbalanced['episode_return'])\n",
        "print(f'Mean Return: {mean_dqn_ub} | Standard Deviation: {std_dqn_ub}')\n",
        "\n",
        "plot_dqn_ub = logs_dqn_unbalanced.episode_return.hist(bins=12, density=True)\n",
        "plot_dqn_ub.set_xlabel('Return [a.u.]')\n",
        "plot_dqn_ub.set_ylabel('Density')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "D50ezbuAooDF",
        "outputId": "d558bce6-9d10-4e66-f65c-1058ef9aa5bc"
      },
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -10.65172 | Standard Deviation: 2.7610326042261795\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Density')"
            ]
          },
          "metadata": {},
          "execution_count": 100
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DRQN Agent"
      ],
      "metadata": {
        "id": "VYENVrXxywgf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Balanced N-Back"
      ],
      "metadata": {
        "id": "PI2ZXu7Kyxyc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "logs_drqn_balanced = train_and_eval(env_balanced, drqn_agent_balanced, True, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "id": "FKEeEbjByWrp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5157d7ec-9eb7-4483-c11b-e3e964dd4dc4"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "here\n",
            "INFO:tensorflow:Assets written to: /root/acme/3860c960-0cbf-11ed-bb08-0242ac1c0002/snapshots/network/assets\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Assets written to: /root/acme/3860c960-0cbf-11ed-bb08-0242ac1c0002/snapshots/network/assets\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mean_drqn = np.mean(logs_drqn_balanced['episode_return'])\n",
        "std_drqn = np.std(logs_drqn_balanced['episode_return'])\n",
        "\n",
        "print(f'Mean Return: {mean_drqn} | Standard Deviation: {mean_drqn}')\n",
        "\n",
        "plot_drqn = logs_drqn_balanced.episode_return.hist(bins=12, density = True)\n",
        "plot_drqn.set_xlabel('Return [a.u.]')\n",
        "plot_drqn.set_ylabel('Density')\n",
        "logs_dqn_balanced.tail()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        },
        "id": "7Ab9UTVDRlFK",
        "outputId": "3e9dbc1f-597f-47b7-f409-4d27d4670377"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -15.62624 | Standard Deviation: -15.62624\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "       episode_length episode_return  steps_per_second  episodes   steps  \\\n",
              "24995              32          -13.0        261.550913     24996  799872   \n",
              "24996              32          -14.0        229.880772     24997  799904   \n",
              "24997              32          -12.0        219.577309     24998  799936   \n",
              "24998              32          -13.0        253.517953     24999  799968   \n",
              "24999              32          -12.0        296.636052     25000  800000   \n",
              "\n",
              "           test  \n",
              "24995  0.000036  \n",
              "24996  0.000039  \n",
              "24997  0.000033  \n",
              "24998  0.000036  \n",
              "24999  0.000033  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-8572b5cf-4f02-4910-9903-a5bae1a25f54\">\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>episode_length</th>\n",
              "      <th>episode_return</th>\n",
              "      <th>steps_per_second</th>\n",
              "      <th>episodes</th>\n",
              "      <th>steps</th>\n",
              "      <th>test</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>24995</th>\n",
              "      <td>32</td>\n",
              "      <td>-13.0</td>\n",
              "      <td>261.550913</td>\n",
              "      <td>24996</td>\n",
              "      <td>799872</td>\n",
              "      <td>0.000036</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24996</th>\n",
              "      <td>32</td>\n",
              "      <td>-14.0</td>\n",
              "      <td>229.880772</td>\n",
              "      <td>24997</td>\n",
              "      <td>799904</td>\n",
              "      <td>0.000039</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24997</th>\n",
              "      <td>32</td>\n",
              "      <td>-12.0</td>\n",
              "      <td>219.577309</td>\n",
              "      <td>24998</td>\n",
              "      <td>799936</td>\n",
              "      <td>0.000033</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24998</th>\n",
              "      <td>32</td>\n",
              "      <td>-13.0</td>\n",
              "      <td>253.517953</td>\n",
              "      <td>24999</td>\n",
              "      <td>799968</td>\n",
              "      <td>0.000036</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24999</th>\n",
              "      <td>32</td>\n",
              "      <td>-12.0</td>\n",
              "      <td>296.636052</td>\n",
              "      <td>25000</td>\n",
              "      <td>800000</td>\n",
              "      <td>0.000033</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8572b5cf-4f02-4910-9903-a5bae1a25f54')\"\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-8572b5cf-4f02-4910-9903-a5bae1a25f54 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-8572b5cf-4f02-4910-9903-a5bae1a25f54');\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": 99
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Un-Balanced N-Back"
      ],
      "metadata": {
        "id": "h7hLLNggyyRG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "logs_drqn_unbalanced = train_and_eval(env_unbalanced, drqn_agent_unbalanced, True, n_episodes = n_episodes,  episode_length = episode_length, log_loss = False)"
      ],
      "metadata": {
        "id": "y0Kz9jPtyW78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1f1ab99-d09b-4514-93c5-1e0ea0e7dff3"
      },
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "here\n",
            "INFO:tensorflow:Assets written to: /root/acme/3860c960-0cbf-11ed-bb08-0242ac1c0002/snapshots/network/assets\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Assets written to: /root/acme/3860c960-0cbf-11ed-bb08-0242ac1c0002/snapshots/network/assets\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mean_drqn_ub = np.mean(logs_drqn_unbalanced['episode_return'])\n",
        "std_drqn_ub = np.std(logs_drqn_unbalanced['episode_return'])\n",
        "\n",
        "print(f'Mean Return: {mean_drqn_ub} | Standard Deviation: {mean_drqn_ub}')\n",
        "\n",
        "plot_drqn = logs_drqn_unbalanced.episode_return.hist(bins=12, density = True)\n",
        "plot_drqn.set_xlabel('Return [a.u.]')\n",
        "plot_drqn.set_ylabel('Density')\n",
        "logs_drqn_unbalanced.tail()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        },
        "id": "KaX22X7ht2R9",
        "outputId": "33aa8bdc-bd8b-4453-9dfe-aba0d0a1b085"
      },
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Return: -5.75736 | Standard Deviation: -5.75736\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "       episode_length episode_return  steps_per_second  episodes   steps\n",
              "24995              32           -7.0        248.461626     24996  799872\n",
              "24996              32           -2.0        270.008526     24997  799904\n",
              "24997              32           -2.0        261.394024     24998  799936\n",
              "24998              32           -5.0        261.869855     24999  799968\n",
              "24999              32           -3.0        217.002763     25000  800000"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-76f8c391-602a-4671-883d-4bb51e3755bb\">\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>episode_length</th>\n",
              "      <th>episode_return</th>\n",
              "      <th>steps_per_second</th>\n",
              "      <th>episodes</th>\n",
              "      <th>steps</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>24995</th>\n",
              "      <td>32</td>\n",
              "      <td>-7.0</td>\n",
              "      <td>248.461626</td>\n",
              "      <td>24996</td>\n",
              "      <td>799872</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24996</th>\n",
              "      <td>32</td>\n",
              "      <td>-2.0</td>\n",
              "      <td>270.008526</td>\n",
              "      <td>24997</td>\n",
              "      <td>799904</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24997</th>\n",
              "      <td>32</td>\n",
              "      <td>-2.0</td>\n",
              "      <td>261.394024</td>\n",
              "      <td>24998</td>\n",
              "      <td>799936</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24998</th>\n",
              "      <td>32</td>\n",
              "      <td>-5.0</td>\n",
              "      <td>261.869855</td>\n",
              "      <td>24999</td>\n",
              "      <td>799968</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24999</th>\n",
              "      <td>32</td>\n",
              "      <td>-3.0</td>\n",
              "      <td>217.002763</td>\n",
              "      <td>25000</td>\n",
              "      <td>800000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-76f8c391-602a-4671-883d-4bb51e3755bb')\"\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-76f8c391-602a-4671-883d-4bb51e3755bb 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-76f8c391-602a-4671-883d-4bb51e3755bb');\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": 103
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "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')  "
      ],
      "metadata": {
        "id": "uro52jc69oCH"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Balanced Logs\n",
        "dqn_b_ma = moving_average(logs_dqn_balanced['episode_return'], 100)\n",
        "drqn_b_ma = moving_average(logs_drqn_balanced['episode_return'], 100)\n",
        "\n",
        "# dqn_b = list(logs_dqn_balanced['episode_return'])\n",
        "# drqn_b = list(logs_drqn_balanced['episode_return'])\n",
        "\n",
        "plt.plot(dqn_b_ma, color='blue')\n",
        "plt.plot(drqn_b_ma, color='yellow')\n",
        "\n",
        "# plt.plot(dqn_b, color='blue')\n",
        "# plt.plot(drqn_b, color='yellow')\n",
        "\n",
        "plt.ylabel(\"episode_reward\")\n",
        "plt.xlabel(\"episode (N_steps per episode = 32)\")\n",
        "plt.legend(['DQN','DRQN'])\n",
        "plt.title(\"Equal match and non-match\")"
      ],
      "metadata": {
        "id": "gLIG5S-K1tB-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "outputId": "c5057cc9-69f9-46a1-d45c-f7f57bec35c2"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Equal match and non-match')"
            ]
          },
          "metadata": {},
          "execution_count": 67
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Un-Balanced Logs\n",
        "dqn_u_ma = moving_average(logs_dqn_unbalanced['episode_return'], 100)\n",
        "drqn_u_ma = moving_average(logs_drqn_unbalanced['episode_return'], 100)\n",
        "\n",
        "# dqn_u = list(logs_dqn_unbalanced['episode_return'])\n",
        "# drqn_u = list(logs_drqn_unbalanced['episode_return'])\n",
        "\n",
        "plt.plot(dqn_u_ma, color='blue')\n",
        "plt.plot(drqn_u_ma, color='yellow')\n",
        "\n",
        "# plt.plot(dqn_u, color='blue')\n",
        "# plt.plot(drqn_u, color='yellow')\n",
        "\n",
        "plt.ylabel(\"episode_reward\")\n",
        "plt.xlabel(\"episode (N_steps per episode = 32)\")\n",
        "plt.legend(['DQN','DRQN'])\n",
        "plt.title(\"Unequal match and non-match\")"
      ],
      "metadata": {
        "id": "v1CkmCXg1uLI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "outputId": "c923210c-04d0-42d1-e51b-1657e8d8e887"
      },
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Unequal match and non-match')"
            ]
          },
          "metadata": {},
          "execution_count": 102
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Mohinga_Project_RL_Mult.ipynb",
      "provenance": []
    },
    "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
}