Dyna_Q_DynaQ+_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "456971b7c32e2bf5364ff3e844755588",
     "grade": false,
     "grade_id": "cell-2379d0e980554734",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Assignment: Dyna-Q and Dyna-Q+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "76de530741f980cceea89c1cbca751b3",
     "grade": false,
     "grade_id": "cell-e4a73a1d4819583b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Welcome to this programming assignment! In this notebook, you will:\n",
    "1. implement the Dyna-Q and Dyna-Q+ algorithms. \n",
    "2. compare their performance on an environment which changes to become 'better' than it was before, that is, the task becomes easier. \n",
    "\n",
    "We will give you the environment and infrastructure to run the experiment and visualize the performance. The assignment will be graded automatically by comparing the behavior of your agent to our implementations of the algorithms. The random seed will be set explicitly to avoid different behaviors due to randomness. \n",
    "\n",
    "Please go through the cells in order. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b5700a0fc8aa27a9871262534a74584d",
     "grade": false,
     "grade_id": "cell-fc7a8bce812462f8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## The Shortcut Maze Environment\n",
    "\n",
    "In this maze environment, the goal is to reach the goal state (G) as fast as possible from the starting state (S). There are four actions â€“ up, down, right, left â€“ which take the agent deterministically from a state to the corresponding neighboring states, except when movement is blocked by a wall (denoted by grey) or the edge of the maze, in which case the agent remains where it is. The reward is +1 on reaching the goal state, 0 otherwise. On reaching the goal state G, the agent returns to the start state S to being a new episode. This is a discounted, episodic task with $\\gamma = 0.95$.\n",
    "\n",
    "<img src=\"./images/shortcut_env.png\" alt=\"environment\" width=\"400\"/>\n",
    "\n",
    "Later in the assignment, we will use a variant of this maze in which a 'shortcut' opens up after a certain number of timesteps. We will test if the the Dyna-Q and Dyna-Q+ agents are able to find the newly-opened shorter route to the goal state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b5d6eca06a34b6a6e873658478461b95",
     "grade": false,
     "grade_id": "cell-003d45ed0386900a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Packages\n",
    "\n",
    "We import the following libraries that are required for this assignment. Primarily, we shall be using the following libraries:\n",
    "1. numpy: the fundamental package for scientific computing with Python.\n",
    "2. matplotlib: the library for plotting graphs in Python.\n",
    "3. RL-Glue: the library for reinforcement learning experiments.\n",
    "\n",
    "**Please do not import other libraries** as this will break the autograder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "120eb20b7f1dddd120d76b2aa7919153",
     "grade": false,
     "grade_id": "cell-bee88a7e78d66006",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import jdc\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rl_glue import RLGlue\n",
    "from agent import BaseAgent\n",
    "from maze_env import ShortcutMazeEnvironment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ee4fd0b140763673eeaa4eb9568f651c",
     "grade": false,
     "grade_id": "cell-028a2dd8d19ea3a7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "plt.rcParams.update({'font.size': 15})\n",
    "plt.rcParams.update({'figure.figsize': [8,5]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8af78c99916d2bef7b8950c06c91ca1b",
     "grade": false,
     "grade_id": "cell-05b0c5c488d26a90",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Section 1: Dyna-Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a70fc156a2c433210a5340707627ab14",
     "grade": false,
     "grade_id": "cell-87547eb7b48d2d80",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Let's start with a quick recap of the tabular Dyna-Q algorithm.\n",
    "\n",
    "<div style=\"width:80%\"><img src=\"./images/DynaQ.png\" alt=\"DynaQ_pseudocode\"></div>\n",
    "\n",
    "Dyna-Q involves four basic steps:\n",
    "1. Action selection: given an observation, select an action to be performed (here, using the $\\epsilon$-greedy method).\n",
    "2. Direct RL: using the observed next state and reward, update the action values (here, using one-step tabular Q-learning).\n",
    "3. Model learning: using the observed next state and reward, update the model (here, updating a table as the environment is assumed to be deterministic).\n",
    "4. Planning: update the action values by generating $n$ simulated experiences using certain starting states and actions (here, using the random-sample one-step tabular Q-planning method). This is also known as the 'Indirect RL' step. The process of choosing the state and action to simulate an experience with is known as 'search control'.\n",
    "\n",
    "Steps 1 and 2 are parts of the [tabular Q-learning algorithm](http://www.incompleteideas.net/book/RLbook2018.pdf#page=153) and are denoted by line numbers (a)â€“(d) in the pseudocode above. Step 3 is performed in line (e), and Step 4 in the block of lines (f).\n",
    "\n",
    "We highly recommend revising the Dyna videos in the course and the material in the RL textbook (in particular, [Section 8.2](http://www.incompleteideas.net/book/RLbook2018.pdf#page=183))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "65b87624638d81a162640d0c59868798",
     "grade": false,
     "grade_id": "cell-feffd3d6e8b4ac8b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Alright, let's begin coding.\n",
    "\n",
    "As you already know by now, you will develop an agent which interacts with the given environment via RL-Glue. More specifically, you will implement the usual methods `agent_start`, `agent_step`, and `agent_end` in your `DynaQAgent` class, along with a couple of helper methods specific to Dyna-Q, namely `update_model` and `planning_step`. We will provide detailed comments in each method describing what your code should do. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "30cdeb28f5cf7ee8bfe4844ab7b9624b",
     "grade": false,
     "grade_id": "cell-d0135622e9f741c2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Let's break this down in pieces and do it one-by-one.\n",
    "\n",
    "First of all, check out the `agent_init` method below. As in earlier assignments, some of the attributes are initialized with the data passed inside `agent_info`. In particular, pay attention to the attributes which are new to `DynaQAgent`, since you shall be using them later. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fcc0e80f7f9aee52e7128caa88d2c7ba",
     "grade": false,
     "grade_id": "cell-5d0e8c43378d5e30",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "class DynaQAgent(BaseAgent):\n",
    "\n",
    "    def agent_init(self, agent_info):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\n",
    "\n",
    "        Args:\n",
    "            agent_init_info (dict), the parameters used to initialize the agent. The dictionary contains:\n",
    "            {\n",
    "                num_states (int): The number of states,\n",
    "                num_actions (int): The number of actions,\n",
    "                epsilon (float): The parameter for epsilon-greedy exploration,\n",
    "                step_size (float): The step-size,\n",
    "                discount (float): The discount factor,\n",
    "                planning_steps (int): The number of planning steps per environmental interaction\n",
    "\n",
    "                random_seed (int): the seed for the RNG used in epsilon-greedy\n",
    "                planning_random_seed (int): the seed for the RNG used in the planner\n",
    "            }\n",
    "        \"\"\"\n",
    "\n",
    "        # First, we get the relevant information from agent_info \n",
    "        # NOTE: we use np.random.RandomState(seed) to set the two different RNGs\n",
    "        # for the planner and the rest of the code\n",
    "        try:\n",
    "            self.num_states = agent_info[\"num_states\"]\n",
    "            self.num_actions = agent_info[\"num_actions\"]\n",
    "        except:\n",
    "            print(\"You need to pass both 'num_states' and 'num_actions' \\\n",
    "                   in agent_info to initialize the action-value table\")\n",
    "        self.gamma = agent_info.get(\"discount\", 0.95)\n",
    "        self.step_size = agent_info.get(\"step_size\", 0.1)\n",
    "        self.epsilon = agent_info.get(\"epsilon\", 0.1)\n",
    "        self.planning_steps = agent_info.get(\"planning_steps\", 10)\n",
    "\n",
    "        self.rand_generator = np.random.RandomState(agent_info.get('random_seed', 42))\n",
    "        self.planning_rand_generator = np.random.RandomState(agent_info.get('planning_random_seed', 42))\n",
    "\n",
    "        # Next, we initialize the attributes required by the agent, e.g., q_values, model, etc.\n",
    "        # A simple way to implement the model is to have a dictionary of dictionaries, \n",
    "        #        mapping each state to a dictionary which maps actions to (reward, next state) tuples.\n",
    "        self.q_values = np.zeros((self.num_states, self.num_actions))\n",
    "        self.actions = list(range(self.num_actions))\n",
    "        self.past_action = -1\n",
    "        self.past_state = -1\n",
    "        self.model = {} # model is a dictionary of dictionaries, which maps states to actions to \n",
    "                        # (reward, next_state) tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0aabcf332aa74c3e7db51eb0b47ab744",
     "grade": false,
     "grade_id": "cell-ee23a83113d8ed05",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now let's create the `update_model` method, which performs the 'Model Update' step in the pseudocode. It takes a `(s, a, s', r)` tuple and stores the next state and reward corresponding to a state-action pair.\n",
    "\n",
    "Remember, because the environment is deterministic, an easy way to implement the model is to have a dictionary of encountered states, each mapping to a dictionary of actions taken in those states, which in turn maps to a tuple of next state and reward. In this way, the model can be easily accessed by `model[s][a]`, which would return the `(s', r)` tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d6dd59f9c730360c26df3035b85ea17a",
     "grade": false,
     "grade_id": "cell-59c91c0887f0eaea",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "\n",
    "def update_model(self, past_state, past_action, state, reward):\n",
    "    \"\"\"updates the model \n",
    "    \n",
    "    Args:\n",
    "        past_state       (int): s\n",
    "        past_action      (int): a\n",
    "        state            (int): s'\n",
    "        reward           (int): r\n",
    "    Returns:\n",
    "        Nothing\n",
    "    \"\"\"\n",
    "    # Update the model with the (s,a,s',r) tuple (1~4 lines)\n",
    "    \n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    if past_state in self.model: # check if the key exist\n",
    "        self.model[past_state][past_action] =(state, reward) # update or insert turple to the the action\n",
    "    else:\n",
    "        self.model[past_state] = {past_action:(state, reward)} # if not, add state and turple of action to the dict\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "802b3f2ab731bdccc0adcfc6d4950229",
     "grade": false,
     "grade_id": "cell-f625328c7bd73d13",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `update_model()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ab016ddc9bcf9816b2a62407532dede7",
     "grade": true,
     "grade_id": "cell-d4fa9f9e0a14ccfa",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "actions = []\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0, \n",
    "              \"random_seed\": 0,\n",
    "              \"planning_random_seed\": 0}\n",
    "\n",
    "agent = DynaQAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "# (past_state, past_action, state, reward)\n",
    "agent.update_model(0,2,0,1)\n",
    "agent.update_model(2,0,1,1)\n",
    "agent.update_model(0,3,1,2)\n",
    "\n",
    "expected_model = {\n",
    "    # action 2 in state 0 leads back to state 0 with a reward of 1\n",
    "    # or taking action 3 leads to state 1 with reward of 2\n",
    "    0: {\n",
    "        2: (0, 1),\n",
    "        3: (1, 2),\n",
    "    },\n",
    "    # taking action 0 in state 2 leads to state 1 with a reward of 1\n",
    "    2: {\n",
    "        0: (1, 1),\n",
    "    },\n",
    "}\n",
    "\n",
    "assert agent.model == expected_model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4ad7e7911407af12a3ad8dea6a0e83fa",
     "grade": false,
     "grade_id": "cell-a398d6775a6d809a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Next, you will implement the planning step, the crux of the Dyna-Q algorithm. You shall be calling this `planning_step` method at every timestep of every trajectory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2c48cb05d902ca761858cc4c81846350",
     "grade": false,
     "grade_id": "cell-1a90876a079f6ea2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "\n",
    "def planning_step(self):\n",
    "    \"\"\"performs planning, i.e. indirect RL.\n",
    "\n",
    "    Args:\n",
    "        None\n",
    "    Returns:\n",
    "        Nothing\n",
    "    \"\"\"\n",
    "    \n",
    "    # The indirect RL step:\n",
    "    # - Choose a state and action from the set of experiences that are stored in the model. (~2 lines)\n",
    "    # - Query the model with this state-action pair for the predicted next state and reward.(~1 line)\n",
    "    # - Update the action values with this simulated experience.                            (2~4 lines)\n",
    "    # - Repeat for the required number of planning steps.\n",
    "    #\n",
    "    # Note that the update equation is different for terminal and non-terminal transitions. \n",
    "    # To differentiate between a terminal and a non-terminal next state, assume that the model stores\n",
    "    # the terminal state as a dummy state like -1\n",
    "    #\n",
    "    # Important: remember you have a random number generator 'planning_rand_generator' as \n",
    "    #     a part of the class which you need to use as self.planning_rand_generator.choice()\n",
    "    #     For the sake of reproducibility and grading, *do not* use anything else like \n",
    "    #     np.random.choice() for performing search control.\n",
    "\n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    for n in range(self.planning_steps):\n",
    "        # select from a list of keys of the dict\n",
    "        state = self.planning_rand_generator.choice(list(self.model.keys())) \n",
    "        action = self.planning_rand_generator.choice(list(self.model[state].keys()))\n",
    "        # query state and reward value in the model\n",
    "        state_next, reward = self.model[state][action]\n",
    "        \n",
    "        # update\n",
    "        if state_next != -1:\n",
    "            equation = self.step_size * (reward + self.gamma * max(self.q_values[state_next, :]) - self.q_values[state, action])\n",
    "        else: # terminal state q max = 0\n",
    "            equation = self.step_size * (reward + self.gamma * 0 - self.q_values[state, action])\n",
    "            \n",
    "        self.q_values[state, action] += equation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "edbac5139f888befba4b2696d25fed12",
     "grade": false,
     "grade_id": "cell-35c7dcb9a38dd319",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `planning_step()` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f8e02d9152bf919f6755239ef071f37c",
     "grade": true,
     "grade_id": "cell-8ae4b7a941ad7767",
     "locked": true,
     "points": 20,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "actions = []\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0, \n",
    "              \"planning_steps\": 4,\n",
    "              \"random_seed\": 0,\n",
    "              \"planning_random_seed\": 5}\n",
    "\n",
    "agent = DynaQAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "agent.update_model(0,2,1,1)\n",
    "agent.update_model(2,0,1,1)\n",
    "agent.update_model(0,3,0,1)\n",
    "agent.update_model(0,1,-1,1)\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        2: (1, 1),\n",
    "        3: (0, 1),\n",
    "        1: (-1, 1),\n",
    "    },\n",
    "    2: {\n",
    "        0: (1, 1),\n",
    "    },\n",
    "}\n",
    "\n",
    "assert agent.model == expected_model\n",
    "\n",
    "agent.planning_step()\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0, 0.1, 0, 0.2],\n",
    "    [0, 0, 0, 0],\n",
    "    [0.1, 0, 0, 0],\n",
    "])\n",
    "assert np.all(np.isclose(agent.q_values, expected_values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a3534e47ea52ac6c4180d714a0e01e37",
     "grade": false,
     "grade_id": "cell-02566293dd5feb36",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now before you move on to implement the rest of the agent methods, here are the helper functions that you've used in the previous assessments for choosing an action using an $\\epsilon$-greedy policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7d55430e58877032febb23ecb4ba8efd",
     "grade": false,
     "grade_id": "cell-cc975f6b2f1a6661",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQAgent\n",
    "\n",
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def argmax(self, q_values):\n",
    "    \"\"\"argmax with random tie-breaking\n",
    "    Args:\n",
    "        q_values (Numpy array): the array of action values\n",
    "    Returns:\n",
    "        action (int): an action with the highest value\n",
    "    \"\"\"\n",
    "    top = float(\"-inf\")\n",
    "    ties = []\n",
    "\n",
    "    for i in range(len(q_values)):\n",
    "        if q_values[i] > top:\n",
    "            top = q_values[i]\n",
    "            ties = []\n",
    "\n",
    "        if q_values[i] == top:\n",
    "            ties.append(i)\n",
    "\n",
    "    return self.rand_generator.choice(ties)\n",
    "\n",
    "def choose_action_egreedy(self, state):\n",
    "    \"\"\"returns an action using an epsilon-greedy policy w.r.t. the current action-value function.\n",
    "\n",
    "    Important: assume you have a random number generator 'rand_generator' as a part of the class\n",
    "                which you can use as self.rand_generator.choice() or self.rand_generator.rand()\n",
    "\n",
    "    Args:\n",
    "        state (List): coordinates of the agent (two elements)\n",
    "    Returns:\n",
    "        The action taken w.r.t. the aforementioned epsilon-greedy policy\n",
    "    \"\"\"\n",
    "\n",
    "    if self.rand_generator.rand() < self.epsilon:\n",
    "        action = self.rand_generator.choice(self.actions)\n",
    "    else:\n",
    "        values = self.q_values[state]\n",
    "        action = self.argmax(values)\n",
    "\n",
    "    return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e4704ddcf5cfaad469470f8397c9397d",
     "grade": false,
     "grade_id": "cell-50858ea1e5f5db91",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Next, you will implement the rest of the agent-related methods, namely `agent_start`, `agent_step`, and `agent_end`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ae45bcd826ba619bf18f2513c80b4079",
     "grade": false,
     "grade_id": "cell-34d9e8a161d6e5b4",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "\n",
    "def agent_start(self, state):\n",
    "    \"\"\"The first method called when the experiment starts, \n",
    "    called after the environment starts.\n",
    "    Args:\n",
    "        state (Numpy array): the state from the\n",
    "            environment's env_start function.\n",
    "    Returns:\n",
    "        (int) the first action the agent takes.\n",
    "    \"\"\"\n",
    "    \n",
    "    # given the state, select the action using self.choose_action_egreedy()), \n",
    "    # and save current state and action (~2 lines)\n",
    "    ### self.past_state = ?\n",
    "    ### self.past_action = ?\n",
    "\n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    self.past_state = state\n",
    "    self.past_action = self.choose_action_egreedy(state)\n",
    "    \n",
    "    return self.past_action\n",
    "\n",
    "def agent_step(self, reward, state):\n",
    "    \"\"\"A step taken by the agent.\n",
    "\n",
    "    Args:\n",
    "        reward (float): the reward received for taking the last action taken\n",
    "        state (Numpy array): the state from the\n",
    "            environment's step based on where the agent ended up after the\n",
    "            last step\n",
    "    Returns:\n",
    "        (int) The action the agent takes given this state.\n",
    "    \"\"\"\n",
    "    \n",
    "    # - Direct-RL step (~1-3 lines)\n",
    "    # - Model Update step (~1 line)\n",
    "    # - `planning_step` (~1 line)\n",
    "    # - Action Selection step (~1 line)\n",
    "    # Save the current state and action before returning the action to be performed. (~2 lines)\n",
    "\n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    q_max = np.max(self.q_values[state])\n",
    "    self.q_values[self.past_state, self.past_action] += self.step_size * (reward + self.gamma * q_max\n",
    "                                                                - self.q_values[self.past_state, self.past_action])\n",
    "    # Model Update step\n",
    "    self.update_model(self.past_state, self.past_action, state, reward)\n",
    "    # Planning\n",
    "    self.planning_step()\n",
    "    # Choose Action\n",
    "    action = self.choose_action_egreedy(state)\n",
    "    # Save the current state and action\n",
    "    self.past_state = state\n",
    "    self.past_action = action\n",
    "    \n",
    "    return self.past_action\n",
    "\n",
    "def agent_end(self, reward):\n",
    "    \"\"\"Called when the agent terminates.\n",
    "\n",
    "    Args:\n",
    "        reward (float): the reward the agent received for entering the\n",
    "            terminal state.\n",
    "    \"\"\"\n",
    "    \n",
    "    # - Direct RL update with this final transition (1~2 lines)\n",
    "    # - Model Update step with this final transition (~1 line)\n",
    "    # - One final `planning_step` (~1 line)\n",
    "    #\n",
    "    # Note: the final transition needs to be handled carefully. Since there is no next state, \n",
    "    #       you will have to pass a dummy state (like -1), which you will be using in the planning_step() to \n",
    "    #       differentiate between updates with usual terminal and non-terminal transitions.\n",
    "\n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    self.q_values[self.past_state, self.past_action] += self.step_size * (reward + self.gamma * 0\n",
    "                                                                - self.q_values[self.past_state, self.past_action])\n",
    "    # Model Update step\n",
    "    self.update_model(self.past_state, self.past_action, -1, reward) # -1 for the terminal\n",
    "    # Planning\n",
    "    self.planning_step()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "684b56621417ff95a833db909acbc2b9",
     "grade": false,
     "grade_id": "cell-13ed73c6c6df5630",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `agent_start()`, `agent_step()`, and `agent_end()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8ce595f374dc31897a6698cae3652bef",
     "grade": true,
     "grade_id": "cell-02b41cfa4e281a4f",
     "locked": true,
     "points": 20,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0, \n",
    "              \"random_seed\": 0,\n",
    "              \"planning_steps\": 2,\n",
    "              \"planning_random_seed\": 0}\n",
    "\n",
    "agent = DynaQAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "# ----------------\n",
    "# test agent start\n",
    "# ----------------\n",
    "\n",
    "action = agent.agent_start(0)\n",
    "\n",
    "assert action == 1\n",
    "assert agent.model == {}\n",
    "assert np.all(agent.q_values == 0)\n",
    "\n",
    "# ---------------\n",
    "# test agent step\n",
    "# ---------------\n",
    "\n",
    "action = agent.agent_step(1, 2)\n",
    "assert action == 3\n",
    "\n",
    "action = agent.agent_step(0, 1)\n",
    "assert action == 1\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        1: (2, 1),\n",
    "    },\n",
    "    2: {\n",
    "        3: (1, 0),\n",
    "    },\n",
    "}\n",
    "assert agent.model == expected_model\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0, 0.3439, 0, 0],\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0, 0, 0],\n",
    "])\n",
    "assert np.allclose(agent.q_values, expected_values)\n",
    "\n",
    "# --------------\n",
    "# test agent end\n",
    "# --------------\n",
    "\n",
    "agent.agent_end(1)\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        1: (2, 1),\n",
    "    },\n",
    "    2: {\n",
    "        3: (1, 0),\n",
    "    },\n",
    "    1: {\n",
    "        1: (-1, 1),\n",
    "    },\n",
    "}\n",
    "assert agent.model == expected_model\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0, 0.41051, 0, 0],\n",
    "    [0, 0.1, 0, 0],\n",
    "    [0, 0, 0, 0.01],\n",
    "])\n",
    "assert np.allclose(agent.q_values, expected_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ebc65986e4b7d2a58cbaa4fc22508593",
     "grade": false,
     "grade_id": "cell-58a0061ef19de5af",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Experiment: Dyna-Q agent in the maze environment\n",
    "\n",
    "Alright. Now we have all the components of the `DynaQAgent` ready. Let's try it out on the maze environment! \n",
    "\n",
    "The next cell runs an experiment on this maze environment to test your implementation. The initial action values are $0$, the step-size parameter is $0.125$. and the exploration parameter is $\\epsilon=0.1$. After the experiment, the sum of rewards in each episode should match the correct result.\n",
    "\n",
    "We will try planning steps of $0,5,50$ and compare their performance in terms of the average number of steps taken to reach the goal state in the aforementioned maze environment. For scientific rigor, we will run each experiment $30$ times. In each experiment, we set the initial random-number-generator (RNG) seeds for a fair comparison across algorithms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6f1ce118374c859b81ca1a743bc1bd9b",
     "grade": false,
     "grade_id": "cell-744f017993777ec8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def run_experiment(env, agent, env_parameters, agent_parameters, exp_parameters):\n",
    "\n",
    "    # Experiment settings\n",
    "    num_runs = exp_parameters['num_runs']\n",
    "    num_episodes = exp_parameters['num_episodes']\n",
    "    planning_steps_all = agent_parameters['planning_steps']\n",
    "\n",
    "    env_info = env_parameters                     \n",
    "    agent_info = {\"num_states\" : agent_parameters[\"num_states\"],  # We pass the agent the information it needs. \n",
    "                  \"num_actions\" : agent_parameters[\"num_actions\"],\n",
    "                  \"epsilon\": agent_parameters[\"epsilon\"], \n",
    "                  \"discount\": env_parameters[\"discount\"],\n",
    "                  \"step_size\" : agent_parameters[\"step_size\"]}\n",
    "\n",
    "    all_averages = np.zeros((len(planning_steps_all), num_runs, num_episodes)) # for collecting metrics \n",
    "    log_data = {'planning_steps_all' : planning_steps_all}                     # that shall be plotted later\n",
    "\n",
    "    for idx, planning_steps in enumerate(planning_steps_all):\n",
    "\n",
    "        print('Planning steps : ', planning_steps)\n",
    "        os.system('sleep 0.5')                    # to prevent tqdm printing out-of-order before the above print()\n",
    "        agent_info[\"planning_steps\"] = planning_steps  \n",
    "\n",
    "        for i in tqdm(range(num_runs)):\n",
    "\n",
    "            agent_info['random_seed'] = i\n",
    "            agent_info['planning_random_seed'] = i\n",
    "\n",
    "            rl_glue = RLGlue(env, agent)          # Creates a new RLGlue experiment with the env and agent we chose above\n",
    "            rl_glue.rl_init(agent_info, env_info) # We pass RLGlue what it needs to initialize the agent and environment\n",
    "\n",
    "            for j in range(num_episodes):\n",
    "\n",
    "                rl_glue.rl_start()                # We start an episode. Here we aren't using rl_glue.rl_episode()\n",
    "                                                  # like the other assessments because we'll be requiring some \n",
    "                is_terminal = False               # data from within the episodes in some of the experiments here \n",
    "                num_steps = 0\n",
    "                while not is_terminal:\n",
    "                    reward, _, action, is_terminal = rl_glue.rl_step()  # The environment and agent take a step \n",
    "                    num_steps += 1                                      # and return the reward and action taken.\n",
    "\n",
    "                all_averages[idx][i][j] = num_steps\n",
    "\n",
    "    log_data['all_averages'] = all_averages\n",
    "    \n",
    "    return log_data\n",
    "    \n",
    "\n",
    "def plot_steps_per_episode(data):\n",
    "    all_averages = data['all_averages']\n",
    "    planning_steps_all = data['planning_steps_all']\n",
    "\n",
    "    for i, planning_steps in enumerate(planning_steps_all):\n",
    "        plt.plot(np.mean(all_averages[i], axis=0), label='Planning steps = '+str(planning_steps))\n",
    "\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.xlabel('Episodes')\n",
    "    plt.ylabel('Steps\\nper\\nepisode', rotation=0, labelpad=40)\n",
    "    plt.axhline(y=16, linestyle='--', color='grey', alpha=0.4)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f4b740a35fbe720e8ecc73ade69dd3cd",
     "grade": false,
     "grade_id": "cell-b7c90063cc0888e0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:07<00:00,  3.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:06<00:00,  4.56it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:42<00:00,  1.43s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAFHCAYAAABZF73PAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd3hUZdr48e89ySSZSSOFEEJJCAKhd6V3ROFFRRdwXTSR97cCou7KAoKCRFlWkZVmeVfUBV1RAQVEXmm6CCi41Fek94TQEiAhgRQS8vz+OJNxJpkUQpKJ8Hyuay6dc+5zzjO5Um7up4lSCk3TNE3TtN86k7sboGmapmmaVhF0UqNpmqZp2m1BJzWapmmapt0WdFKjaZqmadptQSc1mqZpmqbdFnRSo2mapmnabcHT3Q3Qbk1oaKiKiopydzM0TdM0rcrs2rXrolKqZuHjOqn5jYuKimLnzp3uboamaZqmVRkRSXB1XHc/aZqmaZp2W9BJTTmJyPcioop5dbbFiIi8KCKnRSRLRDaLSBsX92omIt+JSKaInBWRV0XEo+o/laZpmqb9dunup/J7GggodOxVoC2ww/Z+EjAVmAAcAsYB34pIC6XUeQARCQK+BQ4ADwINgTcxEs4plfwZNE3TNO22oZOaclJKHXB8LyJeQAdgiVIqT0R8MJKa15RSb9titgGngGf4NWEZDViAh5VS6cAGEQkA4kXkDdsxTdM0TdNKobufKs59QBDwme19F4xKztKCAKXUNeBr4H6H6+4H1hVKXj7HSHR6VmaDNU3TNO12opOaivMocAbYYnsfA9wAjhaKO2g7h0PcIccApVQikFkoTtM0TdO0EujupwogIlZgMLBAKaVsh4OAq0qpG4XCUwGriHgppa7b4tJc3DbVdk7TtNtAeno6ycnJ5ObmurspmlZtmc1mwsLCCAgoPGS1bHRSUzEGA3782vVUQLmIFRfniotzdRwReQp4CqB+/fo31VBN06peeno6Fy5coE6dOlgsFkSk9Is07Q6jlCIrK4szZ84AlCux0d1PFeNR4JhSynEVvFTA38XU7BpAplIq1yGuhot7BuK6goNSaoFSqoNSqkPNmkUWVNQ0rZpJTk6mTp06WK1WndBoWjFEBKvVSp06dUhOTi7XPXRSc4tEJBBjsG/hKs0hwAO4q9DxwmNoDlFo7IyI1AN8C8VVumOJ+3jjs6fYd3RrVT5W0257ubm5WCwWdzdD034TLBZLubtpdVJz64YA3hRNarYC6cDQggMOY2/WOMStAQaIiL/DseFAFrCpMhpcnBNnf+Ff17fxw741pQdrmnZTdIVG08rmVn5WdFJz6x4FflZKHXQ8qJTKBl4HXhSRsSLSF1iG8TV/yyH0H0AOsFxE+tnGy8QDs6t6jZro8DoAnE9LqcrHapqmaVqF0EnNLRCRUKAvxroyrrwOzAAmA6sx1q3pr5S6UBCglEq13cMDYw2bV4A5wLTKa7lr/n5hAFy66nIoj6Zpd7D4+HhExP6KiIjgkUce4fjx4/aYuLg4OnTo4MZWGpv8jh8/3q1tcLRgwQJWrlzp7mZUmvfff59GjRrh4+ND+/bt+e6779zaHj376RYopS4C5hLOK4ykZkYp9zkA9KnY1t08i6+R1GTmZJB5PQ+rl/720DTtV4GBgaxduxaAEydOMHXqVPr27cv+/fvx9fV1c+sMK1asICQkxN3NsFuwYAEtWrTgoYcecndTKtznn3/O6NGjiY+Pp1u3bixcuJD/+q//YseOHbRo0cItbdJ/tTQ7i7cxrEdM2exNukKn6Orzi0HTNPfz9PSkU6dOAHTq1In69evTvXt3vvnmG4YOHVrK1VWjbdu27m7CHWPatGnExsYydepUAHr27MmePXt4/fXX+eSTT9zSJt39pNmZTWY8lULkOrsTU93dHE3Tqrn27dsDcOrUKZfnz507x8iRI4mOjsZisdC4cWOmTJnC9evX7TGnTp1CRFi6dCmjRo0iMDCQunXrMm3aNPLz8+1x8fHxhIaGsmfPHjp16oTVaqVt27Zs2bLF6ZmFu58KusQ2bNhAq1at8PX1pVu3buzfv9/putTUVB599FF8fX2JiIhg5syZjB8/nqioqBK/Bvv37+e+++4jODgYX19fmjZtyjvvvANAr1692LVrFx999JG9227RokX2az/44AOaN2+Ot7c3kZGRvPHGG073Lmj7ypUriYmJwcfHh27dunHggNPWg3z44Yc0b94ci8VCaGgoPXv2LPL5KtqJEyc4cuQIw4YNsx8zmUwMHTqUNWvcN9lEV2o0J1YEL3MeuxP0uBpN00pWkMyEh4e7PH/x4kWCg4OZPXs2QUFBHDlyhPj4eFJSUnjvvfecYidOnMgjjzzCF198wXfffcerr75K8+bNnf5oZmZmEhsby/PPP094eDivvPIKQ4YMITExEavVWmw7ExMTmTBhAi+99BIWi4Xx48czbNgw9u3bZ59pExcXxw8//MC8efMIDw9nzpw5HDlyBA+PwkuNOXvggQeIiYnhk08+wdvbm8OHD5OebszxePfdd3nkkUeIjo62VzMaNmwIwKxZs3jxxReZOHGiPfmZOnUqVquVZ555xn7/hIQExo0bx/Tp07FYLEybNo0BAwZw9OhRfHx82Lx5M6NHj+bVV1+lc+fOpKens23bNq5cuVJiu/Py8ko8D+Dh4VHsTKRDh4wVR2JinHfzadq0KZcvXyYlJQV3rKOmkxrNiQUTJs8b7ElMRSmlp6FqWiV55ev9HDhbpRMc7ZpFBDBtcPNyXVvwx/DEiRM8/fTT+Pv7069fP5exLVu25O9//7v9fdeuXfH19WXkyJG89dZbeHl52c/16NGDN998E4D+/fuzdu1ali9f7pTUZGVlMXfuXPr0MYYg1q5dm7Zt27J582buu+++Ytt8+fJlfvzxRxo1agRAfn4+Q4YM4fDhw8TExLBv3z5WrVrF0qVL7d1offv2pV69evj5+RV734sXL3LixAlWrlxJy5Yt7dcVaNasGb6+vtSsWdPebQfGCtOvvPIKU6ZMYdq0afbPnJmZyV//+lfGjBljT6YuXrzIV199RZcuXQCjOtawYUMWLVrE6NGj2b59O61atWLy5Mn2+z/wwAPFthmMZLRBgwYlxgBs3LiRXr16uTyXmmpU82vUcF47NigoyH7eHUmN7n7SnFjEA+WRx6Vr10m8nOnu5miaVo1cunQJs9mM2WymSZMmnDhxgiVLllC7dm2X8Uop5s6dS7NmzbBYLJjNZv7whz+Qk5NDYmKiU+y9997r9L5Zs2YkJSU5HTObzU5/ZJs1awZQJK6wqKgoe0Lj6rqdO43F4AcPHmyPsVgsxSZrBYKDg6lXrx6jR49myZIlZV4Fd9u2bVy7do2hQ4eSl5dnf/Xp04cLFy44fZ6wsDB7QgMQGRlJ+/bt2b59OwBt2rRhz549PP/882zevNmpa684ERER7Nixo9RXQfdiSQr/w7dg+0N3/YNYV2o0J1bxJE9yANidmEpkSPWY0aBpt5vyVkrcKTAwkG+//RYRITw8nIiIiBL/eM2dO5fx48czadIkevbsSVBQEDt27GDs2LFkZ2c7xRb+F7+Xl1eRmICAAEwmk1MMUCSuMFf3drzu/Pnz+Pv74+Pj4xRXWqXBZDKxfv16XnrpJUaOHElWVhZdu3Zl/vz5JQ5YvnjxIgDNm7v+Hjh9+jSRkZGAkdQUFhYWxrlz5wDo168fCxcuZP78+cybNw8/Pz9GjBjBrFmzip2R5uXlRZs2bUr8bECJXW8FFZm0tDQCAwPtx9PSjKELhb/mVUUnNZoTi8mLHK7h5+3JroRUhrSt6+4maZpWTXh6et7UOjTLli1j6NChzJjx66oWhQe5Vgfh4eFkZGSQnZ3tlNikpJS+EGlMTAxffvklubm5bNmyhRdeeIFBgwaRlJTklIA5Cg4OBmD16tXUqlWryPkmTZrY/99V9Sc5OdkpIYqNjSU2NpaUlBSWL1/O888/T0BAAK+//rrL51dE91PBWJpDhw7ZE7CC98HBwW7pegKd1GiFWDy8uazyaV0vUA8W1jTtlmRlZeHt7e10bPHixW5qTfEKErVVq1bZx/BkZWWxYcMG/P39S7rUzmw206dPH8aNG8djjz1GWloawcHBLitOnTt3xmKxcPbsWQYNGlTifZOTk9m6dau9CyoxMZHdu3fz5JNPFomtWbMmo0aNYvny5SUmjwXdT6VxTK4Ki46OpnHjxixbtowBAwYAxlilZcuWcf/995d678qikxrNidXThzMoetcL4K3vT3ItJw9fb/1tomnazevfvz/z58/nnnvuoWHDhixevJhjx465u1lFtGjRgsGDBzNmzBgyMjIIDw9n9uzZWK3WYqstAHv37mX8+PEMHz6c6OhoUlNTmTlzJq1bt7ZXY2JiYli3bh3r1q0jJCSEBg0aEBISQnx8PH/6059ISEigR48e5Ofnc+TIETZu3MiKFSvszwgNDeXxxx+3z356+eWXCQsLIy4uDjDWirl8+TK9evWyT3nftGlTsVUaMLqfKmLl5/j4eEaMGEFUVBRdu3blo48+4ujRo3z66ae3fO/y0n+tNCcWTwtZJqFDhJl8BT8npdGlYai7m6Vp2m/Qyy+/TEpKClOmTAHg4YcfZv78+U4DcquLRYsWMWbMGJ577jn8/PwYO3Ys0dHRJVY0wsPDqVWrFjNmzODs2bPUqFGD3r17M3PmTHvMlClTSExMZNiwYaSnp7Nw4ULi4uKYOHEiERERzJkzhzfffBMfHx8aN27M8OHDnZ4RGRnJiy++yKRJk0hISKBDhw589tln9m6yjh07MmfOHD7//HMyMjKIjIy0J0yV7fe//z1Xr15l5syZTJ8+nebNm7N69Wq3rSYMIAUjlbXfpg4dOqiCkfsVYcbqWL5J3sGa+7+m1bxDTBjQhLG976qw+2vanejgwYM0bdrU3c3QbkJeXh4tWrTgnnvu4aOPPnJLG+Li4ti3bx8V+Tv+t6K0nxkR2aWUKlJu0pUazYnV7EeWyUSAZNKwpi+7E/TKwpqm3f6WLVvG2bNnadmyJenp6bz//vscPXqUjz/+2N1N026CTmo0JxZvf3JFyM1MpV39IL47lKwX4dM07bbn6+vLwoULOXbsGDdu3KBly5Z8/fXX3H333e5umnYTdFKjObF4GSP9s7Iu0i4yimW7kjh1KZMGodVnvZqLV3M4fyWbFnUCSw/WNE0rg4EDBzJw4EB3N8OJ4z5RWtnoFYU1J1YfY0GlrKzLtKtv/P+uatYF9fd1hxn+3jZyb+SXHqxpmqbdMXRSozmx+BirQGZlXaZRmB/+3p7Vbsfu3YmpXLt+g4Pn3LNvjqZpmlY96aRGc2LxMdZWyMxJw2QS2tSvUa0GC1/LyeNY8lUAdp6qPu3SNE3T3E8nNZoTq48xTiUr29i2vl39II5cyOBqTunb1FeFfWeukG9bhaC6dYtpmqZp7qWTGs2JxdMCQNZ1o2unXWSQsQjf6eqxZcLeJCPZ6npXCDsTLqPXWdI0TdMK6KRGc/JrUmN08bSpZ4yxqS5dUD8npVGnhoUBzcO5kJ7DmbQsdzdJ0zRNqyZ0UqM5sXpaAcjMvQZAoMVMozC/ajNYeG/SFVrVDaR9ZPWcmaVpt6v4+HhExP6KiIjgkUce4fjx4/aYuLi4CtlT6FZERUUxfvx4t7bB0YIFC1i5cqW7m1EpevXq5fQ9UfAqvIFnVdLr1GhOLGZbpSY3036sXf0g1h04T36+wmRy3yJ8qdeuk3g5k9/fXZ8mtfzx9fJg56lUHmxTx21t0rQ7SWBgIGvXrgXgxIkTTJ06lb59+7J//358favHWlYrVqwgJCTE3c2wW7BgAS1atOChhx5yd1MqRe/evfnb3/7mdKzwzuxVSSc1mpOCSk3WjV8z7XaRNViy8zQnLl7jrjA/dzWNvWeM8TSt6wbi6WGibf0gXanRtCrk6elJp06dAOjUqRP169ene/fufPPNNwwdOtTNrTO0bdvW3U24owQHB9u/J6oD3f2kOfHxNHZ+zXRMamyL8Lm7C2qvbbByi7rGDK32kUEcOp9ebWZmadqdpn379gCcOnXK5flz584xcuRIoqOjsVgsNG7cmClTpnD9+nV7zKlTpxARli5dyqhRowgMDKRu3bpMmzaN/PxfF9iMj48nNDSUPXv20KlTJ6xWK23btmXLli1Ozyzc/VTQJbZhwwZatWqFr68v3bp1Y//+/U7Xpaam8uijj+Lr60tERAQzZ85k/PjxREVFlfg12L9/P/fddx/BwcH4+vrStGlT3nnnHcDontm1axcfffSRvWvGcZXgDz74gObNm+Pt7U1kZCRvvPGG070L2r5y5UpiYmLw8fGhW7duHDhwwCnuww8/pHnz5lgsFkJDQ+nZs2eRz3en0EnNLRARTxGZJCJHRSRHRJJEZE6hGBGRF0XktIhkichmEWnj4l7NROQ7EckUkbMi8qqIeFTdpzGYxIQFD7Ju/PpLp2FNPwJ8PNnj5qTm56QrRNf0JcDHDECHKGNmlrvbpWl3qoJkJjw83OX5ixcvEhwczOzZs1m7di0TJkxg4cKFPPvss0ViJ06ciJ+fH1988QUjRozg1Vdf5YsvvnCKyczMJDY2llGjRvHll1/i7e3NkCFDyMzMLHI/R4mJiUyYMIGXXnqJzz77jOTkZIYNG+Y0ezIuLo4NGzYwb948FixYwPr161myZEmpX4MHHngADw8PPvnkE1atWsWzzz5LRkYGAO+++y4xMTEMHDiQbdu2sW3bNgYNGgTArFmzGDNmDA899BCrV69mzJgxTJ06lbffftvp/gkJCYwbN46pU6fy6aefcuXKFQYMGGAft7J582ZGjx7NiBEjWLNmDf/85z/p0qULV65cKbHdeXl5pb7KMrt0/fr1WK1WrFYrAwYMYO/evaVeU6mUUvpVzhfwL+AsMAroCYwA/lYoZjKQBTwD9AO+AS4C4Q4xQbb7fAv0B0YD14C/ltaG9u3bq4rW4+P26tX5UUrduGE/9sSH/1H3zt5U4c+6GR3/ukH9+fM99vfpWddVg0mr1ez1h93YKk0r3YEDB9zdhFs2bdo0FRISonJzc1Vubq46fPiw6tWrl/L391dnz55VSikVGxurSvqdlJubqxYvXqy8vb1VTk6OUkqpkydPKkA9/vjjTrGtW7dWw4cPd3o+oL777jv7sT179ihArVmzxn4sMjJS/eUvf7G/j42NVR4eHurIkSP2YytWrFCAOnjwoFJKqV9++UUBaunSpfaYzMxMFRISoiIjI4v9PCkpKQpQe/fuLTamffv2KjY21unYlStXlK+vr4qPj3c6PnXqVFWrVi2Vl5dnbzugfvzxR3vMqVOnlIeHh/qf//kfpZRSs2bNUu3atSv2+a4UfM1Le23cuLHE+7z88svqn//8p9q8ebP617/+pWJiYlRAQIA6efLkTbXHldJ+ZoCdysXfRD2mppxE5D7gUaC1UupAMTE+wCTgNaXU27Zj24BTGEnOFFvoaMACPKyUSgc2iEgAEC8ib9iOVRmLyYtMk8D1q+ATABhdUHO/O0J6dq69UlKVzl/JJjkjh1Z1f93E0t/HTJPwALd3i2lauayZBOd/cc+zw1vC/a/f9GWXLl3CbP71579+/fosWbKE2rVru4xXStkrHydPnnSaFZOYmMhdd91lf3/vvfc6XdusWTMSExOdjpnNZnr16uUUA5CUlFRiu6OiomjUqJHL62JiYti5cycAgwcPtsdYLBb69evHTz/9VOx9g4ODqVevHqNHj+a5556jd+/ehIWFldgWgG3btnHt2jWGDh1KXt6v3ed9+vRh+vTpJCUlERkZCUBYWBhdunSxx0RGRtK+fXu2b9/O6NGjadOmDRMnTuT5559nyJAhdOrUCS8vrxKfHxERwY4dO0ptZ5MmTUo8/8orr9j/v3v37vTr14+YmBjmzp3L3LlzS71/ZdDdT+U3Evh3cQmNTRcgAFhacEApdQ34GrjfIe5+YF2h5OVzjESnZ4W1uIwsHt5kiUDOr81pF1kD5cZF+H5OMp7bqm4Np+MdIoPYk5jGjXy9CJ+mVbbAwEB27NjBzp07SUpK4tSpU9x///3Fxs+dO5e//OUvDBkyhK+++ort27fbx5sUnvZbo4bzz7aXl1eRmICAAEwmk1OMq3sV5urejtedP38ef39/fHx8nOJq1qxZ4n1NJhPr168nPDyckSNHEh4eTvfu3dmzZ0+J1128eBGA5s2bYzab7a/evXsDcPr0aXusqyQpLCyMc+fOAdCvXz8WLlzI5s2b6dWrF6GhoTz99NNcu3at2Od7eXnRpk2bUl9+fjc3MSQ8PJyuXbuye/fum7quIulKTfndA6wSkbeBJzC+lmuBZ5RSZ20xMcAN4Gihaw8Cwx3exwD/dgxQSiWKSKbt3NcV3/ziWT19jKQmOx1shZE29WogArsT0ujeqOQf9MqwNykNT5PQPCLA6Xj7yCD+9VMCh86n0zwisJirNa0aKkelxN08PT1vah2aZcuWMXToUGbMmGE/VniQa3UQHh5ORkYG2dnZTolNSkpKqdfGxMTw5Zdfkpuby5YtW3jhhRcYNGgQSUlJTgmYo+BgY4+91atXU6tWrSLnHSskycnJRc4nJyfTvHlz+/vY2FhiY2NJSUlh+fLlPP/88wQEBPD6666/x06dOkWDBg1K/WwbN250qoyVlYj7lv7QSU35hQNxwM8Y3VD+wBvAChHpZOvzCwKuKqVuFLo2FbCKiJdS6rotzlUJJNV2zomIPAU8BUb5t6JZPC1kmkxOlRp/HzONw/zd1tWzN+kKjWv542N2HjvtuAifTmo0rXrJysoqsmbJ4sWL3dSa4hUkaqtWrWLYsGGA0fYNGzbg7+9fpnuYzWb69OnDuHHjeOyxx0hLSyM4ONhlxalz585YLBbOnj1rHzhcnOTkZLZu3WrvgkpMTGT37t08+eSTRWJr1qzJqFGjWL58eYnJY0V1PxV24cIFfvzxR0aOHHlT11UkndSUn9heDyqlLgGIyDlgE9AH+M4W56pfRFycKy6uyHGl1AJgAUCHDh0qvN/FYvYlTQRyMpyOt4usweq956p8ET6lFHuTrjCwZdEZFnWDLNQK8GZXQipPdI6qsjZpmla6/v37M3/+fO655x4aNmzI4sWLOXbsmLubVUSLFi0YPHgwY8aMISMjg/DwcGbPno3Vai222gKwd+9exo8fz/Dhw4mOjiY1NZWZM2fSunVrezUmJiaGdevWsW7dOkJCQmjQoAEhISHEx8fzpz/9iYSEBHr06EF+fj5Hjhxh48aNrFixwv6M0NBQHn/8caZPn47FYuHll18mLCyMuLg4AKZNm8bly5ftXU979uxh06ZNxVZpwOh+utWVn/fu3cvkyZMZOnQokZGRJCYm8tprr2Eymfjzn/98S/e+FTqpKb9U4ERBQmPzA3AdaIaR1KQC/iLiUahaUwPIVErlOtzLudPXEIjrCk6lspj9yDIJZDtPCWxXP4jPtp/meMpVGtUq279eKkLCpUyuZOUWGU8DRpmzQ2QwO0/pwcKaVt28/PLLpKSkMGWKMSfi4YcfZv78+U4DcquLRYsWMWbMGJ577jn8/PwYO3Ys0dHRJVY0wsPDqVWrFjNmzODs2bPUqFGD3r17M3PmTHvMlClTSExMZNiwYaSnp7Nw4ULi4uKYOHEiERERzJkzhzfffBMfHx8aN27M8OHDnZ4RGRnJiy++yKRJk0hISKBDhw589tln9m6yjh07MmfOHD7//HMyMjKIjIy0J0yVKSQkBKUUkydP5tKlS/j7+9OrVy9WrlxZKT0IZeZqSpR+lWk69/fAtkLHTBhJzVjb+z4YlZYmheI+BHY5vN8MfFYopp7t2sEltaMypnRP2zhB9fqgqVI7PnQ6fiw5Q0W+sFp9vj2hwp9ZkpV7klTkC6vVvjNpLs9/sOWEinxhtTqXllWl7dK0srodpnTfaXJzc1WTJk3UE0884bY2lDZF/nZW3indevZT+a0GWolIqMOxHoAZY5wNwFYgHbCvHy4iVmAwsMbhujXAABFxLH8Mx1jfZlPFN71kFp9AW6XGeSZ5dKgvNaxmdidUbfFob9IVvD1NNC6mOtRBb26padotWrZsGfPmzePf//43K1eu5MEHH+To0aOMHTvW3U3TboLufiq/BcBzwNci8jeMgcIzgW+VUj8AKKWyReR1YKqIpAKHgHEYFZ23HO71D9u9lovITCAaiAdmqypeowbA4uVPlggq+wqOI2dEhLb1alT5YOG9SWk0jwjA7OE6B28WEYDF7MHOhMsMauV6vQxN07SS+Pr6snDhQo4dO8aNGzdo2bIlX3/9NXfffbe7m6bdBJ3UlJNSKl1E+gDzMdaUuQ58BTxfKPR1jCRmMhAC7AT6K6UuONwrVUT6Am9jTN9OA+ZgJDZVzmq2ki/C9ew0Cu+12q5+EBsPp3AlK5dAS+Uvwpd3I599Z9IZ3rFesTFmDxOt6wXqSo2maeU2cOBABg4c6O5mOHHcJ0orG53U3AKl1DGgxJ8CW9/fDNurpLgDGGNw3M7iaQEg01VSY+vq+b/TafRsXPnr1RxLuUpW7g1a1yt5unb7yCD+sekEmdfzsHrpb2tN07Q7kR5ToxVh9bQCkHW9aM9X63o1MAnsrqKqyN7TxgwsVzOfHHWIDOZGvuLn0yVv4qZpmqbdvnRSoxVRUKnJKrRODYCftyeNa1XdInw/J6Xh7+1JgxDfEuPa1S8YLHy5KpqlaZqmVUM6qdGKsHc/uajUgNHV83+JaeRXwX5Le5Ou0LJuYKmL/QVazTSu5cdOPa5G0zTtjqWTGq0Iq9nW/ZTrekO0dvWDyMjJ42jy1UptR07eDQ6dTy+166lA+8ggdiekVkmypWmaplU/OqnRirB3P+VlujxfMFi4srugDp7LIPeGonXdsu3p1D4ymPTsPI6lVG6ypWmaplVPOqnRirB3P+Vlgypa9YgKsRLs68W/tiXw+fZEEi9lFqyCXKH2JhmL/LWqV7ZKTcEifHrLBE3TtDuTTmq0Iuyzn1CQW7RaIyKM7hlNytUcJi3/hR6zNtJt5kYmLPuZFXuSOH8lu8g15fHz6SuE+nkREehTprrZ61wAACAASURBVPjIECshvl7s1IOFNa3CxcfHIyL2V0REBI888gjHjx+3x8TFxd3yRom3KioqivHjx7u1DY4WLFjAypUr3d2MStGrVy+n74mCV+Fdyc+cOcOQIUPw8/MjNDSUZ555hsxM1z0Bt0ov6KEVYe9+KtgqwavozKOnejTkj92jOZ5yla3HL7H12CXWH7jAsl1JAETX9KVLwxC6NAylc3QIQb5eN92OvUlptKpbA5Gy7QguIrSPDNKL8GlaJQkMDGTt2rUAnDhxgqlTp9K3b1/279+Pr2/JMxSryooVKwgJCXF3M+wWLFhAixYteOihh9zdlErRu3dv/va3vzkd8/b+dYWzvLw8BgwYgJeXF0uWLCEtLY1x48aRlpbGJ598UuHt0UmNVoTFbOt+EhPkZACutx4QEe4K8+euMH+e6BxFfr7iwLl0th2/xNbjF1mx+wyf/JSIn7cnq57pSnRNvzK34WqOMTbmZrc96BAVxPoDF0jJyKGmf+GlAzVNuxWenp506tQJgE6dOlG/fn26d+/ON998w9ChQ0u5umq0bdvW3U24owQHB9u/J1xZtmwZBw8e5NixYzRo0AAAs9nMo48+yrRp02jUqFGFtkd3P2lFeJm88MBkVGpyyr71lMkktKgTyB97RLPwybv5v2n3snRUZ5RSvLH28E21Yd+ZKygFrcs486lA+8hgQG9uqWlVoX379gCcOnXK5flz584xcuRIoqOjsVgsNG7cmClTpnD9+nV7zKlTpxARli5dyqhRowgMDKRu3bpMmzaN/Px8e1x8fDyhoaHs2bOHTp06YbVaadu2LVu2bHF6ZuHup4IusQ0bNtCqVSt8fX3p1q0b+/fvd7ouNTWVRx99FF9fXyIiIpg5cybjx48nKiqqxK/B/v37ue+++wgODsbX15emTZvyzjvvAEb3zK5du/joo4/sXTOOWx988MEHNG/eHG9vbyIjI3njjTec7l3Q9pUrVxITE4OPjw/dunXjwIEDTnEffvghzZs3x2KxEBoaSs+ePYt8PndZs2YNHTt2tCc0AA899BBeXl72ql9F0kmNVoSIYPHwJksEssu/Qq/Zw8TdDYIZ1bMha/efv6mF8eyDhMs486lAizoBeHma9CJ8mlYFCpKZ8PBwl+cvXrxIcHAws2fPZu3atUyYMIGFCxfy7LPPFomdOHEifn5+fPHFF4wYMYJXX32VL774wikmMzOT2NhYRo0axZdffom3tzdDhgwpdXxGYmIiEyZM4KWXXuKzzz4jOTmZYcOGOU1wiIuLY8OGDcybN48FCxawfv16lixZUurX4IEHHsDDw4NPPvmEVatW8eyzz5KRYSxc+u677xITE8PAgQPZtm0b27ZtY9CgQQDMmjWLMWPG8NBDD7F69WrGjBnD1KlTefvtt53un5CQwLhx45g6dSqffvopV65cYcCAAfZxK5s3b2b06NGMGDGCNWvW8M9//pMuXbpw5UrJv7vz8vJKfZVlAsj69euxWq1YrVYGDBjA3r17nc4fOnSImJgYp2NeXl40bNiQQ4cOlXr/m6W7nzSXLJ4+ZJlMN1WpKc7/696AT35KYMb/HuTLMV3KNEbm56Qr1KlhIcTv5rqQvD09aFVHb26pVX8zt8/k0OWK/6VeFjHBMbxw9wvlujYvLw8wxtQ8/fTT+Pv7069fP5exLVu25O9//7v9fdeuXfH19WXkyJG89dZbeHn9OtauR48evPnmmwD079+ftWvXsnz5coYNG2aPycrKYu7cufTpY2yTV7t2bdq2bcvmzZu57777im3z5cuX+fHHH+1dHfn5+QwZMoTDhw8TExPDvn37WLVqFUuXLrV3o/Xt25d69erh51d8t/nFixc5ceIEK1eupGXLlvbrCjRr1gxfX19q1qzp1EWTnp7OK6+8wpQpU5g2bZr9M2dmZvLXv/6VMWPG4OHhYX/GV199RZcuXQCjOtawYUMWLVrE6NGj2b59O61atWLy5Mn2+z/wwAPFthmMZNSxclKcjRs30qtXr2LP9+zZk9jYWO666y4SEhKYMWMG3bt35+eff7ZXuFJTU6lRo2jFPSgoiNTUiv89rSs1mktWTyuZYhsofKv38vJkXP/G7E5MY+2+82W6Zm9SWqmbWBanfVQQ+86kk517o1zXa5rm2qVLlzCbzZjNZpo0acKJEydYsmQJtWu7HvumlGLu3Lk0a9YMi8WC2WzmD3/4Azk5OSQmJjrF3nvvvU7vmzVrRlJSktMxs9ns9Ee2WbNmAEXiCouKinIau1H4up07dwIwePBge4zFYik2WSsQHBxMvXr1GD16NEuWLCE5ObnE+ALbtm3j2rVrDB061Kky0qdPHy5cuOD0ecLCwuwJDUBkZCTt27dn+/btALRp04Y9e/bw/PPPs3nzZqeuveJERESwY8eOUl8F3YvFeeWVV3jyySfp3r07I0aMYOPGjYgIc+fOdYpz9Q9ZpVSZJ4HcDF2p0VyymK1G91MFVGoAfte+Lh/+cJKZaw/Rr1ktzB7F59OXr13n9OUs/nBPZLme1SEymPc2neCXM1foGBVc3iZrWqUqb6XEnQIDA/n2228REcLDw4mIiCjxD9PcuXMZP348kyZNomfPngQFBbFjxw7Gjh1bZNpv4X/Ne3l5FYkJCAjAZDI5xQBF4gpzdW/H686fP4+/vz8+Ps7LR9SsWbPE+5pMJtavX89LL73EyJEjycrKomvXrsyfP7/EAcsXL14EoHnz5i7Pnz59mshI4/dfWFhYkfNhYWGcO3cOgH79+rFw4ULmz5/PvHnz8PPzY8SIEcyaNavYGWleXl60adOmxM8G2KtFZRUeHk7Xrl3ZvXu3/VhQUBBpaWlFYtPS0lxWcG6VrtRoLlnMvkb3UwVUagA8PUxMHhjDqUuZfPqfxBJjyzuepkC7+sYPil6ET9MqlqenJx06dKB9+/bUqVOn1H9pL1u2jKFDhzJjxgzuvfdeOnbsWG2mfjsKDw8nIyOjSHKUkpJS6rUxMTF8+eWXpKWl8e2335Kdnc2gQYOcBjkXFhxs/GNr9erVLiskrVu3tse6qv4kJyc7VcdiY2PZtWsXFy5cYNasWSxatIjp06cX+/xTp07ZK24lvTZt2lTq53fF8fsiJiamyNiZ69evc+LEiSJjbSqCrtRoLlnMVjI8PG1TuitG7yZhdI4OYd53R3m4XR38fcwu4/YmXUEEWtYpX1IT4udNdKivHlejaW6WlZXltGYJwOLFi93UmuIVLBi4atUq+xierKwsNmzYgL+/f5nuYTab6dOnD+PGjeOxxx4jLS2N4OBglxWnzp07Y7FYOHv2rH3gcHGSk5PZunWrvQsqMTGR3bt38+STTxaJrVmzJqNGjWL58uVFZkg5Kuh+Kk2TJk1KjXF04cIFfvzxR0aOHGk/dv/99/Ppp5+SkJBgrz6tWrWKnJycEsdBlZdOajSXrJ5Wkk0eFdb9BEb2/uLApgx++wf+sek4Ewa4ztL3JqURHepbbNJTFu0jg/juUHKl9dtqmla6/v37M3/+fO655x4aNmzI4sWLOXbsmLubVUSLFi0YPHgwY8aMISMjg/DwcGbPno3VanXq7ips7969jB8/nuHDhxMdHU1qaiozZ86kdevW9mpMTEwM69atY926dYSEhNCgQQNCQkKIj4/nT3/6EwkJCfTo0YP8/HyOHDnCxo0bWbFihf0ZoaGhPP7440yfPh2LxcLLL79MWFgYcXFxAEybNo3Lly/Tq1cv+5T3TZs28frrrxfbbi8vr1te+Xnv3r1MnjyZoUOHEhkZSWJiIq+99homk4k///nP9rjf/e53zJgxg4cffpjp06dz5coVnn/+eR577LEKX6MGdFKjFcPiabF1P5V/SrcrLesG8mCbCD7YcpIRnSKpHWhxOq+U4uekK3S/K/SWntMhKohlu5I4cfEaDW9i0T9N0yrOyy+/TEpKClOmTAHg4YcfZv78+U4DcquLRYsWMWbMGJ577jn8/PwYO3Ys0dHRJVY0wsPDqVWrFjNmzODs2bPUqFGD3r17M3PmTHvMlClTSExMZNiwYaSnp7Nw4ULi4uKYOHEiERERzJkzhzfffBMfHx8aN27M8OHDnZ4RGRnJiy++yKRJk0hISKBDhw589tln9vE/HTt2ZM6cOXz++edkZGQQGRlpT5gqU0hICEopJk+ezKVLl/D396dXr16sXLmS+vXr2+PMZjNr167lmWeeYdiwYXh7e/Poo48ya9asSmmXVMZGhFrV6dChgyoYuV+Rpm+bzobDX7BZ6kPs1xV679OXM+n75iYebBPBrKGtnc6du5JF59f+TfzgZsR1LX3KYXGOJWfQb/Zm3nikFcM61rvVJmvaLTl48CBNmzZ1dzO0m5CXl0eLFi245557+Oijj9zShri4OPbt20dl/I6v7kr7mRGRXUqpIuUmXanRXLKarWSJqrCBwo7qBVuJ7RLJBz+cZGS3BjStHWA/9/NpozLUuow7cxcnOtSPGlYzuxJSdVKjaVqpli1bxtmzZ2nZsiXp6em8//77HD16lI8//tjdTdNugp79pLlk8bSQjeJGTsV2PxV4pncjAnzMvLbGeVT83qQ0PE3ilOiUh8kktK8fpHfs1jStTHx9fVm4cCEPPPAAv//970lJSeHrr7/m7rvvdnfTtJugKzWaSwU7dWfnZFAZEzADrWae6X0XM745yJajKXRvZKwHsTfpCjG1/fEx39z6CK60sw0WTr12vVy7hGuaducYOHAgAwcOdHcznDjuE6WVja7UaC5ZPa0AZF2/WmnPeKJLJHWDLLz2zSHy8xVKKfYmpdHqJjexLE7Bwnuf/JRQIffTNE3Tqjed1JSTiMSJiHLxGu0QIyLyooicFpEsEdksIkWWcRSRZiLynYhkishZEXlVRG69VHELLGajUpOl8iAvp1Ke4e3pwYQBTThwLp2V/3eGU5cySc/Oo3U5F90rrENkEANbhvPmhiPM+/ZomTZn0zRN0367dFJz6/oAnR1eyx3OTQKmAjOBwcBV4FsRsW9pKyJBwLeAAh4EXgX+ArxSFY0vTkH3U6apYvZ/Ks7gVhG0rBPI39cdZsdJY/xLRVVqTCZh/qNteaRdXeZ8e4TX1hzSiY3mNvp7T9PK5lZ+VvSYmlu3QylVpI9GRHwwkprXlFJv245tA04BzwBTbKGjAQvwsFIqHdggIgFAvIi8YTtW5ezdTwX7P/mVvAdKeZlMxoJ8v3//J15fewgfs4lGYRW3roynh4lZv2uFr7cHCzaf4GpOHtMfbIGHSS/Ip1Uds9lMVlYWVqvV3U3RtGovKysLs7l8i6/qSk3l6QIEAEsLDiilrgFfA/c7xN0PrCuUvHyOkej0rIJ2umSv1EjFL8BXWOeGIfSNCePyteu0iAjEs4TNLsvDZBJeeaA5T/dqyKf/SWTc0v8j90bx+7JoWkULCwvjzJkzZGZm6oqNphVDKUVmZiZnzpxxuZFnWehKza07LiIhwHFgtlLqPdvxGOAGcLRQ/EHAccnIGODfjgFKqUQRybSdq9iV78qoIKnJMlXcTt0lmXR/DBsPJ9O2fsXv2grGFg0T74vB19uTWesOk3n9Bm8/1hZvT7cOXdLuEAEBxhIFZ8+eJTc3182t0bTqy2w2U6tWLfvPzM3SSU35ncMYL7Md8AB+D/xDRKxKqTlAEHBVKXWj0HWpgFVEvJRS121xRfdlN+KCKq31pbCajTJ5plTumJoCjWr5s+LprkSFVO4OvmN734WftyfTVu3n/320k/ceb4/VS/8YaJUvICCg3L+oNU0rG/3bvJyUUuuAdQ6H1oiINzBFROYVhLm4VFycKy7OZZ1aRJ4CngKc9tioSL9WakxVUqmBW19FuKxiu0Rh9fLghS/38sSH2/kwriOBlvJvnqlpmqZVD3pMTcX6AggGojAqLf4upmbXADKVUgU16FTbscICcV3BQSm1QCnVQSnVoWbNyhnAa09qRCAno1Ke4U5DO9Tj7cfa8XNSGo+9/xOXrlbOtHVN0zSt6uikpnIo4BBGt9Rdhc7F2M4VOGQ7Zici9QDfQnFVqqqmdLvTwJa1WfBEB44lX2X4gp+4kJ7t7iZpmqZpt0AnNRXrEeAikABsBdKBoQUnRcSKsV7NGodr1gADRMTf4dhwIAvYVNkNLo6nyRMvkxdZnt5V1v3kDr2bhPHRyLs5l5bF04t365kpmqZpv2EVltTYVtjdJSIZIpIqIntEZLbD+TARiReRqIp6pjuJyJci8oKI3C8i/yUi/8JIRl5VSuUrpbKB14EXRWSsiPQFlmF8zd9yuNU/gBxguYj0s42XiceYSeXWbMJitpDl6VXpU7rdrVN0CJMGNmVXQio/ndAbYGqapv1WVUhSIyKTgQ8wBs4+DDwBfAU84BAWBkzDGG9yOzgMjAS+xEhWmgFPKKUcE5bXgRnAZGA1xro1/ZVSFwoClFKpQF+MrqqvMVYSnoPxtXIri6eFTE+v27pSU2Bo+7qE+nnz7vfH3N0UTdM0rZwqavbTM8B7SqkXHY59LSJuXeq/Mtk+64ulxCiMpGZGKXEHMLZbqFasnlayPDxv2zE1jnzMHvx3twbMXHuIX5Ku0LKC9p/SNE3Tqk5FdT/VAM4XPmj7o46ty+kX2+GNBZs/FsSJSLCIvCciF0QkW0S2isg9jveyXTNOROaJyGURSRORt0TEyyGmhoh8YNsUMltEEkXk/Qr6jHcci6eFLJPHHVGpARjRqT7+Pp78zyZdrdE0TfstqqikZjfwrIjE2lbXLewc8Afb/4/l180fsa3t8i3QH5gAPASkUGjjR5u/AHVt9/orxlotjlWQ2UA34HlgAEYlRY/8LCeLp4VMk+mOqNQA+PuYeaJzJGv2nedYcpHtvDRN07RqrqKSmrEYO1AvAlJEZL+IvGrbmBGlVA6w1xZ7QCn1k1LqJ9v7EUALYIBS6mOl1FqMWUTJGEmMowxgqFJqjVLq7xg7Wo8VkWDb+buBd5RSS5RSm5RSnyilnqqgz3jHsZqtZAm35To1xXmyawO8PU28t+m4u5uiaZqm3aQKSWqUUnuBphgDg9/FWA13KrBTRErbcrkfsAs4KSKeIlIwzmcT0KFQ7FdKKcedCJdjbPzYwvb+/4AJIvK0iDQu9wfSAFv3E9wx3U8AoX7ePNqxPiv2nOFsWpa7m6NpmqbdhAqb0q2UylFKfa2UekYp1Qz4f0Aj4L9LuTQU6ATkFno9CdQrFJtczPvatv8+A6wEXgYOi8hREXm0PJ9HK0hq8iE3E27cOZvw/bFHNADvbznh5pZomqZpN6PSFt9TSn0IXKbQarkuXAZ2Ah1dvIYUii28F3nB+3O2Z6YppZ5TSoUDrYH/AItFpFl5P8edzOppJbNgP847qAuqTg0LD7apw+fbT3P52nV3N0fTNE0ro4pap6ZwsoGI1MTYv6hgTZaCvw4+hUK/w9hKIFEptbPQ65dCsQ+KiGObH8ZYeXdf4efbusQmYHzG0hIrzQWLp4Wsgi2qbvMF+Aob0yua7LwbLPrxpLubommappVRRa1T84uIfAWsx+gSigTGA5nAR7aYRIwEJFZErgC5SqmdwMfAaOB7Efk7cAIIwRj0e14pNcfhOf7AMts07eYY3UxvK6UuA4jID8AKjCRHAX8ErgHbK+hz3lEsnhbyVD65gPkOGlcDcFeYP/c2q8Wiraf4Y49o/H30Lt6apmnVXUV1P72KsVLwfIzEZjqwH7hbKXUSwLZtwB+B9hiDgHc4HO8NbMBYTXc9MA9jPE7hZORNjK6mzzASmg9wXgBvGxCHsVv2UozxOvcrpZIq6HPeUaxmK3B7b2pZkqd73UV6dh6f/ifR3U3RNE3TyqBCKjVKqXeAd8oQtxhY7OL4FeBPtldJriulnsEYEOzq/hMwupy0ClCwU3eWmAi8wyo1AK3r1aDbXaF88MNJYrtE4WP2cHeTNE3TtBLoXbq1YtmTGpPcUQOFHT3dqyEpGTl8uVsX+zRN06o7ndRoxbJ62rqf5M7sfgLo3DCE1vVq8N6mE+TdyC/9Ak3TNM1tfjNJjVJKlFJvu7sddxKLuaBSY4KcO2v2UwER4eleDUm8nMn//nLO3c3RNE3TSvCbSWq0qmfvfvL0vmMrNQD9m9aiUZgf//P9cWx7tGqapmnVkE5qtGIVJDWZXtY7aquEwkwmYXTPhhw6n8G/DxVe1FrTNE2rLnRSoxWrYExNltlyR1dqAB5oE0GdGhbe1dUaTdO0aksnNVqx7N1PZp87ulIDYPYw8VSPaHYlpLL95GV3N0fTNE1z4Tef1IiIWUT0AiKVwN79ZPa6Y6d0OxresR6hfl68+/1xdzdF0zRNc6HKkhoRWSQiO0XkIRE5JCLZIvKD42aTImISkUkickxEckTkiIjEFrrP9yLyhYg8JSLHgWwgoqo+x53Ex9MHQcjy8Lrju58AfMwejOzWgE1HUhi7eDenL2dW6fOvZOby5MLtHLmgE0xN0zRXKmrvp7KKBGYDUzH2gXoFWCcijWzbJbwFxGJsu7Ab6A/8U0QuKaVWO9ynK9AQeAFjf6k7c75xJTOJCR9PH7JMnnd891OBP3aP5npePu9tOsGGgxf4724NeLpXwyrZG+qjbafYeDiFjg2CaVzLv9Kfp2ma9ltT1UlNKPCgUmorgIjsAo4DcSLyLTAGeFIpVbAJ5rciUhuYBjgmNTWAtkqp81XX9DuTxdNClnjoSo2N2cPEn/s15tGO9Xlj3SH+5/vjLNt5mr/c24RhHerhYZJKeW7W9Rss2noKgMPndaVG0zTNlaoeU5NckNAAKKUSgF0YO3L3BfKBFSLiWfACvgPaFBo3s0snNFXD6mklU0xwPQPyb7i7OdVGeKAPs4e14auxXYkK8WXy8l8YNH8LW49drJTnLdt1msvXrhMe4KOTGk3TtGJUeVJTzLHaGFUcD4yupFyH1yKMilJth2suVGorNTuL2UJWQfFBDxYuonW9Giwb3Zl3HmvH1Zw8HvvgP/zx452cvHitwp6RdyOf97ecoF39GjzUtg7HU66Sq7ds0DRNK6Kqu5/Cijm2H7gM5GGMl3H1G9sxIdILhVQRi6eFrNzrxpucdLDUcG+DqiERYVCr2vRtGsY/fzzJuxuPc++cTTzROYo/92t0y+Ntvtl3ntOXs5gyqBlZ12+Qe0NxIuUaTcL1uBpN0zRHVV2pCRORLgVvRKQ+0A7YDvwbo1ITqJTa6eJ1vYrbWmYiUkdEroqIEhE/h+MiIi+KyGkRyRKRzSLSxsX1zUTkOxHJFJGzIvJqdZmmbvW0kqlsOaYeV1MiH7MHT/e6i43je/G79nX5548neX7Jz7d0T6UU//j+OA1r+tK/aS17InNYz4DSNE0roqqTmovAv0TkMREZAvwvRgVmkVLqMPAP4HMReUFE+orIIBGZKCIfVHE7b9Ys4KqL45MwZnrNBAbbYr4VkfCCABEJAr7FqD49iDHz6y8YM8PczuJpIUvZxtLo7qcyqenvzWsPt2Ly/TF8e/AC6/eXf/jXlqMXOXAunVE9GmIyCdE1ffEwCYfP6wRT0zStsKpOahKACUA88DmQDgywTecGGAtMB54AvsEYTzMI2FzF7SwzEekO3Af8vdBxH4yk5jWl1NtKqW+BoRjJyzMOoaMBC/CwUmqDUuofGAnNOBEJqIrPUBIjqckz3uhp3Tflya4NiAn3J37Vfq7l5JXrHv/YdJxaAd482NZYisnb04PoUF89WFjTNM2FKl9RWCm1XCnVWCnlrZTqqpTa53BOKaXmKqWa287XVEr1VEp97BDTSyn1u6putyu2LqK3MKorhae9dAECgKUFB5RS14Cvgfsd4u4H1imlHDOGzzESnZ6V0OybYjVbycy39fzp7qebYvYwMWNIC85eyWbed0dv+vq9SWlsPX6J/+7WAG/PX3sjm4T7c0gnNZqmaUX85rdJcLPRgA/wjotzMcANoPBfs4O2c45xhxwDlFKJGIsKOsa5hcXTQtaNHONNjl7j8Ga1jwzm93fX48MfTnLw3M0lhf/YdBx/H09+f3d9p+Mx4f4kpWZxtZzVH03TtNuVTmrKSURCMLrKximlcl2EBAFXlVKFF3dJBawi4uUQl+bi+lTbObeyeFrIyss2ppvpSk25vHBfDIEWMy+t+IX8/LJN3Dt58Rpr9p1nRKfIIrOnmoQbvZK6C0rTNM1ZlSU1Sqk4pVSHqnpeFZgB/Ecp9U0JMa7+gomLc8XFufwLaNv3aqeI7ExJSSlTY8vL4mlBocj2MOsxNeVUw+rFSwObsjsxjSU7T5fpmve3nMDsYeLJrlFFzjWxbZGg94DSNE1zpis15SAizYGRwCsiUkNEagBW2+lAEbFgVFr8XUzNrgFkOlR3Um3HCgvEdQUHpdQCpVQHpVSHmjVr3urHKZHV0/hYWd7+ulJzCx5uV4d7GgTz+ppDXLyaU2JsckY2X+xK4pF2dQnz9ylyvm6QBauXh67UaJqmFVKlSU3BDttV9KyLIhJfSbdvBJiBbRhJSSq/jqtJwhg8fAhj3Z27Cl1beAzNIQqNnRGReoBvoTi3sHhaAMiy+Osp3bdARJgxpAWZ1/P42zcHS4xd9OMpcm/k81SPaJfnTSahcS1/Dulp3ZqmaU6qulLzNDC5ip9ZGX4Aehd6zbSdG4ixbs1WjCnrQwsuEhErxno1axzutQYYICKOy8MOx9jFfFMltb/MLGZbUuPlp7ufbtFdYf6M6tGQ5bvPsPW46z2iMrJz+ddPCdzfIpwGob7F3ism3J/D5zNQSi+urWmaVqBKkxql1AGl1M3Pba1mlFIXlVLfO774taqyRSl12Lb2zuvAiyIyVkT6AsswvuZvOdzuH0AOsFxE+onIUxjr+MwuNM3bLQq6nzK9fXX3UwV4ps9d1A+2MmXlPnLyim4Q+tn2RDKy8xjVo2GJ92kS7k9qZi4pGSV3ZWmapt1JypzUiEg3EdlkW8r/koi8X1BdEJE42xYBimk5kwAAIABJREFUHUVki21LgCO2VYMd7+HU/SQidUVkqYgk2645LiLTC10zTER+EZEc23YDM2y7dzvG9BCRn0UkW0R2OW7FUCjuQdsA22wROS8ib4jIrW3MU7LXMQYUTwZWY6xb018pZd+QUymVirFDuQfGGjavAHOAaZXYrjKzdz+ZLbpSUwF8zB68+mBzTqRc4/3NJ5zO5eTd4MMfTtI5OoTW9UreY6sit0vIztW7r2uadnsoU1IjIl2B74DzwO+AP2N0sywsFLoE+Ap4GPgFWCYirUu49cdAPeApjEXoZgDeDs+913bP3RhbCLwFjAfedoiJwOjCuWxr23vAYn4duFsQNwxYjrHP1AMYycNTwGtl+RqURim1SCklSqmrDseUUmqGUqquUsqilOqulNrj4toDSqk+tpjaSqmpLqaCu4V9oLDZR1dqKkivJmEMalmbt/59jIRLv+7m/dWes1xIz2F0r5KrNPDrDKhbHSy85WgKrV5Z79QOTdO036qy7tL9OrBVKTW84ICInAG+E5EWDnEfKKX+bju/DjiAUaV4tJj73g38Xin1te3994XOvwp8r5SKtb1fKyIAr4nIX5VSSRgJVjYwSCmVaXv2NeATh7YKxjiXj5VSTzsczwHeEfn/7d15fBv1nfj/13t02JLP+MhJTickhJumlAQopVAgtJQesGz7bbfHdtluD7oLWwpsKZSF7Q1tYbu0S3fpdn/d0oMe3AVazpBAKOVOgDiBEHI4sXPYkmVJ8/79MSNHlmVb8hFJ5v18POYhaeYz4894ZPmtz+c9n498TVV3FfareHPJ5NTEgmEbfG8cXf6epTz4Ugdf+d3z3PyJt6IKNz60gaUz6nn7opYR92+uraKltmrMIwvf98J2+lIuD6zv4GMrhs7hMcaYSjBiS42f3Loc+IWIBDMLXrJsEnhLVvHfZJ6oqovXanPsMIf/C16A8nF/xu7snxvAm8H7lzn73OLXe7n/+ljg3kxA47s1Z5+DgTl5zuGPeCMCH4bJq7+lJhjy7n6yxNRxMb2hmotOO5gHX+rgzme3cd+L22nv6OHvT1qAH7iPKJMsPBZrNnYC8Mgr+ROXjTGmkhTS/TQFL9/jB3hBTGZJ4N3WPDur7I6cfXcAM4Y59nnAWrwckldF5C9+Qi1Ai3/87Tn7ZF43+Y/Tc3+uqsYZOGt25qvvnTnnsNFfn30OJkt/Tk0gCOpCX77JyM1ofPS4uRw2q56v3vY81//xFWY3RXj34cP9uQy0eHodL23fR7rAUYpzdfb0sW7bPsIBh9Xtu0il3VEdxxhjykUhQc1uvJFtrwDemmf5r6yyU3P2nQpsHerAqrpFVT8ONOO1vGwDfu9PQbATL/DIPeY0/7HTf9yWW8Yf/K42a1Wm7PlDnEP2LdYmS//dT44/hqCNVTNuggGHa953OB3dCZ7dsoe/O3EBwUDhNyQunl5HIuXyWmds5MJ5PL7R63H98NvmsK83xXNvWM6UMaayjfgJ6s8svRpYrKpr8yxvZBXvv9tJRBy85N7HC/gZrqquxkvejQJz/UTZJ8ka58X3V4CLN/AdwBPAu/xusowP5OyzHtgCzBviHCyfZgihQIigBIk7fpeIJQuPqyNnN3L+2xcwtznKuW8prsFwf7Lw6K7J6vZOqkMOnz7JS0x+1LqgjDEVrtBE4YvxkoJd4FfAPrwclXcD/5JV7lMi0gc8B/wd3mi6H8p3QBFpAO7BuwPqJby7ni7Ca3nJDLl6BXCPiPw38HPgcLxJJP/TTxIG+C7wWeB2EbkWmImXnBzP/CxVdUXkIuCnIlKP1zLTBywA3geck5OTY7JEghHimTwPu6173F268hC+eNriolppAA6eVocIrNu2jzMOK7zbKmN1+y6WzW1iekM1h8yo59FXdvLZk3MHwDbGmMpR0Keoqj4CvB1oBX6KN57KxcBmBua8/DVea81vgSOB8/Ldwuzrxbvt+wvA74GfADHgND8nBlX9g3/MZf7P/EfgO8Dnsuq2Be/28hbg13ijFn/EP1b2OdyC13J0FF7y8a1+2T/jBThmCJFQhFhmbk1rqZkQxQY0AJFwgLlN0VElC3f5+TTHLfBS045va2btq102Zo0xpqIV2lKDqq4Bzsi3LetujRdU9fhhjvGOrOcJvNackX7uLXh3PA1X5gHgiJzVg+6LVdW7sPyZokWDUeL4SaR2W3dZWTzKO6Aydz0dt6AZgOMXtXDTIxtZu6mLEwq4pdwYY8qRzdJtRhQJRoi7/jd4a6kpK4un17NpV0/RLSyr23dRHXI44iBv5OJj5zURdIRHh5iTyhhjKoEFNWZEkWCEuCa9F5ZTU1YWT6vDVXhlR3G32q9u38Vb5k4hHPQ+Amqqghw9p5FVlixsjKlg4xLU5JsiwEwekVCEWLoPxLFbustMZg6oYkYW3h3rY/32fRw3v3nA+uMXtvDMlj3siSXHtY7GGHOgWEuNGVE0GCWeikNVnXU/lZl5zVHCQaeo27rXbOxEFY5rGxzUqMJj7TbCgTGmMllQY0YUCUb8oKbBup/KTDDgsGhqbVEtNfvzaRoGrD/yoEai4YCNV2OMqVgW1JgRRYIRYqkYVNdbS00ZKvYOqNXtnbxl7hSqgoEB68NBh7fNb7JkYWNMxbKgxoxof/dTvbXUlKEl0+vYsS9BV8/Iwy3tjvWxbtte3paTT5Nx/MIW2jt62Lonnne7McaUMwtqzIgiwQiJdIJ0VR302jg15ebgzHQJ20durXk8k0+zYOigBuDRVyyvxhhTeSyoMSOKhrxpteJVUWupKUNLptcDFNQFtbq9k6qgw5GzG/JuXzytjuaasN3abYypSBbUmBFFghEA4uEay6kpQ9Pqq2iIhApKFs6MT5ObT5PhOMLytmYe3bATVR3vqhpjzISyoMaMaH9QE/HGqbF/dmVFRPxk4eEDzt2xPl7ctnfIrqeMExa2sH1vgg0dNuyUMaayWFBjRhQNet1PsWAVuElI9Za4RibXkul1vLS9e9jWlZHyaTIsr8YYU6ksqDEj6m+pCVV5K6wLquwcPK2O7kSKLbuHvmtpzcbh82kyZjdFmd0U4RHLqzHGVBgLasyIIiE/qAmEvRWWLFx2lvjTJQyXLLy6fRfHzBk6nybbCQtbWN2+i1TaLbouNz+6kbOufwTXtW5KY8yBZUGNGVF/91Mg6K2wlpqyc/AIc0DtiSV5YevI+TQZK9pa2Neb4rk3irvWr3fF+Prd63h2yx5eLGLqBmOMGQ8W1JgR9Xc/Of7bJWFj1ZSb+uoQsxojQ7bUPL4pk0/TVNDxVvjzQhU7ZcLVt7/Yn0f+2AbLyTHGHFgW1IySiJwjIqtEZJeI9IrIehH5soiEs8qIiFwmIptFJC4iD4nIUXmOtVRE7heRmIi8ISJXicjIfQQHyP6gRrwV1lJTlhZPr+OlIQbgW9O+y8+naSzoWM21VRwyo76ooOahlzq4+/ltXHDKIha01rDKghpjzAFmQc3oNQN/Aj4FrAT+C/gX4NqsMpcAlwPfAM4CuoH7RGR6poCITAHuAxQ4G7gKuAj46sSfQmH6B98TP6hJFD7PkDlwFk+vY0NHN8k8eTCrN+7i6DmNVIcKj5WPb2tm7atd9CbTI5ZNpNJc+fvnmd9Sw6dOnM/yBc08vrFzVDk5xhgzWhbUjJKq/lBV/0VVf6Oqf1LVb+AFNB/xW2iq8YKar6nqDap6H3AuXvDyuaxDfRqIAB9Q1XtV9Ua8gOZCEak/sGeVX3WgGoAYfr+CJQqXpcXT6kimlfaOngHr98STPP9G4fk0GccvbKEv5bJ2U9eIZX/8yEbad/ZwxVlLqQoGWNHWQncixbNbrKvSGHPgWFAzvnYBme6nFUA98IvMRlXtAW7Da9nJWAnco6rZkcLP8QKdkya0tgUKOAGqAlXE1f/Gbt1PZWlxf7LwwOvzRIHj0+Q6dn4TQUdGnLX7jd1xrr//FU5bOo13LJ4K7M/dsS4oY8yBZEHNGIlIQESiInICcAHwH+qNgLYESAMv5+zyor8tYwmwLruAqr4GxHLKlVQkGCGW7oVwnbXUlKm21lqCjgxKFl7dvotw0OGoAvNpMmqqghw9p3HEvJpr7ngRRbn8PUv71zXXVrFkep0lCxtjDigLasaux18eBh4EvuivnwJ0q2puQkIXEM1KKJ4C7M5z3C5/W1mIBqPEU3GorreWmjIVDjosaK0ZFNSs2djJMUXm02Qcv7CFZ7fsYU8smXf7Iy/v5I5nt/LZdyxkdlN0wLblbc08samTRGrknBxjjBkPFtSM3QrgRLzk3rOBG7K25Rt9TPJsG6pc3tHLROR8EVkrIms7OjqKr/EoRIIRL6ipqrdbusvY4un1rM+6A8rLp9nD2+YX1/WUcfzCFlThsfbBLS59KZev/P455jZH+bu3Lxi0fUVbC4mUy19eyxezG2PM+LOgZoxU9c+q+oiqXovX/fQPItKG19JSl+fW7EYgpqqZr75d/rpcDeRvwUFVf6Sqy1R1WWtr6/icyAgiwQixVAyq6qylpowtnlbL611xuhMpANZu6sQdRT5NxpEHNRINB/J2Qf3Xoxtp7+jhyrMOzdsKdOz8JhyxvBpjzIFjQc34+rP/OB8vTyYALMwpk5tDs46c3BkRmQ3U5JQrqWgoSjzpdz9ZTk3ZWjzdu2Eu0wWVyac5ek5x+TQZ4aDD2+Y3DUoW3ronzvfvf5lTD5nGyUum5t23IRLi8FkNlldjjDlgLKgZX8f7jxuBVcBevNu4ARCRKN54NXdl7XMXcLqI1GWtOw+I4+XolIWB3U82Tk25yp0DanV7J0fPHl0+TcbxC1to7+hh6579k2Vec8eLpF3lirOWDrMnHNfWzFObu4j3WV6NMWbiWVAzSiJyt4j8s4isFJHTROSrwHeAW1R1g6r2Al8HLhORz4rIKcAv8X7n12cd6kYgAdwqIqeKyPnAlcC1Obd5l1R/UGOJwmVtVmOEmnCA9dv2srfXy6cZbddTxoq2FgAefcVrcVm1YSe3P7OVf3hH26Dk4Hz7JtPK2lc7x1QHY4wpRLDUFahgTwAfB+YBKaAduBQvSMn4Ol4QcyneCMRrgXep6vZMAVXt8gOeG/DGsNkNXIcX2JSNaChKLBmDGut+KmeOIxw8vY712/eNOZ8mY8n0Opprwqx6ZSdnHzWTK373PHOaonz6pLYR933rvCkEHWHVhl2cuOjA5H8ZY968LKgZJVW9HG8KhOHKKHCNvwxX7gXgneNXu/E3oKUm1QupPgiGR97RHHCLp9Vxz/PbeGzDLsKB0efTZDiOsLytmUc37OTmRzfx8o5ufvyxZQV1aUXD3lg3lixsjDkQrPvJFGR/Tk2Dt8Jaa8rW4ul1dMWS3PnsNo4a5fg0uY5f2ML2vQm+dc96TlkylVMOmVbwvssXNPPs67vZ25t/rBtjjBkvFtSYgkSDUVKaIulPbkmvjVVTrjLTJWzZHR9z11PGCQu9vBoErjjr0KL2Xd7WgqvedA3GGDORLKgxBYkEIwDEwlXeCmupKVtLpu+fBzUzB9NYzW6KcsqSqXzpjCXMaR4+OTjX0XMaqQo61gVljJlwllNjCpIJauKBMA1gd0CVsaaaMK11VeyJJTlmzvjNtPHjj791VPtVhwIsmzfFghpjzISzlhpTkKjf7RQL+cnBNlZNWTt2fhMnLGoZl3ya8bB8QTMvbt1LZ09fqatijJnErKXGFKS/pcbx/0la91NZ++55R6F5Zw4rjeVtLcBLrGnfxcrDZ5S6OsaYScpaakxB+nNqAn4cbN1PZS0UcAgHy+fP+4iDGqgJB6wLyhgzocrnU8+Utf6WGvEnGbeWGlOEUMDh2PlNrNoweGJMY4wZLxbUmIJEg35OjZuAUNRu6TZFW97WzIaOHrbv7S11VYwxk5QFNaYgkZDfUpOMQ1WdtdSYomXmkFrdbl1QxpiJYUGNKUh/91Nmpm7LqTFFOmRGPQ2REKtesaDGGDMxLKgxBenvfkrFvPmf7JZuU6SAIxy3oIlV7ZZXY4yZGBbUmIJUBaoQZH9LjXU/mVFYvqCZzZ1xNnfGSl0VY8wkZEGNKYiIDJyp27qfzCis8OeQeszyaowxE8CCGlOwaChKLBmzlhozaoum1tJSG+YxG6/GGDMBLKgxBdvfUtNgLTVmVESE5W0trNqwEy2nIY+NMZOCBTWmYP1BTVUdJHsgnSp1lUwFWr6gme17E7Tv7Cl1VYwxk4wFNaZg0WB0f6IwWBeUGZUVbc0A1gVljBl3FtSYgkWCkf23dIMFNWZU5jZHmdlQbUGNMWbcWVBjCra/+ykT1NhYNaZ4IsJxbc081r4L17W8GmPM+LGgxhQsGop60yRkWmosWdiM0oq2Fjp7+li/3QJjY8z4saDGFKy/+8lyaswYLbe8GmPMBLCgxhRswC3dYC01ZtRmNUaY1xxllQU1xphxZEGNKVgkGKE31YsbrvVWWEuNGYPlbc2sad9FKu2WuirGmEnCgppREpFzReT3IrJFRLpF5EkR+VBOGRGRy0Rks4jEReQhETkqz7GWisj9IhITkTdE5CoRCRy4sylMNBRFUXqDYW9F757SVshUtOVtLexLpHj+DQuOjTHjw4Ka0bsQ6Ab+CXgv8CfgZyLy+awylwCXA98AzvLL3yci0zMFRGQKcB+gwNnAVcBFwFcPwDkUJRKMABDHhUDYWmrMmKxoayYUEH7+xOZSV8UYM0kES12BCnaWqu7Mev1HEZmJF+xcLyLVeEHN11T1BgAReQzYBHwO+LK/36eBCPABVd0L3Csi9cCVIvJNf11Z6A9q+mfqtjtXzOi11Fbx4WPn8L9rXuP8ty9gfktNqatkjKlw1lIzSjkBTcZTwFT/+QqgHvhF1j49wG3Ayqx9VgL35AQvP8cLdE4azzqPVTQYBdg/AJ8lCpsx+tw7FxEOOFx770ulrooxZhKwoGZ8rQBe8J8vAdLAyzllXvS3kVVuXXYBVX0NiOWUK7kBLTWRJujeXuIamUrXWlfF354wn9uefoPntliOljFmbCyoGScicgpeTsy/+6umAN2qms4p2gVERSScVW53nkN2+dvy/azzRWStiKzt6OgYe+ULNCComXMcbF4DfTYpoRmbv3v7AhoiIb79h/WlrooxpsJZUDMORGQe8DPgd6p6c9amfGPAS55tQ5XLO4a8qv5IVZep6rLW1tai6zta0ZDX/RRPxmHhKZDug02PHrCfbyanhkiIf3hHGw+s72BNu41bY4wZPQtqxkhEmoC7gNeAj2Rt6gLq8tya3QjEVDWZVa4xz6EbyN+CUzKZlppYKgZzVkAwAq/cV+JamcngY8vnMa2+im/esx5Vmw/KGDM6FtSMgYhEgduBMPBuPxE4Yx0QABbm7JabQ7OOnNwZEZkN1OSUK7kB3U+haph/ogU1ZlxEwgEuOGURT77axR/X7Sh1dYwxFcqCmlESkSDwS2ARsFJVcz+JVwF7gXOz9onijVdzV1a5u4DTRaQua915QBx4cAKqPmr93U+puLdi4bugcwN0tpewVmay+Ktls5nXHOVb96y32buNMaNiQc3o/QA4E/hXoElEjstaqlS1F/g6cJmIfNZPJP4l3u/8+qzj3AgkgFtF5FQROR+4Eri2nMaogazup2TMW7HwFO/xlftLVCMzmYQCDheetph12/bx+6ffKHV1jDEVyIKa0TvNf/we8FjOMsPf9nXgGuBSvG6qeuBdqtp/L7SqdgGn4HVV3YY3kvB1wBUTfwrFCTkhgk5wf0tNcxtMmW9dUGbcvOfwGSydUc937l1PX8rmhDLGFMeCmlFS1XmqKkMsm/wyqqrXqOpBqhpR1RNV9ak8x3pBVd/pl5mhqpfnuRW8LESD0f1BDcDCU2HjQ5BKlK5SZtJwHOGLZyxmc2ecW554rdTVMcZUGAtqTFEiwYh391PGwlMhGYPXHitdpcyk8o6DWzl2fhPfu/8VYn2pUlfHGFNBLKgxRYkEIwNbauad4E1uaV1QZpyICF86YzE7uxP896ObSl0dY0wFsaDGFGVQUFNVC3OWW7KwGVdvmdvEKUumcuODG9gd6yt1dYwxFcKCGlOUaCi6/+6njIWnwo4XYM+W0lTKTEr/fPpiuhMpbnzQhgwwxhTGghpTlEEtNQCL3uU9WheUGUeHzKjn7CNncvOqjWzf21vq6hhjKoAFNaYoeYOa1iVQP8uCGjPuLnzXYlJp5fv35052b4wxg1lQY4oSDUYH3v0EIOINxNf+AKSTefczZjTmNEf50LFzuOWJzWzaaTPCG2OGZ0GNKUrelhrw8moSe+H1tQe+UmZS+/w7FxIKOFz2m2fZ1W3jIRljhmZBjSlKJBQhnswT1Mw/CSRgXVBm3E2tr+by9yzliU2dnHrtg/zmqddtJm9jTF4W1JiiRINR+tw+Um7OoGiRRph9rAU1ZkJ8+G1zuOOCE5nfUsM/3fI0H/vvJ9jcGRt5R2PMm4oFNaYomUkt83dBnQJb/wLdHQe4VubN4OBpdfzq0yu46uxDeXJTJ6dd9xA3PdxO2mb0Nsb4LKgxRRk+qDnVe9xgA/GZieE4wt8sn8e9F57EirZmrr7jRT7wg0d54Y2ymtDeGFMiFtSYokRDUWCIoGb6kVDTal1QZsLNbIxw08eWcf2HjmbL7jjvveERvnn3OnqTZTkPrDHmALGgxhQl01IzaFRhAMeBtlO8KRNc++diJpaIcNaRM7nvwpN4/9Gz+MEDG1j5vYd5bMOuUlfNGFMiFtSYogzb/QReF1S808utMeYAaIyG+da5R/K/f/s20q7y4ZtW89BLltdlzJuRBTWmKNHgMN1PAG0nA2ITXJoD7oRFLdz9jyfS1lrLpbc+y75eGwjSmDcbC2pMUfq7n3JHFc6oaYGZR1tejSmJaDjIN885gq174nztrnWlro4x5gCzoMYUZcSWGvC6oF5/AuJdB6hWxux3zJwp/O0J8/nZmtdY9crOUlfHGHMAWVBjihIJ+Tk1+UYVzlh4KqgLG/50gGplzEAXnbaY+S01XPzrZ+hJpEbewRgzKVhQY4qSaakZsvsJYNZboLrB8mpMyVSHAnzznCPYsjvON++2bihj3iwsqDFFqQ5WAyN0PwWC0PZOL6/G5ugxJfLWeU18bPk8fvLYq6xut9u8jXkzsKDGFMURh+pA9fBBDXhdUN3bYPvzB6ZixuRx8RmLmdMU5Uu/foZ4n42dZMxkZ0GNKVo0FB05qGk7xXu0u6BMCUXDQb7xwSN4dVeMb92zvtTVMcZMMAtqRklEForID0XkaRFJi8gDecqIiFwmIptFJC4iD4nIUXnKLRWR+0UkJiJviMhVIhI4ICcyCpFgJP+IwtnqZ8C0wyyoMSW3vK2Zjx43l/9etZG1mzpLXR1jzASyoGb0DgXOBF7yl3wuAS4HvgGcBXQD94nI9EwBEZkC3AcocDZwFXAR8NUJq/kYRYKRkVtqwJu1+7XVkNg38ZUyZhiXrFzCzIYIF//qGZsfyphJzIKa0btNVWer6rnAoMQREanGC2q+pqo3qOp9wLl4wcvnsop+GogAH1DVe1X1RryA5kIRqZ/wsxiFaLCA7ifw8mrcJGx8aOIrZcwwaqq8bqj2nT1ce+9Q30GMMZXOgppRUlV3hCIrgHrgF1n79AC3ASuzyq0E7lHVvVnrfo4X6Jw0PrUdX5FgZPhbujNmHwfhWuuCMmXhhEUtfOjY2dz0cDtPvWYDQxozGVlQM3GWAGng5Zz1L/rbsssNGEhDVV8DYjnlykbB3U/BMMw/yW7tNmXjsjMPYXp9NV+0bihjJiULaibOFKBbVXM/ObuAqIiEs8rtzrN/l7+t7ERCBQY1AItOhd2v2a3dpizUVYf42geP4JUd3Xz//tzvG8aYSmdBzcTK1zwhebYNVS5v84aInC8ia0VkbUdHxxirWLxoMDry3U8Zh7wXnCA8c8vEVsqYAp10cCvnvuUgbnxwA8+8nu/7hDGmUllQM3G6gLo8t2Y3AjFVTWaVa8yzfwP5W3BQ1R+p6jJVXdba2jpuFS5Uwd1P4M3avfBd8OwvwbXmflMevvyepbTWVXHJr58llR4pPc4YUyksqJk464AAsDBnfW4OzTpycmdEZDZQk1OubGSCGi00T+bI82DfVtj44MRWzJgCNURCXHHWobywdS8/eezVUlfHGDNOLKiZOKuAvXi3cQMgIlG88Wruyip3F3C6iNRlrTsPiANlGQVEQ1HSmqbP7Stsh4NXQlUDPG1dUKZ8rDxsOu9Y3Mq1f1jP1j0FtjwaY8qaBTWjJCJRETlHRM4BZgGtmdciElXVXuDrwGUi8lkROQX4Jd7v/PqsQ90IJIBbReRUETkfuBK4Nuc277IRCUYAiCcL/EcQqoZD3wcv3gaJ7gmsmTGFExGueu9hpFzlqtteKHV1jDHjwIKa0ZuKF6T8EjgOWJr1eqpf5uvANcClwO1449a8S1W3Zw6iql3AKXhdVbfhDbx3HXDFATmLUYgGo8AIM3XnOvKvIdkD626foFoZU7w5zVEuOGURdz23jT+t21Hq6hhjxsiCmlFS1U2qKkMsm/wyqqrXqOpBqhpR1RNV9ak8x3pBVd/pl5mhqpfnuRW8bGRaagoagC9j9nHQOAee/vkE1cqY0fm7ExfQ1lrDV37/nM3kbUyFs6DGFK2/+6mYlhrHgSP+2ksW3rt1gmpmTPHCQYer33c4mzvj3PAnG7vGmEpmQY0p2qiCGvC6oNT1bu82powsb2vmA8fM4kcPtfPydpuA1ZhKZUGNKVo0NIqcGoDmNpi1zLqgTFm67MxDiIaDfPm3zxU+XEGOXd0JXNemBDGmVCyoMUXrz6kpdFThbEf+Nex4HrY9O861MmZsWmqruGTlEtZs7OTWP28pat+0q1x370u89Zr7+Nh/P07HvsQE1dIYMxwLakzRRt39BHDYB8EJWWuNKUvnLZvNMXMauebOF9kdK2wcpm17evnwf67me/e/zAmLWnnxe/N6AAAaSElEQVR8Yycrv/cwj76yc4Jra4zJZUGNKVrmlu6i7n7q37kJFp3m5dWkU+NcM2PGxnGEq993OHviSb5x98gDev9x3XZWfu8hnt2yh++ceyT/88lj+f3nTmBKNMRHfryG7/xhvU3DYMwBZEGNKVokNIaWGvC6oLq3w8YHxq9SxoyTpTPr+eTx8/i/xzfz5Kudecv0pVyuvv0FPnnzWqY3RLjt8yfwwbccBMDi6XX87nPHc+5bDuL6P77Ch/9zjY1YbMwBYkGNKVrYCeOIM7qcGoCDT4fqRps2wZStfzz1YGY0VPMvv3mOZE5Ly6u7ejjnxlXc9MhG/mb5XH7zmRW0tdYOKBMNB/nmOUdy3XlH8twbezjzew/zx3XbMcZMLAtqTNFEhGgwOvqWmmAVHPp+b3ThhN0+a8pPTVWQK846lHXb9nHzo5v619/29Bu8+/uPsGlnDzd+5C1cdfZhVIcCQx7n/UcfxO2fP4EZDRE+efNarrnjBfpS1h1lzESxoMaMSmam7lE78kOQjHnzQRlThk4/dBqnLJnKdfe9xIaObi759TN8/v+eYvH0Ou78womccdj0go6zoLWWWz+zgr9ZPpf/fHgj5/7wMTZ3jrKV0xgzLAtqzKhEgpHRJQpnzD4Wpsy3u6BM2RIRrnzvobiqnPHdh7hl7WY+8442fn7+cRw0JVrUsapDAa46+zD+4/8dQ3tHN2d+/2FueeI1Yn2WLG/MeLKgxoxKNBRlS/cWXB1lU7oIHHEebHwI9hQ3JogxB8rspiiXnXkI0xuq+Z9PHsvFZywhFBj9x+bKw2dw5wUn0tZay5d+/SzLrr6PC2/5Cw+91GF3SRkzDmS0I2ea8rBs2TJdu3btAf+5P33hp3zziW9y7sHncvlxlyMixR+ksx2+fzSceiWc8E/jXUVjypbrKk9s6uS3f9nC7c9sZV9vita6Kt575Ezef/QsDp1ZP7q/KWPeJETkSVVdNmi9BTWVrVRBDcD3/vw9bnr2Jj669KN8cdkXR/ch/OPToHcvfOYxr/XGmDeZ3mSaB9bv4DdPbeGP63aQTCsLp9by/qNn8d4jZzK7qbiuLmPeDIYKaoKlqIyZHC44+gLiqTg/feGn1IRq+OxRny3+IEecB3dcCNuegRlHjn8ljSlz1aEAZxw2gzMOm8HuWB93PruN3z61hW/ds55v3bOeY+c3ccE7F3HCopZSV9WYsmdBjRk1EeHit15MPBXnxqdvJBKM8MnDPlncQQ59P9x9iTdmjQU15k2uMRrmw2+bw4ffNofNnTF+//Qb/GzNa3zkx2t4+8GtXHLGEpbOrC91NY0pW5YobMbEEYevHPcVVs5byXVPXsf/rfu/4g4QbfIG47NpE4wZYHZTlM+evJD7LzqJL7/7EJ7evJt3X/8wF/7iL2zZbSMUG5OPBTVmzAJOgGtOvIaTZ5/Mv635N377ym+LO8ARfw09O6D9TxNTQWMqWHUowKdOXMBDXzyZ809cwO3PbOXkbz/A1+56kT2xZKmrZ0xZsaDGjIuQE+LbJ32bFTNXcMWqK7h7492F77zoNIhMsTFrjBlGQzTEpWcewp/++R2854gZ/Oihdt7+rT9x08PtJFLpUlfPmLJgQY0ZN+FAmO+e/F2Oaj2KSx++lAc2P1DYjsEwHPZBWHeHdyeUMWZIsxojXPtXR3H750/giIMauPqOF3nntx/kt09tGTRPlTFvNnZLd4Ur5S3dQ+nu6+ZTf/gUL3e9zA2n3MDymctH3mnzE/DjU2HR6TD/RJh6CLQeAvUz7VZvY4bx8MsdfO3Odbyw1ftCEA44RMIBov1LcNDruuogMxsizGyMMLOxmllTIrTUVOE49rdmKoONUzNJlWNQA7AnsYdP3PMJXt/3OjeeeiPHTDtmUBlVRVHvUV244yJ46W6c7u0IIABVDV6AM2BZCjUtkE5CX0/W0u09JmNZz+PgBCBQ5U2kGazyn4chWD3wuTigCqj3qO7+59nrRCAQ9o9X7T+v9l47Q09uiJv26pPq9R8TkIpDshfcTG6EkFKXhJuiV5Mk0kl6NUXCTZJw+0homkAoSjhcT7iqnnB1A6FQhLATJhzwlpATIuSEynbwNlddYskYPckeYqkYISdEJBghGopSHagu23qPi3TKe38m4957KfOeDFYP/94Zgesqdz+/jVd2dBPrSxPrSxHrSxPPfp5M05NIEe9LsyeepKdvYJdVOOAwo7G6P9iZ1VjNjMYI4YCDq4oqpFVxVXHV+/t1Xe+5q4qIEA46VAUcQkEhHAgQDjreEvAeq/wlEg5QWxWkpio4phGah6KqxJNp9sZT7O1NsjeeZF+v97wqGKAhEqI+EqS+OkR9JERdVdACujFSVdKukkwrfWmXZGZJea/nNkfH9VpbUDNJlWtQA7AzvpNP3P0JNu3dhCMOmfeaUvh7zgFEQVAEcFT3BzxZhnvt+Ps77O9vdRSczDH918VQwBXvMbOri6CCf1TQzD9nVSTrnEUH1lFQ0iIk/CU1Tv/Ug0AAwUEIAg5CYIh1A89M959U5ol/7QJAECGEQ1DEey4OQRxCIgQlQBAHBGKaokddejRNjDTduPSoS1yG/mWLQgSIqviP9D+GECRz9QUEB8RbJyL9z0H837d3HuLXX/zANHMtRNU/Hwip/wgENefRP+80DklHSPvXKC0OKRGSIqTBWwekNE3STZFyUyQ1TVLTpNQlqS4plKQISe8UqHaVsCrVqlQBVTjeIgGqJUCVEyQsAS+QQEnjeoEFSkpdXCCN4qrrPSK4IrgCaQT16+Q9eu/PtP8bEBFQQfsXUBXSLrgKqXTmd+0iuIi4gAviBfva/+gtoP7fmn8VVPy/N/H+htU7XubvLQAElP73Yua9lbkmQf9c+kRIikMf3u86Cf2/w8zrNN5ng6PguN5jQJWAf10DCkFVgnh/n2mc/YsKaQl4X2qcADgBHCeAiOBomoCmcTRNUNMEGPjce3RJCfTh1bXPEZKZuvp1TAkk/T/roHrnFtTMcwip9D8P+r8b7b+Wjn9dHVwBV5z+bSqCiP/7FO+TJ4D3Hg/gf7ah3medCA4BRBxE/E8C8X7jKkFEvN+64tDnJul1E/S5fSTcPvpIkdQkfaS95+LSJ15XZ0AhoJL1mPtcCCBc/J6bWDr/8CH/9otlg+9NUr29vaxfv37AuqamJlpbW3Fdl5dffnnQPi0tLTQ3N5NKpdiwYcOg7a2trTQ1NdHX18fGjRsHbZ82bRqNjY309vby6quvDto+Y8YM6uvriWqUy9suZ9Ubq0i5KcT/pxOaEiJQHcDtdUnt9m7jlqwwJNgcREJCKp4iuTvpB0OKm+yFxF6c4HbQbtxUFLevBhUHnKC/BHCaQEIh3EQINxYAdVFN47pp0DRuQxxIozFwYw6qadRNk/kH7tbHwAGJh5FEOCdiEtzGHkQViYVwEt7xHXW9f5iaRmp3I5qGWATSVf0florjfVo19KISgHgNmg6CeB80IQkSDjrUNgnVTgh3b4hAKkDIcQiK988tEgrQUJekL9nDzp299CYSpFIJUm6CVDqJSwwn1EFfOkFvvBHXDZIGXFFcQAMJ3HCX94+utxVXHfqzMES87VV7QYRAfCr9YaB4YWU6GCMR2ksKJdDTQholjZJQiKHEQt3sC+0GFabHp1ONUI9QjUM1QnUoTl04QVRDaKKFMI4X0KmSECUd7qEvFCPmCn2xRhK4JFD6UGK49Ib2kgzFkVSAmkSzHyBrfxwWD+8mGYgTcMNEE839V029S0d31W5SgT6C6SqifY39QUHaf9xZtYtYIEEgVcWUvimD3ts7gztJBpJEU1GaEnU4Kln/PGBf9Q4CjlKTrqU2NZUADgFxCEqAaidAsnYvoVCQcLIWJ1HlBT3pFElNsUfT7Ixsp5ckwUSUYDJC0h34FWBHdCsOwpS+BmrSNV5QLl6gIMCemg4coDbRQHWqGmH/NsQlHtmJAJFEA4F02Atk/NbSlKTYW92BokQTU3C0Cu0P/AV1UsQjXTgSor63haCGccTxFhzcQIpY9W5cdamKNYLr4OK17Ki49AUS7KvqwlWlNt4C6v+TxgvSYsFeusJduAIt8WmoHwwFFBwV+gI9JEJ7CQJTY9Nx8AKAahRHld5gD7FwN+mAUJOYQRJIOPjXGPaF97Ev1I2oQ0u8mf2xtXeO3aE99AZ7CLgBmhJT+9833tYQe8IxYsEYATdMU28LmvW54KjQE95NOtBLdTpMU6LZD06UGv8c0qFO0k4C160ilGrCFUgBcaBHoDO8i3iwj0C6irq+KX5gmPlSB3uqOnAlSTQVoTbZ4AeQ+79/dFV1kAqkqErVEE02ZH3Z8t78OyPbSUua6mQt0WQdiosrfbj+l6htkW2oKHV9ddSmagm6ShglpBDWAImq7VSp0JRsJJKuIaTel5c0kBaXnurtpBwI9DUibjUpIC2QdCAmaaIhrzV6y5YtdHd3D/i7CofDzJ8/H4DNmzcTiw2cLLm6upq5c+cC8Oqrr9Lb2zvobzPDgpoyISJLgeuB5cBu4Cbgq6pa0bc1NFQ1sHL+ygHrZs2aRW1tLd3d3WzZMngyy9mzZxONRtm7dy9bt24dtH3u3LlUV1eze/dutm/fPmj7/PnzCYfDdHZ20tHRMWh7W1sbwWCQXbt2sXPnzkHbFy1ahOM4dHR00NnZOWj74sWLAdi+fTu7d+8esM1xHBYtWgTA1q1b2bt3YOJzMBikra0NmJg/7mg0yuzZswHYuHEjfX19A7bX1tYya9YsADZs2EAqNXBsoPr6embMmAHAyy+/jOsOTDxtbGxk2rRpAIOCaSifgDoWi7F58+ZB2wt97+3Zs4ctW7fgui4pTaGqBJwAc+bMoTZay749+9ixY8eg/cf7vaequLg4OIiIvfcOxHsvkWBj+wavdTKw/1/kgXrvjfZzb+7ceRAI0rFzFzs6OkimlbTrknKVVNqlZcYcqqpC9OzZTffeLgKZVh4RBJc5c2YSIEnXzu2kEilCoWpwQv05jWN97807qG1QnSeCdT+VARGZAjwPvAB8A2gDvgNcp6pfHm7fcu5+MsYYYyaCdT+Vt0/jpQ58QFX3AveKSD1wpYh8019njDHGmGHYODXlYSVwT07w8nO8QOek0lTJGGOMqSwW1JSHJcC67BWq+hoQ87cZY4wxZgQW1JSHKXjJwbm6/G3GGGOMGYEFNeUjX8a25FsvIueLyFoRWZvvDgtjjDHmzciCmvLQBTTmWd9AnhYcVf2Rqi5T1WWtra0TXjljjDGmElhQUx7WkZM7IyKzgRpycm2MMcYYk58FNeXhLuB0EanLWnce3mCTD5amSsYYY0xlsaCmPNwIJIBbReRUETkfuBK41saoMcYYYwpjg++VAVXtEpFTgBuA2/DyaK7DC2yMMcYYUwCbJqHCiUgHMHgikrFpAQZPTFO57HzKm51PebPzKW9v1vOZq6qD7pSxoMYMIiJr882pUansfMqbnU95s/Mpb3Y+A1lOjTHGGGMmBQtqjDHGGDMpWFBj8vlRqSswzux8ypudT3mz8ylvdj5ZLKfGGGOMMZOCtdQYY4wxZlKwoMYAICJLReR+EYmJyBsicpWIBEpdr9EQkY+LiOZZPl3quhVCRBaKyA9F5GkRSYvIA3nKiIhcJiKbRSQuIg+JyFElqO6ICjyfTXmu17YSVHdYInKuiPxeRLaISLeIPCkiH8opU0nXppDzqYhrAyAi54jIKhHZJSK9IrJeRL4sIuGsMpV0fQo5n4q5PrlEZJb/vlMRqc1aP+prZIPvGURkCnAf8AJwNtAGfAcv6P1yCas2Vu/Em2oio71UFSnSocCZwGogPESZS4DLgS/izQ92IXCfiBymquX2gVbI+QD8DLg+63XfRFZqlC4ENgL/hDeWxpnAz0SkRVUzda+ka1PI+UBlXBuAZuBPwLfwBjE9Fm8Q0+nA5/wylXR9CjkfqJzrk+tbQDfePIfZRn+NVNWWN/kCXIo3U3h91rqLgVj2ukpZgI8DCtSWui6jrL+T9fxXwAM526uBPcBXstbVAB3A1aWuf7Hn46/fBHy71HUt4Fxa8qz7GbCxQq/NsOdTSddmmHO8Bi8gkEq7PiOdTyVfH+BEoBP45+zP67FeI+t+MgArgXt04DxTPwciwEmlqdKbl6q6IxRZAdQDv8japwdvio2VE1i1USngfCqGquYb6fQpYKr/vNKuzUjnMxnsYn8LYUVdnyFkn09F8lMbrgeuYvDowWO6RhbUGIAleE18/VT1NbyWmiUlqdH42CAiKb8f+u9LXZlxtARIAy/nrH+Ryr5enxSRPhHZIyK/EpG5pa5QgVbgdd3C5Lg22eeTUVHXRkQCIhIVkROAC4D/UO8rf0Ven2HOJ6Oirg/wabwWmX/Ps21M18hyagzAFLzmzFxd/rZKsxWvP/ZxIAB8CLhRRKKqel1JazY+pgDdqprOWd8FREUkrKqV0qee8Tu8nJvXgUOAK4CHReRwVd1T0poNQ7yJaM8GPumvquhrk+d8oDKvTQ9Q5T//H7zcDKjc6zPU+UCFXR8RaQb+FfiIqiZFJLfImK6RBTUmI9+ARTLE+rKmqvcA92StuktEqoAvi8j3Jkl3yFDXa6htZU1Vv5D18mERWQX8BfgE8N3S1Gp4IjIPL//kd6p6c9amirw2Q51PJV4bvNamKF5i7VeAG4DP+Nsq8foMeT4VeH2uAdao6p3DlBn1NbKgxoAXATfmWd9A/hacSvQr4K+AeVTOXVBD6QLqRCSQ822mEYiparJE9Ro3qvqciKwHjil1XfIRkSbgLuA14CNZmyry2gxzPoOU+7UBUNU/+08fEZGdwE9E5DtU6PUZ6nxUdUOesmV7fUTkULxWwLeLSOZ/TtR/bBCRNGO8RpZTY8DLpxnQVykis/Eyztfl3aNyles3sWKsw+tWW5izflBu1CRQdtdLRKLA7XjJmu/2kxgzKu7ajHA+wym7azOETEAwnwq8Pnlkn89wyvH6LAJCwGN4wUsX+/NqXsdLHh7TNbKgxoD3De10EanLWnce3hgvD5amSuPug3hZ9q+WuiLjYBWwFzg3s8L/x3QW3rWseCJyGLAYeLLUdckmIkHgl3gfzitVdUdOkYq6NgWcT759yvLaDON4/3EjFXZ9hpB9PoOU+fV5BDg5Z/mGv+1MvHFrxnSNrPvJANyIl1F/q4h8A1iAN8DTtTm3eVcEEfk1XpLwM3gR/3n+ckEl5NP4f8Bn+i9nAfUico7/+k5VjYnI14HLRaSL/YNTOQwcgKssjHQ+eB9sH8FrLXgD7xvZl/G6Qm4+oJUd2Q/wzuULQJOIHJe17SlV7a2ka8MI5wOcSuVcG0TkbryBRJ/Hu4PmeOAi4JZMV00lXZ+RzkdE3k0FXR9/CIEHstf5uVwAD6tqt79u9Neo1APw2FIeC7AU+CNe68xWvOz0QKnrNcpz+TdgPd4t6XG8bywfLXW9iqj/PLym43zLPL+MAP+C12QbBx4Gji513UdzPsARwP14g2slgW14H8gzS133POeyaZJdm2HPp5KujX8+/wo8hzdK7W68rprPA6GsMpV0fYY9n0q7PkOc48fJGSx1LNfIZuk2xhhjzKRgOTXGGGOMmRQsqDHGGGPMpGBBjTHGGGMmBQtqjDHGGDMpWFBjjDHGmEnBghpjjDHGTAoW1BhjKpKIXCkiOsQy7PxFeY6zcyLrmvWzfiUiDxyIn2XMm5GNKGyMqWR7gDPyrH+liGPcBNw2PtUxxpSSBTXGmEqWUtXVYzmAqr6ON3KpMabCWfeTMWZSEpF5flfUh0XkpyKyT0R2iMgVOeUGdD+JSEhEvi0ir4lIQkTeEJHfiEg4q8xRInK/iMREpEtE/j8RmZZz3NkicqeIxEVkk4h8aoh6HiYid/j12ycivxSR6cXUxxjjsZYaY0xF82eaHkBVU1kvv4U34d85wNuBK0Rkp6r++xCHvBT4f8AleDMhT8eb9DHg/7xWvEn5XgQ+DNQCXwfuFZFlqtonIgL8DmgB/hboBb4KNAEvZ9V9IfAosBb4qP8z/hW4TUSOVW8em2HrY4zZz4IaY0wla8abyG8AEZmf9fJ5Vf17//k9IjIVuExE/kPzz9p+LPAzVf1J1rpfZD2/yH88Xf1Z7EXkJWAN8EHg/4CVwNHAcaq6xi/zJLCBrKAGuAJvEsKVqtrnl3sGb2biM4E7CqiPMcZn3U/GmEq2B3hrnuWNrDK/ydnnVmAmcNAQx/wL8HERuVhEjvBbXbIdC/whE9AAqOrjeDNen5BVZnsmoPHLvIo3Y3y2U/36uSIS9FudNvrHWlZgfYwxPgtqjDGVLKWqa/MsfVllduTsk3k9Y4hjXg38O/AZ4Glgs4h8IWv7DGB7nv2243UvgddFlPtz89WlBfgSXmtT9rIAmF1gfYwxPgtqjDGT3dQhXm/NV1hVe1X1K6o6DzgYuAX4roickbVf7jEBpgGd/vNtQ5TJXdcJ/JD8rU1XF1gfY4zPghpjzGT3/pzXH8ALTEa8jVtVXwb+GUgAS/3Va4DTRaQuU05E3grMAx7xVz0BTBORt2WVmQMck/Mj7gcOA57M09q0qcD6GGN8lihsjKlkQRE5Ls/6zVnPDxWRHwK/xrv76W+BLwyRJIyI/AYv9+UpII5311QQeMgvci3wD3hJx99g/91Pz/o/A+BOvK6iX4rIl/DufrqKwd1PVwKPA3eIyH8BO4FZwLuAm1X1gQLqY4zxWVBjjKlkDcBjedZfDvyv//xi4D14AUcv3i3TNwxzzFXAecAX8VqzXwA+qKprAVS1Q0ROBr6Dd6dTH14Q80+ZXB5VVRF5L/Aj4L/wgpl/wwtWWjI/SFVf8oOyq/2yEWALXgtOZlTkYetjjNlPvGEQjDFmchGReXh3Ep2lqreXtjbGmAPBcmqMMcYYMylYUGOMMcaYScG6n4wxxhgzKVhLjTHGGGMmBQtqjDHGGDMpWFBjjDHGmEnBghpjjDHGTAoW1BhjjDFmUrCgxhhjjDGTwv8PnhAnzd7QnqkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "# Experiment parameters\n",
    "experiment_parameters = {\n",
    "    \"num_runs\" : 30,                     # The number of times we run the experiment\n",
    "    \"num_episodes\" : 40,                 # The number of episodes per experiment\n",
    "}\n",
    "\n",
    "# Environment parameters\n",
    "environment_parameters = { \n",
    "    \"discount\": 0.95,\n",
    "}\n",
    "\n",
    "# Agent parameters\n",
    "agent_parameters = {  \n",
    "    \"num_states\" : 54,\n",
    "    \"num_actions\" : 4, \n",
    "    \"epsilon\": 0.1, \n",
    "    \"step_size\" : 0.125,\n",
    "    \"planning_steps\" : [0, 5, 50]       # The list of planning_steps we want to try\n",
    "}\n",
    "\n",
    "current_env = ShortcutMazeEnvironment   # The environment\n",
    "current_agent = DynaQAgent              # The agent\n",
    "\n",
    "dataq = run_experiment(current_env, current_agent, environment_parameters, agent_parameters, experiment_parameters)\n",
    "plot_steps_per_episode(dataq)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "81c7635453f9c560e71d536f7e7be762",
     "grade": false,
     "grade_id": "cell-a44baca574f0e70c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "What do you notice?\n",
    "\n",
    "As the number of planning steps increases, the number of episodes taken to reach the goal decreases rapidly. Remember that the RNG seed was set the same for all the three values of planning steps, resulting in the same number of steps taken to reach the goal in the first episode. Thereafter, the performance improves. The slowest improvement is when there are $n=0$ planning steps, i.e., for the non-planning Q-learning agent, even though the step size parameter was optimized for it. Note that the grey dotted line shows the minimum number of steps required to reach the goal state under the optimal greedy policy.\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "92986c0d6a6e9acfaf3cbab5ebafbf49",
     "grade": false,
     "grade_id": "cell-753d3ebd700359e6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Experiment(s): Dyna-Q agent in the _changing_ maze environment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dd09e132177a8cc9b4a061de27754ad4",
     "grade": false,
     "grade_id": "cell-aa3974b49e4eda2f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Great! Now let us see how Dyna-Q performs on the version of the maze in which a shorter path opens up after 3000 steps. The rest of the transition and reward dynamics remain the same. \n",
    "\n",
    "<img src=\"./images/shortcut_env_after.png\" alt=\"environment\" width=\"800\"/>\n",
    "\n",
    "Before you proceed, take a moment to think about what you expect to see. Will Dyna-Q find the new, shorter path to the goal? If so, why? If not, why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e89fe28e52a88aeed2388ac7afad4ab3",
     "grade": false,
     "grade_id": "cell-422bb22d0465830f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def run_experiment_with_state_visitations(env, agent, env_parameters, agent_parameters, exp_parameters, result_file_name):\n",
    "\n",
    "    # Experiment settings\n",
    "    num_runs = exp_parameters['num_runs']\n",
    "    num_max_steps = exp_parameters['num_max_steps']\n",
    "    planning_steps_all = agent_parameters['planning_steps']\n",
    "\n",
    "    env_info = {\"change_at_n\" : env_parameters[\"change_at_n\"]}                     \n",
    "    agent_info = {\"num_states\" : agent_parameters[\"num_states\"],  \n",
    "                  \"num_actions\" : agent_parameters[\"num_actions\"],\n",
    "                  \"epsilon\": agent_parameters[\"epsilon\"], \n",
    "                  \"discount\": env_parameters[\"discount\"],\n",
    "                  \"step_size\" : agent_parameters[\"step_size\"]}\n",
    "\n",
    "    state_visits_before_change = np.zeros((len(planning_steps_all), num_runs, 54))  # For saving the number of\n",
    "    state_visits_after_change = np.zeros((len(planning_steps_all), num_runs, 54))   #     state-visitations \n",
    "    cum_reward_all = np.zeros((len(planning_steps_all), num_runs, num_max_steps))   # For saving the cumulative reward\n",
    "    log_data = {'planning_steps_all' : planning_steps_all}\n",
    "\n",
    "    for idx, planning_steps in enumerate(planning_steps_all):\n",
    "\n",
    "        print('Planning steps : ', planning_steps)\n",
    "        os.system('sleep 1')          # to prevent tqdm printing out-of-order before the above print()\n",
    "        agent_info[\"planning_steps\"] = planning_steps  # We pass the agent the information it needs. \n",
    "\n",
    "        for run in tqdm(range(num_runs)):\n",
    "\n",
    "            agent_info['random_seed'] = run\n",
    "            agent_info['planning_random_seed'] = run\n",
    "\n",
    "            rl_glue = RLGlue(env, agent)  # Creates a new RLGlue experiment with the env and agent we chose above\n",
    "            rl_glue.rl_init(agent_info, env_info) # We pass RLGlue what it needs to initialize the agent and environment\n",
    "\n",
    "            num_steps = 0\n",
    "            cum_reward = 0\n",
    "\n",
    "            while num_steps < num_max_steps-1 :\n",
    "\n",
    "                state, _ = rl_glue.rl_start()  # We start the experiment. We'll be collecting the \n",
    "                is_terminal = False            # state-visitation counts to visiualize the learned policy\n",
    "                if num_steps < env_parameters[\"change_at_n\"]: \n",
    "                    state_visits_before_change[idx][run][state] += 1\n",
    "                else:\n",
    "                    state_visits_after_change[idx][run][state] += 1\n",
    "\n",
    "                while not is_terminal and num_steps < num_max_steps-1 :\n",
    "                    reward, state, action, is_terminal = rl_glue.rl_step()  \n",
    "                    num_steps += 1\n",
    "                    cum_reward += reward\n",
    "                    cum_reward_all[idx][run][num_steps] = cum_reward\n",
    "                    if num_steps < env_parameters[\"change_at_n\"]:\n",
    "                        state_visits_before_change[idx][run][state] += 1\n",
    "                    else:\n",
    "                        state_visits_after_change[idx][run][state] += 1\n",
    "\n",
    "    log_data['state_visits_before'] = state_visits_before_change\n",
    "    log_data['state_visits_after'] = state_visits_after_change\n",
    "    log_data['cum_reward_all'] = cum_reward_all\n",
    "    \n",
    "    return log_data\n",
    "\n",
    "def plot_cumulative_reward(data_all, item_key, y_key, y_axis_label, legend_prefix, title):\n",
    "    data_y_all = data_all[y_key]\n",
    "    items = data_all[item_key]\n",
    "\n",
    "    for i, item in enumerate(items):\n",
    "        plt.plot(np.mean(data_y_all[i], axis=0), label=legend_prefix+str(item))\n",
    "\n",
    "    plt.axvline(x=3000, linestyle='--', color='grey', alpha=0.4)\n",
    "    plt.xlabel('Timesteps')\n",
    "    plt.ylabel(y_axis_label, rotation=0, labelpad=60)\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.title(title)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ed82204e60d5cda36d818ca9bf653710",
     "grade": false,
     "grade_id": "cell-142b14ac90c9bff7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Did you notice that the environment changes after a fixed number of _steps_ and not episodes? \n",
    "\n",
    "This is because the environment is separate from the agent, and the environment changes irrespective of the length of each episode (i.e., the number of environmental interactions per episode) that the agent perceives. And hence we are now plotting the data per step or interaction of the agent and the environment, in order to comfortably see the differences in the behaviours of the agents before and after the environment changes.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4f802c06e5b1eb84585c6876ac3f2dd3",
     "grade": false,
     "grade_id": "cell-0b246e0fe5abb018",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Okay, now we will first plot the cumulative reward obtained by the agent per interaction with the environment, averaged over 10 runs of the experiment on this changing world. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "20b0026f54442a7ba37d7096128e03ed",
     "grade": false,
     "grade_id": "cell-9f7872900ce6b40f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:07<00:00,  1.28it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:13<00:00,  1.34s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [01:00<00:00,  6.01s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "# Experiment parameters\n",
    "experiment_parameters = {\n",
    "    \"num_runs\" : 10,                     # The number of times we run the experiment\n",
    "    \"num_max_steps\" : 6000,              # The number of steps per experiment\n",
    "}\n",
    "\n",
    "# Environment parameters\n",
    "environment_parameters = { \n",
    "    \"discount\": 0.95,\n",
    "    \"change_at_n\": 3000\n",
    "}\n",
    "\n",
    "# Agent parameters\n",
    "agent_parameters = {  \n",
    "    \"num_states\" : 54,\n",
    "    \"num_actions\" : 4, \n",
    "    \"epsilon\": 0.1, \n",
    "    \"step_size\" : 0.125,\n",
    "    \"planning_steps\" : [5, 10, 50]      # The list of planning_steps we want to try\n",
    "}\n",
    "\n",
    "current_env = ShortcutMazeEnvironment   # The environment\n",
    "current_agent = DynaQAgent              # The agent\n",
    "\n",
    "dataq = run_experiment_with_state_visitations(current_env, current_agent, environment_parameters, agent_parameters, experiment_parameters, \"Dyna-Q_shortcut_steps\")    \n",
    "plot_cumulative_reward(dataq, 'planning_steps_all', 'cum_reward_all', 'Cumulative\\nreward', 'Planning steps = ', 'Dyna-Q : Varying planning_steps')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ce1264bf93c93926107e736687bfe3ab",
     "grade": false,
     "grade_id": "cell-ae67d282ebad19ad",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "We observe that the slope of the curves is almost constant. If the agent had discovered the shortcut and begun using it, we would expect to see an increase in the slope of the curves towards the later stages of training. This is because the agent can get to the goal state faster and get the positive reward. Note that the timestep at which the shortcut opens up is marked by the grey dotted line.\n",
    "\n",
    "Note that this trend is constant across the increasing number of planning steps.\n",
    "\n",
    "Now let's check the heatmap of the state visitations of the agent with `planning_steps=10` during training, before and after the shortcut opens up after 3000 timesteps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bfe46c5772be65c97fa8ba81d947f985",
     "grade": false,
     "grade_id": "cell-c21d98bc4f7296d6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def plot_state_visitations(data, plot_titles, idx):\n",
    "    data_keys = [\"state_visits_before\", \"state_visits_after\"]\n",
    "    positions = [211,212]\n",
    "    titles = plot_titles\n",
    "    wall_ends = [None,-1]\n",
    "\n",
    "    for i in range(2):\n",
    "\n",
    "        state_visits = data[data_keys[i]][idx]\n",
    "        average_state_visits = np.mean(state_visits, axis=0)\n",
    "        grid_state_visits = np.rot90(average_state_visits.reshape((6,9)).T)\n",
    "        grid_state_visits[2,1:wall_ends[i]] = np.nan # walls\n",
    "        #print(average_state_visits.reshape((6,9)))\n",
    "        plt.subplot(positions[i])\n",
    "        plt.pcolormesh(grid_state_visits, edgecolors='gray', linewidth=1, cmap='viridis')\n",
    "        plt.text(3+0.5, 0+0.5, 'S', horizontalalignment='center', verticalalignment='center')\n",
    "        plt.text(8+0.5, 5+0.5, 'G', horizontalalignment='center', verticalalignment='center')\n",
    "        plt.title(titles[i])\n",
    "        plt.axis('off')\n",
    "        cm = plt.get_cmap()\n",
    "        cm.set_bad('gray')\n",
    "\n",
    "    plt.subplots_adjust(bottom=0.0, right=0.7, top=1.0)\n",
    "    cax = plt.axes([1., 0.0, 0.075, 1.])\n",
    "    cbar = plt.colorbar(cax=cax)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ee68fcbd81419dd6d30abaaa38f5a48d",
     "grade": false,
     "grade_id": "cell-aa17be852a4fa1e1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Do not modify this cell!\n",
    "\n",
    "plot_state_visitations(dataq, ['Dyna-Q : State visitations before the env changes', 'Dyna-Q : State visitations after the env changes'], 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0979f12aeeebfa64035c9f27fc407d97",
     "grade": false,
     "grade_id": "cell-50778038da2d7233",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "What do you observe?\n",
    "\n",
    "The state visitation map looks almost the same before and after the shortcut opens. This means that the Dyna-Q agent hasn't quite discovered and started exploiting the new shortcut.\n",
    "\n",
    "Now let's try increasing the exploration parameter $\\epsilon$ to see if it helps the Dyna-Q agent discover the shortcut. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c2dcbc40b05319c4b4efc75ae0128e4d",
     "grade": false,
     "grade_id": "cell-27a96a3ebc8bd13a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def run_experiment_only_cumulative_reward(env, agent, env_parameters, agent_parameters, exp_parameters):\n",
    "\n",
    "    # Experiment settings\n",
    "    num_runs = exp_parameters['num_runs']\n",
    "    num_max_steps = exp_parameters['num_max_steps']\n",
    "    epsilons = agent_parameters['epsilons']\n",
    "\n",
    "    env_info = {\"change_at_n\" : env_parameters[\"change_at_n\"]}                     \n",
    "    agent_info = {\"num_states\" : agent_parameters[\"num_states\"],  \n",
    "                  \"num_actions\" : agent_parameters[\"num_actions\"],\n",
    "                  \"planning_steps\": agent_parameters[\"planning_steps\"], \n",
    "                  \"discount\": env_parameters[\"discount\"],\n",
    "                  \"step_size\" : agent_parameters[\"step_size\"]}\n",
    "\n",
    "    log_data = {'epsilons' : epsilons} \n",
    "    cum_reward_all = np.zeros((len(epsilons), num_runs, num_max_steps))\n",
    "\n",
    "    for eps_idx, epsilon in enumerate(epsilons):\n",
    "\n",
    "        print('Agent : Dyna-Q, epsilon : %f' % epsilon)\n",
    "        os.system('sleep 1')          # to prevent tqdm printing out-of-order before the above print()\n",
    "        agent_info[\"epsilon\"] = epsilon\n",
    "\n",
    "        for run in tqdm(range(num_runs)):\n",
    "\n",
    "            agent_info['random_seed'] = run\n",
    "            agent_info['planning_random_seed'] = run\n",
    "\n",
    "            rl_glue = RLGlue(env, agent)  # Creates a new RLGlue experiment with the env and agent we chose above\n",
    "            rl_glue.rl_init(agent_info, env_info) # We pass RLGlue what it needs to initialize the agent and environment\n",
    "\n",
    "            num_steps = 0\n",
    "            cum_reward = 0\n",
    "\n",
    "            while num_steps < num_max_steps-1 :\n",
    "\n",
    "                rl_glue.rl_start()  # We start the experiment\n",
    "                is_terminal = False\n",
    "\n",
    "                while not is_terminal and num_steps < num_max_steps-1 :\n",
    "                    reward, _, action, is_terminal = rl_glue.rl_step()  # The environment and agent take a step and return\n",
    "                    # the reward, and action taken.\n",
    "                    num_steps += 1\n",
    "                    cum_reward += reward\n",
    "                    cum_reward_all[eps_idx][run][num_steps] = cum_reward\n",
    "\n",
    "    log_data['cum_reward_all'] = cum_reward_all\n",
    "    return log_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "35b1244013e6641a28af6ee1c5e19020",
     "grade": false,
     "grade_id": "cell-7e4c0e42c445b2dc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent : Dyna-Q, epsilon : 0.100000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:41<00:00,  1.39s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent : Dyna-Q, epsilon : 0.200000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:41<00:00,  1.38s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent : Dyna-Q, epsilon : 0.400000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:40<00:00,  1.35s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent : Dyna-Q, epsilon : 0.800000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [00:40<00:00,  1.35s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "# Experiment parameters\n",
    "experiment_parameters = {\n",
    "    \"num_runs\" : 30,                     # The number of times we run the experiment\n",
    "    \"num_max_steps\" : 6000,              # The number of steps per experiment\n",
    "}\n",
    "\n",
    "# Environment parameters\n",
    "environment_parameters = { \n",
    "    \"discount\": 0.95,\n",
    "    \"change_at_n\": 3000\n",
    "}\n",
    "\n",
    "# Agent parameters\n",
    "agent_parameters = {  \n",
    "    \"num_states\" : 54,\n",
    "    \"num_actions\" : 4, \n",
    "    \"step_size\" : 0.125,\n",
    "    \"planning_steps\" : 10,\n",
    "    \"epsilons\": [0.1, 0.2, 0.4, 0.8]    # The list of epsilons we want to try\n",
    "}\n",
    "\n",
    "current_env = ShortcutMazeEnvironment   # The environment\n",
    "current_agent = DynaQAgent              # The agent\n",
    "\n",
    "data = run_experiment_only_cumulative_reward(current_env, current_agent, environment_parameters, agent_parameters, experiment_parameters)\n",
    "plot_cumulative_reward(data, 'epsilons', 'cum_reward_all', 'Cumulative\\nreward', r'$\\epsilon$ = ', r'Dyna-Q : Varying $\\epsilon$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3e41acbeb9782671cdca735c33cf9b16",
     "grade": false,
     "grade_id": "cell-8159dc6c61e345f9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "What do you observe?\n",
    "\n",
    "Increasing the exploration via the $\\epsilon$-greedy strategy does not seem to be helping. In fact, the agent's cumulative reward decreases because it is spending more and more time trying out the exploratory actions.\n",
    "\n",
    "Can we do better...? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "88675c8ce603f560311089a74104f394",
     "grade": false,
     "grade_id": "cell-62df4f966a370995",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Section 2: Dyna-Q+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "15faa0c27e0b1427655f666914540c23",
     "grade": false,
     "grade_id": "cell-7961458a916a28a8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The motivation behind Dyna-Q+ is to give a bonus reward for actions that haven't been tried for a long time, since there is a greater chance that the dynamics for that actions might have changed.\n",
    "\n",
    "In particular, if the modeled reward for a transition is $r$, and the transition has not been tried in $\\tau(s,a)$ time steps, then planning updates are done as if that transition produced a reward of $r + \\kappa \\sqrt{ \\tau(s,a)}$, for some small $\\kappa$. \n",
    "\n",
    "Let's implement that!\n",
    "\n",
    "Based on your `DynaQAgent`, create a new class `DynaQPlusAgent` to implement the aforementioned exploration heuristic. Additionally :\n",
    "1. actions that had never been tried before from a state should now be allowed to be considered in the planning step,\n",
    "2. and the initial model for such actions is that they lead back to the same state with a reward of zero.\n",
    "\n",
    "At this point, you might want to refer to the video lectures and [Section 8.3](http://www.incompleteideas.net/book/RLbook2018.pdf#page=188) of the RL textbook for a refresher on Dyna-Q+."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fc1df956ada702fea2fdd43be25d2144",
     "grade": false,
     "grade_id": "cell-5cb32fc5b37ad166",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "As usual, let's break this down in pieces and do it one-by-one.\n",
    "\n",
    "First of all, check out the `agent_init` method below. In particular, pay attention to the attributes which are new to `DynaQPlusAgent`â€“ state-visitation counts $\\tau$ and the scaling parameter $\\kappa$ â€“ because you shall be using them later. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f941a227e6e8174f497769e87d5968b5",
     "grade": false,
     "grade_id": "cell-539ab8af016fc473",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "class DynaQPlusAgent(BaseAgent):\n",
    "    \n",
    "    def agent_init(self, agent_info):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\n",
    "\n",
    "        Args:\n",
    "            agent_init_info (dict), the parameters used to initialize the agent. The dictionary contains:\n",
    "            {\n",
    "                num_states (int): The number of states,\n",
    "                num_actions (int): The number of actions,\n",
    "                epsilon (float): The parameter for epsilon-greedy exploration,\n",
    "                step_size (float): The step-size,\n",
    "                discount (float): The discount factor,\n",
    "                planning_steps (int): The number of planning steps per environmental interaction\n",
    "                kappa (float): The scaling factor for the reward bonus\n",
    "\n",
    "                random_seed (int): the seed for the RNG used in epsilon-greedy\n",
    "                planning_random_seed (int): the seed for the RNG used in the planner\n",
    "            }\n",
    "        \"\"\"\n",
    "\n",
    "        # First, we get the relevant information from agent_info \n",
    "        # Note: we use np.random.RandomState(seed) to set the two different RNGs\n",
    "        # for the planner and the rest of the code\n",
    "        try:\n",
    "            self.num_states = agent_info[\"num_states\"]\n",
    "            self.num_actions = agent_info[\"num_actions\"]\n",
    "        except:\n",
    "            print(\"You need to pass both 'num_states' and 'num_actions' \\\n",
    "                   in agent_info to initialize the action-value table\")\n",
    "        self.gamma = agent_info.get(\"discount\", 0.95)\n",
    "        self.step_size = agent_info.get(\"step_size\", 0.1)\n",
    "        self.epsilon = agent_info.get(\"epsilon\", 0.1)\n",
    "        self.planning_steps = agent_info.get(\"planning_steps\", 10)\n",
    "        self.kappa = agent_info.get(\"kappa\", 0.001)\n",
    "\n",
    "        self.rand_generator = np.random.RandomState(agent_info.get('random_seed', 42))\n",
    "        self.planning_rand_generator = np.random.RandomState(agent_info.get('planning_random_seed', 42))\n",
    "\n",
    "        # Next, we initialize the attributes required by the agent, e.g., q_values, model, tau, etc.\n",
    "        # The visitation-counts can be stored as a table as well, like the action values \n",
    "        self.q_values = np.zeros((self.num_states, self.num_actions))\n",
    "        self.tau = np.zeros((self.num_states, self.num_actions))\n",
    "        self.actions = list(range(self.num_actions))\n",
    "        self.past_action = -1\n",
    "        self.past_state = -1\n",
    "        self.model = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1a7b620740e82640f572213177bee2ef",
     "grade": false,
     "grade_id": "cell-1cad0227d9ff16d5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now first up, implement the `update_model` method. Note that this is different from Dyna-Q in the aforementioned way.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ff36e4ae144e4409bd1ea34b1918000f",
     "grade": false,
     "grade_id": "cell-d4452e4cd395456a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQPlusAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "\n",
    "def update_model(self, past_state, past_action, state, reward):\n",
    "    \"\"\"updates the model \n",
    "\n",
    "    Args:\n",
    "        past_state  (int): s\n",
    "        past_action (int): a\n",
    "        state       (int): s'\n",
    "        reward      (int): r\n",
    "    Returns:\n",
    "        Nothing\n",
    "    \"\"\"\n",
    "\n",
    "    # Recall that when adding a state-action to the model, if the agent is visiting the state\n",
    "    #    for the first time, then the remaining actions need to be added to the model as well\n",
    "    #    with zero reward and a transition into itself.\n",
    "    #\n",
    "    # Note: do *not* update the visitation-counts here. We will do that in `agent_step`.\n",
    "    #\n",
    "    # (3 lines)\n",
    "\n",
    "    if past_state not in self.model:\n",
    "        self.model[past_state] = {past_action : (state, reward)}\n",
    "        # ----------------\n",
    "        # your code here\n",
    "        \n",
    "        for action in self.actions:\n",
    "            if action != past_action:\n",
    "                self.model[past_state][action] = (past_state, 0)\n",
    "        \n",
    "        # ----------------\n",
    "    else:\n",
    "        self.model[past_state][past_action] = (state, reward)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a9c44b9a6b276c0e08312dec0d413076",
     "grade": false,
     "grade_id": "cell-a44ec8b7ac701e0c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `update_model()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fc850bdd9ff71c46e5e9b7246c7625d4",
     "grade": true,
     "grade_id": "cell-8cdef71644d2952f",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "actions = []\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0, \n",
    "              \"random_seed\": 0,\n",
    "              \"planning_random_seed\": 0}\n",
    "\n",
    "agent = DynaQPlusAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "agent.update_model(0,2,0,1)\n",
    "agent.update_model(2,0,1,1)\n",
    "agent.update_model(0,3,1,2)\n",
    "agent.tau[0][0] += 1\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        0: (0, 0),\n",
    "        1: (0, 0),\n",
    "        2: (0, 1),\n",
    "        3: (1, 2),\n",
    "    },\n",
    "    2: {\n",
    "        0: (1, 1),\n",
    "        1: (2, 0),\n",
    "        2: (2, 0),\n",
    "        3: (2, 0),\n",
    "    },\n",
    "}\n",
    "assert agent.model == expected_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9c1771a9ba649fde3e588bae3022e161",
     "grade": false,
     "grade_id": "cell-885fe1cd5447e0b0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Next, you will implement the `planning_step()` method. This will be very similar to the one you implemented in `DynaQAgent`, but here you will be adding the exploration bonus to the reward in the simulated transition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6ef80ec707602f554d0a56412d066855",
     "grade": false,
     "grade_id": "cell-b3605364bf724124",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQPlusAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "\n",
    "def planning_step(self):\n",
    "    \"\"\"performs planning, i.e. indirect RL.\n",
    "\n",
    "    Args:\n",
    "        None\n",
    "    Returns:\n",
    "        Nothing\n",
    "    \"\"\"\n",
    "    \n",
    "    # The indirect RL step:\n",
    "    # - Choose a state and action from the set of experiences that are stored in the model. (~2 lines)\n",
    "    # - Query the model with this state-action pair for the predicted next state and reward.(~1 line)\n",
    "    # - **Add the bonus to the reward** (~1 line)\n",
    "    # - Update the action values with this simulated experience.                            (2~4 lines)\n",
    "    # - Repeat for the required number of planning steps.\n",
    "    #\n",
    "    # Note that the update equation is different for terminal and non-terminal transitions. \n",
    "    # To differentiate between a terminal and a non-terminal next state, assume that the model stores\n",
    "    # the terminal state as a dummy state like -1\n",
    "    #\n",
    "    # Important: remember you have a random number generator 'planning_rand_generator' as \n",
    "    #     a part of the class which you need to use as self.planning_rand_generator.choice()\n",
    "    #     For the sake of reproducibility and grading, *do not* use anything else like \n",
    "    #     np.random.choice() for performing search control.\n",
    "\n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    for i in range(self.planning_steps):\n",
    "        past_state = self.planning_rand_generator.choice(list(self.model.keys()))\n",
    "        past_action = self.planning_rand_generator.choice(list(self.model[past_state].keys()))\n",
    "        next_state, reward = self.model[past_state][past_action]\n",
    "        reward += self.kappa * np.sqrt(self.tau[past_state, past_action])\n",
    "    \n",
    "        if next_state == -1:\n",
    "            q_max = 0\n",
    "        else:\n",
    "            q_max = np.max(self.q_values[next_state])\n",
    "    \n",
    "        self.q_values[past_state, past_action] += self.step_size * (reward + self.gamma * q_max\n",
    "                                                                    - self.q_values[past_state, past_action])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4d4d85edc08c8307d5a7072c79c30aad",
     "grade": false,
     "grade_id": "cell-0df5e5a11dce577b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `planning_step()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "506a78d3a89c1a04c8f59e6a69515623",
     "grade": true,
     "grade_id": "cell-1bae4d3c34b953a2",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Do not modify this cell!\n",
    "\n",
    "## Test code for planning_step() ##\n",
    "\n",
    "actions = []\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0, \n",
    "              \"kappa\": 0.001,\n",
    "              \"planning_steps\": 4,\n",
    "              \"random_seed\": 0,\n",
    "              \"planning_random_seed\": 1}\n",
    "\n",
    "agent = DynaQPlusAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "agent.update_model(0,1,-1,1)\n",
    "agent.tau += 1\n",
    "agent.tau[0][1] = 0\n",
    "\n",
    "agent.update_model(0,2,1,1)\n",
    "agent.tau += 1\n",
    "agent.tau[0][2] = 0\n",
    "\n",
    "agent.update_model(2,0,1,1)\n",
    "agent.tau += 1\n",
    "agent.tau[2][0] = 0\n",
    "\n",
    "agent.planning_step()\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        1: (-1, 1), \n",
    "        0: (0, 0), \n",
    "        2: (1, 1), \n",
    "        3: (0, 0),\n",
    "    }, \n",
    "    2: {\n",
    "        0: (1, 1), \n",
    "        1: (2, 0), \n",
    "        2: (2, 0), \n",
    "        3: (2, 0),\n",
    "    },\n",
    "}\n",
    "assert agent.model == expected_model\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0, 0.10014142, 0, 0],\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0.00036373, 0, 0.00017321],\n",
    "])\n",
    "assert np.allclose(agent.q_values, expected_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0463f44477f43a3e5ac587a664caf3e9",
     "grade": false,
     "grade_id": "cell-49b8bb85128d50f3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Again, before you move on to implement the rest of the agent methods, here are the couple of helper functions that you've used in the previous assessments for choosing an action using an $\\epsilon$-greedy policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "81bcd74d211cf70c7259d7e035ed6393",
     "grade": false,
     "grade_id": "cell-0550ca807b59d14c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQPlusAgent\n",
    "\n",
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def argmax(self, q_values):\n",
    "    \"\"\"argmax with random tie-breaking\n",
    "    Args:\n",
    "        q_values (Numpy array): the array of action values\n",
    "    Returns:\n",
    "        action (int): an action with the highest value\n",
    "    \"\"\"\n",
    "    top = float(\"-inf\")\n",
    "    ties = []\n",
    "\n",
    "    for i in range(len(q_values)):\n",
    "        if q_values[i] > top:\n",
    "            top = q_values[i]\n",
    "            ties = []\n",
    "\n",
    "        if q_values[i] == top:\n",
    "            ties.append(i)\n",
    "\n",
    "    return self.rand_generator.choice(ties)\n",
    "\n",
    "def choose_action_egreedy(self, state):\n",
    "    \"\"\"returns an action using an epsilon-greedy policy w.r.t. the current action-value function.\n",
    "\n",
    "    Important: assume you have a random number generator 'rand_generator' as a part of the class\n",
    "                which you can use as self.rand_generator.choice() or self.rand_generator.rand()\n",
    "\n",
    "    Args:\n",
    "        state (List): coordinates of the agent (two elements)\n",
    "    Returns:\n",
    "        The action taken w.r.t. the aforementioned epsilon-greedy policy\n",
    "    \"\"\"\n",
    "\n",
    "    if self.rand_generator.rand() < self.epsilon:\n",
    "        action = self.rand_generator.choice(self.actions)\n",
    "    else:\n",
    "        values = self.q_values[state]\n",
    "        action = self.argmax(values)\n",
    "\n",
    "    return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "cfc05c6dac5be58f8070c05bcab23dc4",
     "grade": false,
     "grade_id": "cell-ff89fce4c62dd24b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now implement the rest of the agent-related methods, namely `agent_start`, `agent_step`, and `agent_end`. Again, these will be very similar to the ones in the `DynaQAgent`, but you will have to think of a way to update the counts since the last visit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9ea6edbc6526bfb8d57d8d6a03514ba1",
     "grade": false,
     "grade_id": "cell-675ebe1d175f5730",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "%%add_to DynaQPlusAgent\n",
    "\n",
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\n",
    "    \n",
    "def agent_start(self, state):\n",
    "    \"\"\"The first method called when the experiment starts, called after\n",
    "    the environment starts.\n",
    "    Args:\n",
    "        state (Numpy array): the state from the\n",
    "            environment's env_start function.\n",
    "    Returns:\n",
    "        (int) The first action the agent takes.\n",
    "    \"\"\"\n",
    "    \n",
    "    # given the state, select the action using self.choose_action_egreedy(), \n",
    "    # and save current state and action (~2 lines)\n",
    "    ### self.past_state = ?\n",
    "    ### self.past_action = ?\n",
    "    # Note that the last-visit counts are not updated here.\n",
    "    \n",
    "    # ----------------\n",
    "    # your code here\n",
    "    \n",
    "    self.past_state = state\n",
    "    self.past_action = self.choose_action_egreedy(self.past_state)\n",
    "    \n",
    "    return self.past_action\n",
    "\n",
    "def agent_step(self, reward, state):\n",
    "    \"\"\"A step taken by the agent.\n",
    "    Args:\n",
    "        reward (float): the reward received for taking the last action taken\n",
    "        state (Numpy array): the state from the\n",
    "            environment's step based on where the agent ended up after the\n",
    "            last step\n",
    "    Returns:\n",
    "        (int) The action the agent is taking.\n",
    "    \"\"\"  \n",
    "    \n",
    "    # Update the last-visited counts (~2 lines)\n",
    "    # - Direct-RL step (1~3 lines)\n",
    "    # - Model Update step (~1 line)\n",
    "    # - `planning_step` (~1 line)\n",
    "    # - Action Selection step (~1 line)\n",
    "    # Save the current state and action before returning the action to be performed. (~2 lines)\n",
    "    \n",
    "    # ----------------\n",
    "    # Tau Update step\n",
    "    self.tau += 1 # increaase tau for not visiting \n",
    "    self.tau[self.past_state, self.past_action] = 0 # set zeros to the one visit\n",
    "    # Direct-RL step\n",
    "    q_max = np.max(self.q_values[state])\n",
    "    self.q_values[self.past_state, self.past_action] += self.step_size * (reward + self.gamma * q_max\n",
    "                                                                - self.q_values[self.past_state, self.past_action])\n",
    "    # Model Update step\n",
    "    self.update_model(self.past_state, self.past_action, state, reward)\n",
    "    \n",
    "    # Planning\n",
    "    self.planning_step()\n",
    "    \n",
    "    # Choose Action\n",
    "    action = self.choose_action_egreedy(state)\n",
    "    \n",
    "    # Save the current state and action\n",
    "    self.past_state = state\n",
    "    self.past_action = action\n",
    "    return self.past_action\n",
    "\n",
    "def agent_end(self, reward):\n",
    "    \"\"\"Called when the agent terminates.\n",
    "    Args:\n",
    "        reward (float): the reward the agent received for entering the\n",
    "            terminal state.\n",
    "    \"\"\"\n",
    "    # Again, add the same components you added in agent_step to augment Dyna-Q into Dyna-Q+\n",
    "    \n",
    "    # ----------------\n",
    "    self.tau += 1\n",
    "    self.tau[self.past_state, self.past_action] = 0\n",
    "    # Direct-RL step\n",
    "    self.q_values[self.past_state, self.past_action] += self.step_size * (reward\n",
    "                                                                          - self.q_values[self.past_state, self.past_action])\n",
    "    # Model Update step\n",
    "    self.update_model(self.past_state, self.past_action, -1, reward)\n",
    "    # Planning\n",
    "    self.planning_step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "375c9af20c23fbafe952776276d580dd",
     "grade": false,
     "grade_id": "cell-05300ec8845616b2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Test `agent_start()`, `agent_step()`, and `agent_end()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "44a3a0b6fcb2e7f37c933bd18ff378f8",
     "grade": true,
     "grade_id": "cell-9cf838836ad39efb",
     "locked": true,
     "points": 15,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "agent_info = {\"num_actions\": 4, \n",
    "              \"num_states\": 3, \n",
    "              \"epsilon\": 0.1, \n",
    "              \"step_size\": 0.1, \n",
    "              \"discount\": 1.0,\n",
    "              \"kappa\": 0.001,\n",
    "              \"random_seed\": 0,\n",
    "              \"planning_steps\": 4,\n",
    "              \"planning_random_seed\": 0}\n",
    "\n",
    "agent = DynaQPlusAgent()\n",
    "agent.agent_init(agent_info)\n",
    "\n",
    "action = agent.agent_start(0) # state\n",
    "assert action == 1\n",
    "\n",
    "assert np.allclose(agent.tau, 0)\n",
    "assert np.allclose(agent.q_values, 0)\n",
    "assert agent.model == {}\n",
    "\n",
    "# ---------------\n",
    "# test agent step\n",
    "# ---------------\n",
    "\n",
    "action = agent.agent_step(1, 2)\n",
    "assert action == 3\n",
    "\n",
    "action = agent.agent_step(0, 1)\n",
    "assert action == 1\n",
    "\n",
    "expected_tau = np.array([\n",
    "    [2, 1, 2, 2],\n",
    "    [2, 2, 2, 2],\n",
    "    [2, 2, 2, 0],\n",
    "])\n",
    "assert np.all(agent.tau == expected_tau)\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0.0191, 0.271, 0.0, 0.0191],\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0.000183847763, 0.000424264069, 0],\n",
    "])\n",
    "assert np.allclose(agent.q_values, expected_values)\n",
    "\n",
    "expected_model = {\n",
    "    0: {\n",
    "        1: (2, 1), \n",
    "        0: (0, 0), \n",
    "        2: (0, 0), \n",
    "        3: (0, 0),\n",
    "    }, \n",
    "    2: {\n",
    "        3: (1, 0), \n",
    "        0: (2, 0), \n",
    "        1: (2, 0), \n",
    "        2: (2, 0),\n",
    "    },\n",
    "}\n",
    "assert agent.model == expected_model\n",
    "\n",
    "# --------------\n",
    "# test agent end\n",
    "# --------------\n",
    "agent.agent_end(1)\n",
    "\n",
    "expected_tau = np.array([\n",
    "    [3, 2, 3, 3],\n",
    "    [3, 0, 3, 3],\n",
    "    [3, 3, 3, 1],\n",
    "])\n",
    "assert np.all(agent.tau == expected_tau)\n",
    "\n",
    "expected_values = np.array([\n",
    "    [0.0191, 0.344083848, 0, 0.0444632051],\n",
    "    [0.0191732051, 0.19, 0, 0],\n",
    "    [0, 0.000183847763, 0.000424264069, 0],\n",
    "])\n",
    "assert np.allclose(agent.q_values, expected_values)\n",
    "\n",
    "expected_model = {0: {1: (2, 1), 0: (0, 0), 2: (0, 0), 3: (0, 0)}, 2: {3: (1, 0), 0: (2, 0), 1: (2, 0), 2: (2, 0)}, 1: {1: (-1, 1), 0: (1, 0), 2: (1, 0), 3: (1, 0)}}\n",
    "assert agent.model == expected_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "79c71f3b2858306fde14049a0383667f",
     "grade": false,
     "grade_id": "cell-0e614343c0d86b2d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Experiment: Dyna-Q+ agent in the _changing_ environment\n",
    "\n",
    "Okay, now we're ready to test our Dyna-Q+ agent on the Shortcut Maze. As usual, we will average the results over 30 independent runs of the experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7b694d2c1d02154058ad127123594b44",
     "grade": false,
     "grade_id": "cell-22a658123d08fafa",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning steps :  50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 30/30 [04:19<00:00,  8.67s/it]\n"
     ]
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "# Experiment parameters\n",
    "experiment_parameters = {\n",
    "    \"num_runs\" : 30,                     # The number of times we run the experiment\n",
    "    \"num_max_steps\" : 6000,              # The number of steps per experiment\n",
    "}\n",
    "\n",
    "# Environment parameters\n",
    "environment_parameters = { \n",
    "    \"discount\": 0.95,\n",
    "    \"change_at_n\": 3000\n",
    "}\n",
    "\n",
    "# Agent parameters\n",
    "agent_parameters = {  \n",
    "    \"num_states\" : 54,\n",
    "    \"num_actions\" : 4, \n",
    "    \"epsilon\": 0.1, \n",
    "    \"step_size\" : 0.5,\n",
    "    \"planning_steps\" : [50]      \n",
    "}\n",
    "\n",
    "current_env = ShortcutMazeEnvironment   # The environment\n",
    "current_agent = DynaQPlusAgent          # The agent\n",
    "\n",
    "data_qplus = run_experiment_with_state_visitations(current_env, current_agent, environment_parameters, agent_parameters, experiment_parameters, \"Dyna-Q+\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3c8507e67b844c085afe5bd111f176cc",
     "grade": false,
     "grade_id": "cell-5d80afb4585b0357",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Let's compare the Dyna-Q and Dyna-Q+ agents with `planning_steps=50` each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "56f9182c13c40b6647f53e95d2a89302",
     "grade": false,
     "grade_id": "cell-b17bc044f6e4e020",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "def plot_cumulative_reward_comparison(data1, data2):\n",
    "\n",
    "    cum_reward_q = data1['cum_reward_all'][2]\n",
    "    cum_reward_qPlus = data2['cum_reward_all'][0]\n",
    "\n",
    "    plt.plot(np.mean(cum_reward_qPlus, axis=0), label='Dyna-Q+')\n",
    "    plt.plot(np.mean(cum_reward_q, axis=0), label='Dyna-Q')\n",
    "\n",
    "    plt.axvline(x=3000, linestyle='--', color='grey', alpha=0.4)\n",
    "    plt.xlabel('Timesteps')\n",
    "    plt.ylabel('Cumulative\\nreward', rotation=0, labelpad=60)\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.title('Average performance of Dyna-Q and Dyna-Q+ agents in the Shortcut Maze\\n')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "74b2b53a88c98b3a41f4ccdf24c585bf",
     "grade": false,
     "grade_id": "cell-bff6a7315a81ba36",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "plot_cumulative_reward_comparison(dataq, data_qplus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "74108cc11abe9d0edcfd58957ecd5cf1",
     "grade": false,
     "grade_id": "cell-3b4406fd8796da4e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "What do you observe? (For reference, your graph should look like [Figure 8.5 in Chapter 8](http://www.incompleteideas.net/book/RLbook2018.pdf#page=189) of the RL textbook)\n",
    "\n",
    "The slope of the curve increases for the Dyna-Q+ curve shortly after the shortcut opens up after 3000 steps, which indicates that the rate of receiving the positive reward increases. This implies that the Dyna-Q+ agent finds the shorter path to the goal.\n",
    "\n",
    "To verify this, let us plot the state-visitations of the Dyna-Q+ agent before and after the shortcut opens up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "02a92b5dfca164799531bfbfc51b2947",
     "grade": false,
     "grade_id": "cell-30b40e125c10f4a1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "plot_state_visitations(data_qplus, ['Dyna-Q+ : State visitations before the env changes', 'Dyna-Q+ : State visitations after the env changes'], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "93e6b7711fe3bbb622a649369171566d",
     "grade": false,
     "grade_id": "cell-c2e1a4549783e5d9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "What do you observe?\n",
    "\n",
    "Before the shortcut opens up, like Dyna-Q, the Dyna-Q+ agent finds the sole, long path to the goal. But because the Dyna-Q+ agent keeps exploring, it succeeds in discovering the shortcut once it opens up, which leads to the goal faster. So the bonus reward heuristic is effective in helping the agent explore and find changes in the environment without degrading the performance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "316c6bb4a3a11821d48d0c4482b546b4",
     "grade": false,
     "grade_id": "cell-122b7fbe5a69ce76",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Wrapping Up\n",
    "\n",
    "Congratulations! You have:\n",
    "\n",
    "1. implemented Dyna-Q, a model-based approach to RL;\n",
    "2. implemented Dyna-Q+, a variant of Dyna-Q with an exploration bonus that encourages exploration; \n",
    "3. conducted scientific experiments to empirically validate the exploration/exploitation dilemma in the planning context on an environment that changes with time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "af62c782e534d54888e892bb8588ad60",
     "grade": false,
     "grade_id": "cell-38d472ccebc0dd45",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Some points to ponder about:\n",
    "1. At what cost does Dyna-Q+ improve over Dyna-Q?\n",
    "2. In general, what is the trade-off of using model-based methods like Dyna-Q over model-free methods like Q-learning?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "sample-based-learning-methods",
   "graded_item_id": "trR7Z",
   "launcher_item_id": "edrCE"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}