Skip to content

Instantly share code, notes, and snippets.

@johnleung8888

johnleung8888/Assignment: Dyna-Q and Dyna-Q+.ipynb

Created January 17, 2023 18:11
Show Gist options
  • Save johnleung8888/1b6afa6ea9c4d2925a41675c2179c749 to your computer and use it in GitHub Desktop.
Save johnleung8888/1b6afa6ea9c4d2925a41675c2179c749 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
Assignment: Dyna-Q and Dyna-Q+.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",
" if past_state not in self.model: \n",
" self.model[past_state] = {}\n",
" self.model[past_state][past_action] = (state, reward)\n",
" \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",
" counter = 0\n",
" while counter < 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",
" state, reward = self.model[past_state][past_action]\n",
" if state != -1: \n",
" self.q_values[past_state][past_action] += self.step_size*(reward + self.gamma*np.max(self.q_values[state]) - self.q_values[past_state][past_action])\n",
" else:\n",
" self.q_values[past_state][past_action] += self.step_size*(reward - self.q_values[past_state][past_action])\n",
" counter += 1\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",
" self.past_state = state\n",
" self.past_action = self.choose_action_egreedy(state)\n",
" # ----------------\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",
" action = self.choose_action_egreedy(state)\n",
" self.q_values[self.past_state][self.past_action] += self.step_size*(reward + self.gamma*np.max(self.q_values[state]) - self.q_values[self.past_state][self.past_action])\n",
" self.update_model(self.past_state, self.past_action, state, reward)\n",
" self.planning_step()\n",
" self.past_state = state\n",
" self.past_action = action\n",
" # ----------------\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",
" self.q_values[self.past_state, self.past_action] += self.step_size*(reward + 0 - self.q_values[self.past_state, self.past_action])\n",
" self.update_model(self.past_state, self.past_action, -1, reward)\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, 4.02it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Planning steps : 5\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 30/30 [00:09<00:00, 3.31it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Planning steps : 50\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 30/30 [00:56<00:00, 1.89s/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_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:10<00:00, 1.01s/it]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Planning steps : 10\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 10/10 [00:17<00:00, 1.73s/it]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Planning steps : 50\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 10/10 [01:15<00:00, 7.58s/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:51<00:00, 1.72s/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:52<00:00, 1.74s/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:50<00:00, 1.69s/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:51<00:00, 1.71s/it]\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAFdCAYAAAAuSEh/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeVzU1frA8c8DiIKKAu4LkituqWSpZblnamhpmmWrddPM8qemLZbRcm+Z2aJldm3TrLTSQkvtqtli3kxzX3DBNdwFQQVZz++P7+AdcYBBhxkGnvfrxWviO+f7Pc8wyTycc77PEWMMSimllFLKNXw8HYBSSimlVEmiyZVSSimllAtpcqWUUkop5UKaXCmllFJKuZAmV0oppZRSLqTJlVJKKaWUC2lypZRSSinlQppcKaWUUkq5kCZXSimlipyIdBYRIyIPeDoWpYqaJldKKbey+5DN+coSkUQR2Sois0TkFhERT8d5OUQkSESeF5H1InJGRFJEZLuIvC4i1Yqoz69tP8fW+bQREdknIqdFJKAo4lBK/Y/o9jdKKXcSkc7ASuBLYDEgQEWgCXAbEAYsBwYaY057KMxCE5HGwI9APWAB1mvMANoD9wBJwK3GmDUu7vcWYAkw1RgzKo82XYEVwAfGmOGu7N9ZIuID+AMZxpgsT8SglLtocqWUciu75GqcMeaNXM/5Aq8DY4Clxphe7o+w8EQkENgAXAXcboz5IdfzbbESxjSgpTHmuAv79gH2A4FALWNMuoM2n2EleNcZY9a6oE9foKwxJuVKr6VUSaTTgkqpYsMYk2WMGQusAm4RkY4i0t827fWwo3NEZJuI7MmZShSRB2ztu4rIkyISJyJpIrJLRO7PdW5FEXlFRNaIyElbuz0i8potYXLWQ0Bj4K3ciZXtda0DngWqAeOcuaCINBCRiILaGWOygU+BUKCvg+sEAf2BrTmJVWFet93Ps7ttyjMOOA8ML+T7csmaq8K8V7b24SIyX0SSRSRJRGJE5CoR2S8iPxf0s7K7jojIUBH5XUROich5ETkgIt+LSBlnr6NUXjS5UkoVRx/ZHvsAC4GjWAnMRUSkPdAM+NhcOgz/L+Be4ANgPJANfCoiN9i1qQ08DKwDXsYaMVtva/9tIeK9w/Y4M582n2JNEw5w8porgB1Otv0EMMCDDp4bjDWq9ZHdsct53W/YrjUTGAWs5fLeF0cKfK9EJBT4DYjC+lk+DZzDGgUt70Qf9mZg/TyOAM8BTwCfAcnGmIxCXkupSxlj9Eu/9Eu/3PYFdMZKBJ7Mp02krc182/f/sn3fLFe7mUAm1nRYzrEHbG03AP52x2tjTct9aXfMHyjjoP+Xbde4zsnXdArrg7mgdlts163gRNv91q9op3+uK3L/LGzH/2t73VUu53Xb/Tx3AoG52hfmfcl53x+4zPfqdVvbIbn6yjn+s5M/p0pAFtb6M4//e9CvkvmlI1dKqeIo2fYYZHucifUBemGURETKA3cCS4wxhx1cY7qxW39kjIkHdgGN7I6lG9tIhYj4iUiwiFTBWh8F0M7JeIOwFqwXJKdNxYIaGmPCjTGFuWvyI8AXawQIANu0YntgoTHmpN21L+d1v28uXWN1Oe+LIwW+V1gjVkewboSw9waFk4H1/9c1InKdiFQTkUqFvIZS+dLkSilVHOUkVckAxph9WB/899qtiRmElaR8mMc19jo4dgprbdIFIjJCRDZjjZQkACeAn21PB9va+IpIjVxf9h/IyXYxF/S6soGTBTW8DAuA01w8NTjU9vhx7sbOvO5cduU+cJnviyPOvFdXAXuMtcbMPobjWK/bKbYEsS9QC1gDHCP/6VylCk2TK6VUcXS17XGn3bF/A1X536Lth7DW/FyygNwmr9v9L4wGicgY4D2sEZFhWGu8emBNV8H/fkfWtbWx/3rH7ppbgSARaZjXC7ItFG8CHDBFsK7HGHMe+AJoIiLX2+7ouxf4G/hPrlicfd328rozsLDviyMFvleuIiIDsGJbjjXC1gPrZgOlXMbP0wEopZQDOdNM9h/QMcBx4CER2QrcAEwyxmReQT/3Yq1t6mU/ImKrHWXvKNaHsD37Ka/5wE1Yi8SfzqOv+7DWOs25gngL8hEwAmv0KgSoAfzTXFpXytnX7YyieF8c2Q80FBGfXDFXAyo7cwERCQZmAZ8aY0a6OD6lLtCRK6VUsWGbfnsD6AgsNsb8nvOcbbTnU6An8ILt8EeXXKRwsrDWDNmPZvmRK0Eyxpw3xizP9bXdrsmHWNNmox0lKCISCbyKNVL0njOBOVuKIVec64GNWCMyI22v7RMHTZ163U72WRTviyOLgJrAXbmOP1mIa7TEurPwkilOpVxJR66UUp4SKSL32P7bvkJ7PaxprLsdnDMTq07UXcAvxpjdVxjDN1hJzxIRWYC1JupurEXPTjPGpIhIX2Ap8IOIzMdav5QJXIc1UpQI9DXGHHPysiuwfhaFnRr7CJiGlez8bIyJc9DGJa/bjqvfF0cmYcX4iYhcB8RiJeE3YK1hc6bkwy6s8g3/EpH6wDagLNAAqGGMyZ24KXVZNLlSSnnKXbavbOAs1tqgX7Buv1/q6ARjzB4RWQl0xTWjI5OxkpeHsNZQHQXmYY32bM/nPEex7RSRVlg1oPoDvflf/aVtQEfjnu18Psd6XeVwsJDdxmWvG4rkfXHUx0kR6QhMwVqob7BqXHXBqrmV6sQ1jopIT2Ai1jRtEFbSG0vhFuArlS/d/kYp5VVEZDHQAauGUoEfqJ5km2r7GmtEbqwx5k0Ph1RkPPW+2IqLnsSD+yYqlZuuuVJKeQ3b3Xg9gc+Ke2IFYFvUfSfWBtVTRORRD4dUJNz1vohIgIPDT9kelxVVv0oVlo5cKaWKPRFpBzTF2qakKdDUGLPfo0Ept78vtv0DD2Bt2+MLdANuBVYDNzm4K1Ipj9A1V0opb/Ao1hqZvVjbn+z3bDjKxt3vyyJbf7cBAVjr9KYAL2pipYoTHblSSimllHIhXXOllFJKKeVCOi2oXKJKlSomPDzc02EoVaqcP38egHLlynk4EqVKn7/++uukMaaqo+c0uVIuER4ezrp16zwdhlKlSnx8PAC1a9f2cCRKlT4iciCv5zS5UkopL6VJlVLFk665UkoppZRyIU2ulFLKS8XFxREX52jrQKWUJ+m0oFJKeanMzExPh6CUckBHrpRSSimlXEiTK6WUUkopF9JpQeUWycnJHD9+nIyMDE+HovJRpkwZqlWrRlBQkKdDUUopr6XJlSpyycnJHDt2jNq1axMQEICIeDok5YAxhtTU1Au1kzTBKv70PVKqeNLkShW548ePU7t2bQIDAz0disqHiBAYGEjt2rU5fPiwfnB7gZo1a3o6BKWUA7rmShW5jIwMAgICPB2GclJAQIBO3yqlSgxjDPPWHuRQQorb+tTkSrmFTgV6D32vvMfu3bvZvXu3p8NQqthKSs1gxOfreWr+FuasyXO3GpfTaUGllPJS2dnZng5BqWJr2+Ekhs/5i/jEVMb1bMKjnRq4rW9NrpRSSilVYmRlG/79617eWraL4PJl+Hr49VxTL9itMei0oFJeYPv27XTr1o3AwEBq1arFxIkTycrKyvecPXv2MGzYMFq1aoWvry+dO3d2T7BKKeUhfyemMOTDP5i0NJYuEVVZMuomtydWoCNXShV7iYmJdO/enWbNmhETE0NcXBxjx44lOzubV155Jc/ztm3bxuLFi2nfvj3p6elujFgppdzLGMPCTYd57rutGAOv33E1A6+p47E1pJpcKVXMzZgxg9TUVBYsWEBQUBA9evQgOTmZ6Ohoxo8fn2fJhKioKPr16wfAHXfcwcmTJ90ZtnKDypUrezoEpTzuzPkMnv9uK99tPMzVdSrxzuA2XFWlvEdj0mlBpQphzZo19O7dm9DQUAICAmjUqBFz5swp0j6XLFlCz549L0qiBg8eTGpqKr/88kue5/n46D/vkq569epUr17d02Eo5TE7jiTT993fidl0mOGdGjD/0es9nliBjlwp5bS9e/fSpUsXRowYwdixY/Hx8eHgwYM0bdrUYXtjTIHrogD8/PL/ZxgbG0vXrl0vOhYWFkZgYCCxsbFERUU5/yKUUqqEiNkYz1PzNxNUrgxf/qM97euHejqkCzS5Uh7x4qJtbD+c7JG+m9UK4oWo5oU+b9myZYgIQ4YMoXnz5vj5+eU7OjRr1iwefPDBAq9rjMn3+cTERIfTP8HBwSQmJhYcuCqxdu7cCUCTJk08HIlS7pNwLp3nvtvC4i1Hue6qEN67O5KqFct6OqyLaHKllJO6dOlC+fLliYyMBGDMmDFMmTIlz/ZRUVGsXbvWJX07WpRpjNGCn0qpUmV13ElGfL6elLQsRnVrxMiuDSnjW/yWQGhypTzickaOPC0tLY1BgwbRsWNH6tevT7169fJtHxISQqVKla643+DgYE6fPn3J8aSkJF3QrJQqFdIys/jgl728tXwXdYMD+fzhdjSvdeW/X4uKJldKOeHkyZN069aNVatW0bhxY6fOcdW0YEREBLGxsRcdO3ToEOfOnSMiIsKpWJRSylsdSUrl/+ZuZM2+BG5pXoNXbm9BlQrFaxowN02ulHLCypUrSUxMJDw83OlzXDUt2KtXLyZPnsyZM2eoWLEiAPPmzSMgIIBOnTpd8fWVUqo4Msbww5YjPLtgC+czspk0oCWD2tb1iuUQmlwp5YTQ0FAyMzMZNGgQw4YNw9fXl82bN1O1alXuv//+PM8JDb3yu1eGDx/O1KlT6d+/P0899RR79+4lOjqaMWPGXCjPMHv2bIYOHUpcXNyF6cqUlBQWL14MQHx8PMnJyXzzzTcA9O7dm8DAwCuOTXlWSEiIp0NQqkicS8tkYsw25q//m6Y1g3j37jY0qFrB02E5TZMrpZzQtWtXpk6dyvTp0xkwYAD+/v60bt2ayZMnF3nfwcHBrFixgpEjRxIVFUXlypUZPXo00dHRF9pkZ2eTlZV10RTj8ePHGThw4EXXyvl+3759hRqFU8VT1apVPR2CUi6340gyj32+nn2nzjGicwPG9GiMXzFctJ4fKWi9h1LOaNu2rVm3bp3D53bs2JFnLShVPOl75h2ys7MBLRirSgZjDO+t3MO0n/ZQKaAM7wxuQ4cGxad2VW4i8pcxpq2j53TkSimlvNTu3bsBrXOlvN/Js2mMmruB3/ecoleLGrzYrznVKpbzdFiXTZMrpZRSSnnMytjjjPlqI2fOZ/LKbS0Y0i7MKxat50eTK6WUUkq5XUp6Jq8v3cmnq/fTuHoF5hTz2lWFocmVUkoppdwq9mgyY7/axLbDydzTPozn+jSjXBlfT4flMppcKaWUUsotsrINn67ez+QfYylXxpcP72tL92bVPR2Wy2lypZRSXqpKlSqeDkEppx1NOs/EmK38Z/sxOjaswtuDWxf7SuuXS5MrpZTyUq4oUquUO/y88zjjv9nM6dQMnu0dwSM3NfB0SEVKkyullPJSmZmZAPj56a9yVTylZ2bz1vJdvP9zHA2rVeCzh9rRpEZFT4dV5LTynBcTkYEislBE4kXkrIj8JSJ35WqzX0RMrq+jDq7VTERWiEiKiBwWkZdEpOSsLlSqBIqLiyMuLs7TYSjl0MFTKQycsZr3f45j4DV1+P7xjqUisQIdufJ2Y4B9wGjgJNAb+EJEqhhjptm1+wKw/z7d/iIiEgwsB7YD/YAGwBSs5Pu5IoteKaVUifTFmoP884ft+PgIM+65hlta1PB0SG6lI1feLcoYc7cx5itjzE/GmCeBL7GSLntHjDF/2H2tz/X8cCAA6G+MWWaMmQG8CIwRkaCifxmqINu3b6dbt24EBgZSq1YtJk6cSFZWVp7tv/76a/r27Uvt2rWpUKEC11xzDV9++aUbI1ZKlUZn0zJ54ssNPPvtFprUqMhXwzoUj8Tq6FbITC+4nYtocuXFjDEnHRzeAFQr5KV6AT8aY5Ltjs3FSrg6XWZ4ykUSExPp3r07IkJMTAwTJ05kypQpvPDCC3me8+abb1KhQgXeeustFi5cSJcuXbj77ruZNm1anucopdSV2HY4iX7vruL7zYcZ3b0xXz7SnqY1Pfz3eXY2rPkAPuoBK150W7c6LVjyXI81vWdvqIg8AaQCy4CxxpgDds9HAD/Zn2CMOSgiKbbnFhVhvKoAM2bMIDU1lQULFhAUFESPHj1ITk4mOjqa8ePHExR06S+vRYsWXXSbfteuXTl8+DBvvvkmjz/+uDvDV0qVcMYY5vxxgBcWbiOkvD9zHm7H9Q2KQZmQ4zvghyfhwCqo3wVuGOW2rnXkqgQRkW5Ya6beszscAzwGdAPGAR2A30TEfo+BYOC0g0sm2p5TNmvWrKF3796EhoYSEBBAo0aNmDNnTpH2uWTJEnr27HlREjV48GBSU1P55ZdfHJ7jqP5RmzZtOH78eJHFqdyvatWqVK1a1dNhqFIsKTWDRz77i+djtnFT46qsGNPZ84lVVgaseBk+6ATHt0PvN+Deb6FCYSd1Lp+OXJUQIhKOtXA9xhjzac5xY4x9qv6biKwGNgIPAm/bPWccXTaP4zl9PgI8AhAWFnaZkXuPvXv30qVLF0aMGMHYsWPx8fHh4MGDNG3a1GF7Y0y+66JyFHQbfWxsLF27dr3oWFhYGIGBgcTGxhIVFeVU/KtXr6ZZs2ZOtVXeISQkxNMhqFLs9z0nGf/NZo4ln+fpXhE8cmN9fHw8vOHy0a3w3XA4ugVaDoLuL0ClOm4PQ5OrEkBEQoAlwEHgnvzaGmO2ishOINLucCJQ2UHzSjge0cq51r+BfwO0bds2zySspFi2bBkiwpAhQ2jevDl+fn74+OQ9+Dtr1iwefPDBAq9rTP4/usTERCpXvvTtCQ4OJjExseDAgRUrVhATE8PHH3/sVHvlHdLTrQW6/v7+Ho5ElSaZWdm8u3IP037aw1VVyvP18A60CfPwJEdmGvz8KqyeBgEhMOgzaNbXY+FocuXlRCQQ+B7wB/oYY845ear9J3os1toq++vWBcrbnnO9JU9bf1l4Qo2W0Ou1Qp/WpUsXypcvT2SklZeOGTOGKVOm5Nk+KiqKtWvXXnaY9kQu/WvQGOPweG779+/n7rvvpl+/fjzwwAMuiUcVD/v27QOgSZMmHo5ElRYHT6Xw+Jfr2fR3Ev1a1+Ll21oQVK6Mh4P6A74fA8e3Qet7oMdLUN6zuxdocuXFRMQP+BpoBNxgjClwQY2ItACaAB/YHV4CjBORisaYM7Zjd2ItgHe8qKcUSktLY9CgQXTs2JH69etTr169fNuHhIRQqVKlfNs4Izg4mNOnLx1ATEpKcjiiZS8hIYFevXoRFhZW5GvDlFIllzGGr9Yd4pUfdiDAtLvaENWqlmeDSk+Bn16BP96DoNpw1zxocotnY7LR5Mq7TccqHDoKCBGR9nbPbQC6Y00Tfg8cxhqdeg5r+vBTu7YzgCeABSIyCagPRANv5irP4DqXMXLkSSdPnqRbt26sWrWKxo0bO3WOq6YFIyIiiI29eADx0KFDnDt3joiIiDzOgpSUFG699VbS09P54YcfKF++vFNxK6WUvdMp6TyzYAtLth4lMqwy7wxuQ92QQM8Gte07WPo0nDkC1z4M3V+EshU8G5MdTa682822x3ccPHcVcAir5tXbWGuqTgFLgWftkyZjTKLtTsN3scounAbewkqwFLBy5UoSExMJDw93+hxXTQv26tWLyZMnc+bMGSpWtLaOmDdvHgEBAXTq5LgMWWZmJgMHDmT37t38/vvvVKvmvrtklFIlx9r9CTz2+XoSU9IZ17MJj9xUnzK+Hiw0kLgfvh8NcT9Bjavhjk+gXgfPxZMHTa68mDEm3Ilm3Zy81naga4ENS6nQ0FAyMzMZNGgQw4YNw9fXl82bN1O1alXuv//+PM8JDb3yef/hw4czdepU+vfvz1NPPcXevXuJjo5mzJgxF8ozzJ49m6FDhxIXF0e9evUYMWIEixcv5p133iEhIYE//vjjwvXatGlD2bJlrzgupVTJlZaZxauLY/l09X5qVw5g7iMduKaeBxetZ2fB+lmw9BnwKWOtq2o3HPyK5+8yTa6UckLXrl2ZOnUq06dPZ8CAAfj7+9O6dWsmT55c5H0HBwezYsUKRo4cSVRUFJUrV2b06NFER0dfaJOdnU1WVtaFKcb//Oc/AIwadWnRvH379hVqBE4VX9WrV/d0CKoE2n/yHMPn/EXs0TPc2bYuE25t6tlF68mHYeETsGcZ1OsIt02H4PzXvHqaFLTeQylntG3b1qxbt87hczt27MizFpQqnvQ9U6r0McawcNNhJny7FYB/9W9JX08uWs/KhD8/gJWvQnYmdI+GdsPAibuk3UFE/jLGtHX0nI5cKaWUlzp//jwA5cqV83AkytudTcvkmQVbWLTpMG3CKjPtrjbUCfbgovX49bBoFBzdDA17QO/XIaS+5+IpJE2ulFLKSx04YG0RqnWu1JX4Y+8pxn+zmb8TUxjTozEjOjfAz1OL1jPTYOU/rWKggaHQ/0NoMQDyKdhcHGlypZRSSpVC2dmGmb/t5bWlsdQNDmTesA5cG+7BLZV2L4fFT0LiPmhxB/SZAgH51/IrrjS5UkoppUqZE2fSeHTOX6w7kEivFjV4Y2Arypf1UEqQFA8/jIFdSyG0IdyzABo6daN7saXJlVJKKVWKrNx5nDHzNpKakcXkO67mjmvqOLWVlssZAxs/t8orZGUU+/IKhaHJlVJKKVUKpKRn8saPu/hk9T6aVK/IO4Pb0KRGRc8Ec2w7LH0K9v0KddtDv3ehSiPPxFIENLlSSikvVbNmTU+HoLzEtsNJjP1qE7FHzzCobR1e7NuCAH9f9weSkQrLJsK6j6FskLWu6pqhXrdgvSCaXCmllJfKqdCvVF6MMby3cg/vrNhN5UB/Pn3wWjo38dB2WLuXw5LxkLAX2j4IXSZA+SqeiaWIaXKllFJeKiUlBYDAQA9voquKpYRz6Tz33RYWbznKzc2q89qAqwkp7+/+QFITYemzsOkLqNIY7p4HjXu6Pw430uRKKaW81KFDhwCtc6UutXz7MZ75dguJ59J5plcEj9xU3/2L1o2BTV/Cj89C2lloPwK6Pg/+Jf+PAU2ulFJKqRLifEYWry7ewaz/HiCiRkVmD72OpjU9MH2csBdiHocDqyCsA/R6HWpe7f44PKRkrSBTqoTavn073bp1IzAwkFq1ajFx4kSysrKcPj8+Pp4KFSogIpw9e7YII1VKecqe42fo++4qZv33AA91vIqFIzu6P7HKOA8rXoJpbeHoFrj1LXjgh1KVWIGOXClV7CUmJtK9e3eaNWtGTEwMcXFxjB07luzsbF555RWnrjFu3DgqVKjAuXPnijhapZS7GWNYsD6eZ7/dQoWyfswaeh2dGld1fyBxK2HhE5B0EFrdBd0mQpAHN372IE2ulCrmZsyYQWpqKgsWLCAoKIgePXqQnJxMdHQ048ePL/COsd9++42lS5fy7LPPMm7cODdFrZRyh6TUDCZ8u4XvNx/huqtCePeuNlQLcvNG3hnnYfkLsGYGVKoL98VA/c7ujaGY0WlBpQphzZo19O7dm9DQUAICAmjUqBFz5swp0j6XLFlCz549L0qiBg8eTGpqKr/88ku+52ZlZfH4448zceJEqlQpmbc8l2a1a9emdu3ang5Dechvu09w81u/sGTrUZ68uTFfPNzO/YnVzqXw7rVWYnXtwzBybalPrECTK6WctnfvXrp06UKzZs346quvWLx4Mc899xxNmzZ12N4YQ2ZmZoFfBYmNjSUiIuKiY2FhYQQGBhIbG5vvuTNmzOD8+fM89thjzr9Q5TUqVKhAhQoVPB2GcrOMrGwm/xjLfR//SaWAMsx/9HpGdm2En68bP9JTE2HBI/DlnVC2Aty/yCoIWibAfTEUYzotqDxi0p+TiE3IPzEoKhEhETx13VOFPm/ZsmWICEOGDKF58+b4+fnhk09V4VmzZvHggw8WeF1jTL7PJyYmUrnypTvDBwcHk5iYmOd5p06d4vnnn2fOnDmUKVOmwDiU98m5OUETrNJj++FkJny3hQ0HT3Nn27pE923u/krrm7+GpU9bCdZN4+Cm8eDngfpZxZgmV0o5qUuXLpQvX57IyEgAxowZw5QpU/JsHxUVxdq1a13St6P6NMaYfOvWTJgwgXbt2tG7d2+XxKCKn/j4eEDrXJUW322I58mvNxHo78ubg1rRP7KOewNI2AcLH4f9v0Gda6HPt6XuLkBnaXKlPOJyRo48LS0tjUGDBtGxY0fq169PvXr18m0fEhJCpUqVrrjf4OBgTp8+fcnxpKQkhyNaANu2bePjjz/m119/vXBuTjXvpKQkfH19CQjQ4XulvMHplHRe+n47C9bH07ZeMNPviaRaRTeurcrKgF9eh9VTwdcfbplkra/y1RQiL/qTUcoJJ0+epFu3bqxatYrGjRs7dY6rpgUjIiIuWVt16NAhzp07d8larBy7d+8mIyODDh06XPJcnTp1eOihh/jwww8LjE0p5Vl/7ktg1NwNnDiTxuNdGzKqm5vXVv39Fyx6Ao5theb94eaXoZKbR8y8kCZXSjlh5cqVJCYmEh4e7vQ5rpoW7NWrF5MnT+bMmTNUrFgRgHnz5hEQEECnTp0cntOxY0dWrlx50bGlS5cyadIkFi9eTP369a84LqVU0TmfkcWkpbF8uno/NYPKMefhdrSvH+q+ADLTYNlEWPshVKgOg2ZDs37u69/LaXKllBNCQ0PJzMxk0KBBDBs2DF9fXzZv3kzVqlW5//778zwnNPTKfxkOHz6cqVOn0r9/f5566in27t1LdHQ0Y8aMuVCeYfbs2QwdOpS4uDjq1atHlSpV6Ny580XX2b9/PwA33nijLoBWqhjb8ncS4+dvZseRZAZeU4fovs0pX9aNH9f7V8G3j1rFQCPvgx4vQUCw+/ovATS5UsoJXbt2ZerUqUyfPp0BAwbg7+9P69atmTx5cpH3HRwczIoVKxg5ciRRUVFUrlyZ0aNHEx0dfaFNdnY2WVlZBU4xqpKlbt26ng5BuZAxhi/+PMiLC7cTFODH+0Mi6dWypvsCSD8Hy16wRqtCroJ7FkDDbu7rvwQR/WWsXKFt27Zm3bp1DufcmkYAACAASURBVJ/bsWNHnrWgVPGk75lS7nXqbBrPLNjCf7Yfo0P9UN6/J5LKgW4sb7DrR/hhLCT9bS1W7/Ei+Jd3X/9eSET+Msa0dfScjlwppZSXSk5OBihwCyRVvC3ecoRnv91CSnoWz/aO4OGO9fHxybvMikudPQ4/ToAtX0G1ZtYmy+E3uKfvEkyTK6WU8lJHjhwBNLnyVmfOZ/Dy99v5at3fNKsZxOSBV9O81pWXb3FKdjZs+MxKrDLPw41jrYKgWmHdJTS5Ukoppdws9mgy/zd3I7uOneH+DvV4tk9Tyvq5qdJ6wj74fjTsXQnhN8Ktb0OVhu7pu5TQ5EoppZRyk+xsw7sr9/DuT3sICvDjo/uvpUtENXd1Dn9+ACteApNtFQO97hHIZxsvdXn0J+rFRGSgiCwUkXgROSsif4nIXbnaiIg8KyKHRCRVRH4VkdYOrtVMRFaISIqIHBaRl0TEzRtWKaVUyRV34iwDZqzmzWW76NSkKotH3ei+xOrETvi0j7UnYHhHePwvaD9cE6sioiNX3m0MsA8YDZwEegNfiEgVY8w0W5ungeeBcUCs7ZzlItLCGHMUQESCgeXAdqAf0ACYgpV8P+e+l6OUUiWPMYav//qbCd9uoVwZX165rQVD2oXluzeoy2Rlwu9vw8+vWnf/9XsPWg8Bd/Rdimly5d2ijDEn7b7/SURqYSVQ00SkHFZy9aox5l0AEfkvsB8Yyf8Sp+FAANDfGJMMLBORICBaRF63HVNKFTMF7W+pPC8pJYOJC7cSs/EwkWGV+eDetlStWNY9nR/eCN+NgOPbrOrqfd6E8lXc03cpp+OBXixXYpVjA5Azznw9EAR8ZXfOOWAR0MvunF7Aj7mSqLlYCZfj/VWUUh5Xrlw5ypVz4wa+qlB+33OSPtN+I2bjYUZ2achXwzq4J7FKOws/PAkfdoPUBLhzjrV9jSZWbqMjVyXP9VjTewARQBawO1ebHcCddt9HAD/ZNzDGHBSRFNtzi4omVKXUlTh9+jQAlStX9nAkyl52tuGdFbuZ/vMealUOYN4j7Wnnjn0BjYGdiyFmpJVUtbobev4TAkOKvm91EU2uShAR6Ya1Zmqo7VAwcNYYk5WraSIQKCL+xph0W7vTDi6ZaHtOKVUMHTt2DNDkqjg5lJDC2K838ee+BPpcXZMX+zanSgU3jFYlH7YqrO9cDFUj4K65ENau6PtVDum0YAkhIuHAF0CMMeZTu6cc7W8kDp7Lq12e+yOJyCMisk5E1p04caJQ8arC2b59O926dSMwMJBatWoxceJEsrJy58yXmjt3LpGRkVSoUIHatWtz3333cfjwYTdErFTpYozhuw3x3PzWr+w4nMykAS159642RZ9YZWfD2o/gndaw+z/Q5TkY9qsmVh6mI1clgIiEAEuAg8A9dk8lAhVFxDfX6FVlIMUYk2HXztGfvpVwPKIFgDHm38C/wdpb8PJfgcpPYmIi3bt3p1mzZsTExBAXF8fYsWPJzs7mlVdeyfO8hQsXctddd/HYY48xefJkjhw5wnPPPcett97KunXr8NFbsJVyiaSUDF5YuJXvNh6mTVhl3hjYigZVKxR9x8djrWKgB1dDvRvgtukQHF70/aoCaXLl5UQkEPge8Af62Bas54gFfIGGwE674xG25+zbReS6bl2gfK52ygNmzJhBamoqCxYsICgoiB49epCcnEx0dDTjx4/Pc+uTL774gsjISN59990Lx4KCgujXrx87d+7UjZmVcoFNh07zj9nrOHE2jce7NuSJbo0o41vEf7ikn4NfJ8PvU63yCn3ftcor6B9MxYa+E15MRPyAr4FGQC9jzPFcTVYDycBAu3MCgSiska4cS4CeIlLR7tidQCrwSxGE7rXWrFlD7969CQ0NJSAggEaNGjFnzpwi7XPJkiX07NnzoiRq8ODBpKam8ssveb89GRkZVKp08T5lOWtzjNGBRqWuRGZWNtNW7GbA+6sp4+vDwsc6MvbmJkWfWB36E2Z2hVVvQcs7YMQfEHmvJlbFjI5cebfpWIVDRwEhItLe7rkNxpjzIvIa8LyIJPK/IqI+wDS7tjOAJ4AFIjIJqA9EA29qjav/2bt3L126dGHEiBGMHTsWHx8fDh48mOcIkDHGqXVRfn75/zOMjY2la9euFx0LCwsjMDCQ2NhYoqKiHJ43dOhQbrvtNmbPns1tt93G0aNHee655+jSpQvNmjUrMC5V/F111VWeDqFUij+dyqgvN7DuQCK9WtTgtf5XUymwTNF2ej7JGq1aPQ3KV4NBn0GzvkXbp7psmlx5t5ttj+84eO4qrGKhr2ElU88AocA6oIcx5lhOQ2NMou1Ow3exyi6cBt7CSrCUzbJlyxARhgwZQvPmzfHz88t33dKsWbN48MEHC7xuQaNIiYmJDu8GCw4OJjExMc/z+vTpw6effspDDz3E/fffD8D111/PwoULC4xJeQd/f39Ph1DqxGyMZ8K3W8k2hrfvbE2/1rWKvtJ67GLrTsAzR6DNvXDLa1DWDWu61GXT5MqLGWPCnWhjgH/avvJrtx3oml8bVzr6r3+RtsMzy7nKNo2gxrPPFvq8Ll26UL58eSIjIwEYM2YMU6ZMybN9VFQUa9euvew47Tn65W2MyfeX+sqVKxk+fDijRo2iV69eHDt2jOjoaG6//XaWL1+Or69uHentEhISAAgJ0TpGRe10SjqvLo5l3rpDXBsezJuDWlM3JLBoOz1zFBaPgx0LoVpzqxhonWuKtk/lEppcKeWktLQ0Bg0aRMeOHalfv36BW4+EhIRcsubpcgQHB18oFmkvKSkp3/pGY8eOpW/fvkyaNOnCsdatWxMREUFMTAz9+/e/4tiUZ+WUQNHkqmit2XuKJ+Zu4MSZNIZ3asCTNzfGryjXVmVnw5r34bcpkJ4CXZ+DG/4PfIt46lG5jCZXyiMuZ+TIk06ePEm3bt1YtWoVjRs3duocV00LRkREEBt78SjfoUOHOHfuHBEREXmcZa3Vuuuuuy461qRJEwICAoiLiyswLqVKu4ysbN7/OY63l+8iLCSQmMc60rLOlf/BlK/ThyBmBOz7FWpfA7e9D1WbFG2fpUDO71m3bJaNJldKOWXlypUkJiYSHh7u9Dmumhbs1asXkydP5syZM1SsaN3QOW/ePAICAujUKe+tH+vVq8f69esvOrZjxw5SU1ML9TqUKo2OJp3n0c//YsPB0/RrXYt/3t6SCmWL8CMzOws2zIH/PA8mC259C655ENyUDJRUWdlZ/H74d2ZunsngiMH0qd/HLf1qcqWUE0JDQ8nMzGTQoEEMGzYMX19fNm/eTNWqVS8sFnd0Tmjole8nNnz4cKZOnUr//v156qmn2Lt3L9HR0YwZM+ZCeYbZs2czdOhQ4uLiLkxXDh8+nNGjR1OrVq0La65eeuklwsPD6d279xXHpVRJZIxh0eYjTFiwhYzsbKbd1YaoVrWKttPEA/DtcKsYaFgH6PcehDYo2j5LuLSsNBbGLWTWtlkcSD5ASLkQ/Hzcl/JocqWUE7p27crUqVOZPn06AwYMwN/fn9atWzN58uQi7zs4OJgVK1YwcuRIoqKiqFy5MqNHjyY6OvpCm+zsbLKysi6aYnziiSfw9/fn/fffZ8aMGVSuXJmOHTvy6quvUr58+SKPWylvk5KeyYsLtzNv3SGa1wpi+pBI6oUW4b8VY6zRqh8ngMmGvtOsuwF1tOqypWam8mXsl8zeNptT50/RLLQZkztNpnOdzpTzK+e2OESLCSpXaNu2rVm3bp3D53bs2KHVwL2MvmfeITMzEyi4Vpoq2IaDiYz5ahP7T53j0U4NGNOjiBetn4qDmJG2rWs6Qr9pEFK/6Por4c6kn+HL2C+Zs30OiWmJXF/reh5q8RDX1ri2yNZZichfxpi2jp7Tf5FKKeWlNKm6clnZhreW7eKDX+OoVrEcXzzcng4Nrnw6P0+Z6fDfafDza+BXDm59GyLv1wrrl+ls+lk+3PIhC3YvIDEtkRtr38jDLR8msnqkR+PSf5lKKeWlTp06BeCStX2l0dGk8zwxdwN/7kvgtta1eP7WZoRWKFt0Hcb/Za2tOrkLmvSGPm9CUM2i668EO5Fygs93fM5XO7/iTMYZbqh9A4+3fpzmVZp7OjRAkyullPJaJ0+eBDS5uhxLtx7h6QVbSM/MZvIdV3PHNXWK7jb99BRYNhHWfghBteDur6FRD11bdRkOJB/gs+2fMX/XfLLJpntYd4a2GFpskqocmlwppZQqNc6mZfL0/M18v/kIrepU4s07W9OgahFtJWMMbJ1vJVbJ8XDtP6yCoAF5F/9Vju04tYNPtn7Cjwd+xAcfbm90Ow80f4CwoDBPh+aQJldKKaVKhZ9ij/Hk15tJOJfOE90aMaJzA8qVKaJtoBL2WVvX7FkGNVtD/5kQfkPR9FWCbTqxifc2vMd/j/yX8mXKc1+z+7i32b1UC6zm6dDypcmVcouC9sFTxYfeQaxKmrTMLKavjOOdFbupHlSW+Y924Jp6RbRlUEYqrJkBK18FHz/o8RJ0GAk+updnYWw8vpFpG6bx59E/CfIPYlTkKAY1GUSQf5CnQ3NKoZIrEekPjAQigQDgAPAV8LYx5qTrwys8EYkGRhpjqhTiHH/gWeA7Y8xGu+PhwD4gyhjzvWsjLT3KlClDamoqgYFFvMmpconU1FTKlNE9zFTJcCz5PE98uYE1+xLo2bw6b9/ZhgD/Ikp0jm6Bbx6CkzuhQVfoM0XLKxRCtslm5aGVzNo2iw3HNxDkH8S4tuPo17AflcoW8bZDLuZ0ciUiU4D/Az4B3gKSgWbAcKA5cHtRBOgm/sALwH5go93xI0AHINbBOcpJ1apVIz4+ntq1axMQEKAjWMWUMYbU1FTi4+OpXr26p8NRTmjUqJGnQyjWYjbGMzFmG+czsnj9jqsZ1LZu0XSUmQa/TILV06BsRRj4KTT35o9E90rPSue7Pd8xe/tsDiQfoHaF2jx93dPc3vB2Ast45x/lTiVXIhIFjAEeMsZ8bPfULyLyb+DmogjO04wxacAfno7D2+Vs0XL48GEyMjI8HI3KT5kyZahevfqF90wVbz5aG8mhlPRMXv5+B1/+eZDIsMpMHtiq6Bat71wCS5+GxP3QvD/0fgPK692bzkjPSueHvT/w8daP2Z+8n+ahzZncaTLdw7q7dauaouBs9KOB9bkSKwCMMVnAEhHpDKwEWhpjtuY8LyI/AyeNMXfYvv8UaIE1UjQZCLeddy8QAswErgN2AEONMZtt54XjYIou53p5VUkVkfLAJKAHUBc4BiwGnjHGJNuanbE9fiIin9j++yrb44U+RWQW0NQYc12uPkbaXktVY8xZEfEBxgMP2/o8APzTGDPLUYylQVBQkH5gK+ViJ06cAKBq1aoejqT4WLs/gTFfbeRQQirDOzVg7M2NKVMUldbPnYQlT1l3A1ZpBPfMh4bdXd9PCZSVncVXu75i5uaZnEg9QZPgJrzd+W26hnUtMTMbBSZXIlIGuB6Y4sJ+w4CXgOeAQGAa8G+sRGsm8DrwKjBXRJqbK1thGwj4AhOAE1jJzgTga6CnrU1X4CfgFeAH27EjQO7qbnOBxSJS3xiz1+74IOAHY8xZ2/fTgPttr3E9VmL3sYic0rVbSilXSUhIADS5AjifkcU7K3bz/s9xVKngz7xH2tOufhGMIBkDW76GxU9ai9c7PAadn4GyRTQyVoJkZWexaO8iZm2bxZ7Te2hZpSWvdHyFDjU7lJikKoczI1ehQFngoAv7DQE6GGPiAETkamAccL8xZrbtmGAlOhFYo1iXxRhzAng053sR8cMajVolImHGmIPAWtvTccaYP+za5r7cMuAUVjL1mq1NbaCj7Rgi0tDW34N2I1XLRaQm1midJldKKeVCB06dY9TcjWw8dJpeLWow6Y6rCSpXBDdlJB+BH8bCzh+gznXQaxLU9uw2K94gMzuTJfuWMHPLTPYl7aNxcGNeu/E1+tTv4+nQikxhJjVdeX/2/pzEymaP7fEnB8dqcwXJFYCI3Iu1ZqwRYL/FeWMKkTQaYzJFZAFwJ7bkChgInON/I17dgGzgW1sil2MFcJeI+NqmUpVSSl0BYwyf/XGAf/6wgzK+PkwZ2Ir+kbVdPwqSmW5VV1/5L8g8Dze/Au0eBV/vXhdU1DKyM1i6bynTN07n77N/07ByQ97s/Cbdw7qXuJGq3Jz5P+MUkIY1lecqp3N9n+7geM6xclfSkYjcDswG3scqt5CANd337WVeey7wDxFpbIzZhZVoLTTGpNqer4I1DZmUx/k1gb8vo1+llFI2x5PPM37+Zn7eeYIbG1Vh8h2tqFHpij4uHNv/u1UM9Pg2aNAN+ryh5RUKcC7jHN/u/pbZ22dz5NwRGgc35p0u79C5bmd8pHTchFFgcmWMyRCR37HWJz2XT9Pztkf/XMdDAFfUwMrv+vkZCKwxxozIOSAina4gjp+Bo8CdIjIbaIe1PixHApAJ3IA1gpXb8SvoWymlSr0lW44w7pvNZGRl81yfpjxwfTh+rl60nnHeugvwr0+hUh2483OI6KP7AebjfOZ5YvbE8MHmDziReoLIapFMaDeBG+vcWGqSqhzOjmm+DSwUkftz3/FmuzPuZiDnDsGmWIu4EZG6QBNglwtiPQ5k2K6f03cFrDpUB/I5LwBr5M3ekFzfOz1KZozJFpFvsEaszmPV+1pq1+QnrJGrSsaYZQVdTymlLleTJk08HYJbpaZnMXreRpZuO0rTmkFMHxLJVVXKF3xiYR34LywaZRUDbTsUur2g+wHmI9tk88WOL5i5ZSYJ5xO4uurVvNHpDSKrl971aE4lV8aYRSLyJvCRiNwAxABnsRabD8daQ3W7iKwFXhaRFMCH/03DXTFbUhMDjBaRA1hTiGOB1PzPZBnwnohMANYAvbHWRdlfO11E9gGDRGQrVtK0OZ9rzsOqVD8a+NYYk5OcYYzZKSIzsO50fB1Yh5W0NQcaG2MedvpFK6WUAmDn0TM8/uV6dh07yxPdGjGyS0P8/Vw8GpKZZq2r+u+7EFQb7pwDTaNc20cJkpaVRsyeGD7b/hn7k/fTrkY7hrUaRtvqbUv8mqqCOL0azxgzVkRWYyUVX2CNCO0HFgJv2JrdDXwIzMFaVzQeKwFxlZFYJRumA4nAP7HKRLTI55wPgPrAKKwkZ5ktztzFQYdjvY7lWHdHXkXefgcOYZV1mOvg+cewRuv+gVWOIRnYDnyUzzWVUqpQjh07BlCiK+pnZxs+/n0fk5bGUinAn9lDr+OmxkVQemLvL1bdqhM7oPU91p6AWgzUoZSMFObunMuc7XM4kXqCZqHNmHzTZG4Ov7nUTf/lRXSTVuUKbdu2NevWrfN0GEqVKjt37gRK7vTgiTNpPLNgM8t3HOfGRlWYMqgV1Sq6eNF6SgKseNFaW1WhBvSdCo17FnhaaXQu4xzf7PqGj7d+TML5BK6vdT0PNH+A9jXbl8qRKhH5K68C5nofqVJKqWLnuw3xvLhoG+fSs3j+1mYMvSHctR/gxsD6WfDTK1aCdd0j1mhVmQDX9VFCJKUl8fmOz/l8x+ckpyfTrmY7Hm/zOK2qtvJ0aMWWJldKKaWKjTPnM3h7+W4+WrWPVnUr88YdV9OoekXXdnIqzlqwvv83qxjoPQug5tWu7aMEOHbuGJ9t/4y5O+eSlpVGl7pdeLjlw1xdVX9WBdHkSimlVLGwbn8Co+ZuJP50Kne3C2Pirc0oV8bXdR1kZcCaGfDza+DjC33ehGseBN0A+yIHkw/y0daPWBi3kGyTTbewbjzc8mGahTbzdGheQ5MrpZTyUj4lJCk4n5HF9JV7eHflHmpWCmDBiOuJDAt2bSeHN8CCYVZ5hYY9IOptq36VumBX4i6mrZ/Gz3//TFnfstzR6A7ub34/dSrqz6mwNLkqgIi8AdxhjAn3dCxKKWWvUaNGng7hih1KSOHJrzexZl8CvVrU4I2BrShf1oUfTeeTrHVVf86EijXgrrnQ+BYtBmpnT+Iepm+azrIDy6joX5ERrUZwe6PbqVG+hqdD81qaXCmllPKIpVuP8vSCzWRlGaYMbMWAa1w4QmIM7FhobV1z9ri1YL3Ls1oM1M6mE5v4cPOH/Pz3zwT4BfCPlv9gSNMhhAZoCYor5ZHkSkR8AV/74pueJCIBdnsDehURaQiMA9pj1fv6zRjTOVeb/UC9XKceM8bUyNWuGTANq+r9aayaZS/qRtNKFU9HjhwBoGbNmh6OpHDOpWUyfv5mfth8hBa1g3j3rkjCXVlpPSkeFj4OcSugShMY/CXUucZ11/dixhjWHVvHx1s/ZlX8KiqVrcSIViMYHDGY4HIunootxdySXInIp1gf/K9gFf5sDHQVkRDgedtzp7E2WJ5g28+wPhAH3GCMWW27zpfAYKCVMWaz7dgiINkYM0REygOTgB5YBT6PAYuBZ4wxyXbxGKzq7mFYW+EkAQ1FpDJWgdJ+WIU/3y2yH4rrNMeqOv8Hl+67aO8LrMQpx0WJrYgEYxVQ3Y71+hsAU7Aq7ee3p6RSykOSk61fa96UXG04mMjYrzax9+Q5xvZozCOd6lPWz0WL1rOz4a+PYdkL1sjVLZPg2ofBVydpMrMzWX5wObO2zmLrqa0Elw1mVOQo7o64m8AygZ4Or8Rx5/9x4cDrWBXLj2FVQP8Eq4L6s1gf5q9ifZg/aYzZKyLxwI3Aats1bsTamuZGYLNYRU9usJ0PEIi1r98E4ARWgjUB+Bpr42l744BfgXttfWKLpzPwf1ibMz9piyvzyl9+kVlkjIkBsO15WCWPdkeMMbmr0tsbjlV1v78tEV0mIkFAtIi8bp+cKqVUYaVlZvHeyjje/Wk3VSqU5YuH23F9w7x+XV2GpHj47lHY9wtcdRP0eQuqNHTd9b1UelY683fPZ9a2WcSfjSesYhjPt3+eqAZRBPhpTa+i4s7kKhTobozZaEuK9gOzjTEjchqISBrWPoCvGmNOAb9hJVKTbCNZNbGSsRuB94CWQLCtHcaYE8CjdtfzA/YBq0QkzBhz0C6eo8aYO+3aNgduAwYbY+bZjq0EDmKNYhVLxphsF12qF/BjriRqLtZIYCdgkYv6UUqVMnuOn2XsVxvZ9HcS/dvUJrpfc4LKlXHNxY2xqqv/53nISoeodyDy/lK/YD0jK4P5u+czc/NMjqce5+oqVzOu7Tg61+2Mr48Ly1soh9yZXMUbYzba/rsx1pTcV7YEKMdPWPv/tQB+wUqa/ikiPsBNWJspL8JaC4TtWALWVBYAInIvMAZoBNhP4jfGSpRy/JArvmttjwtzDhhjzorIMqBdoV5p8TRURJ7A2uh6GTDWGHPA7vkIrJ//BcaYg7ZNuCPQ5EopVUjGGOasOcjrS2Lx9RXeGdyafq1ru66DQ39a+wEeXg9XdYJb34LQBq67vhdKzUzl293f8um2Tzly7ghtqrXh5Y4v06Fmh1K5RY2nuDO5Omb33zljwYvzaFvX9vgrUBkr2boRK9n6HahhG8m6EVhlbBskisjtWOu23seaKkzAGu36FitpyysegBrAGQcL248X+MqKvxisNVl/A02BF4DfRKSlMSbJ1iYYa91bbom255RSxYyfX/FdS3QkKZXR8zbyx94EOtQPZfLAq6kT7KK1Penn4McJ1vY1FWpAv/eg1d2luhhoUloSc2Pn8vmOz0lMS6R11dZM7DCRG2rdoEmVB7jzX6b9DtEJtsdHgA0O2u6zPW6ztb0Ra5TqGWNMsohsth27EXjT7ryBwJpcU42dnIgHrDVWFR3cOVgt75fkHYwxo+y+/U1EVgMbgQeBt+2bOjhd8jiOiDyC9R4SFhbmmmCVUk5r0KD4jdIYY/hx2zHGfbOJtMxsXrmtBXdfF4aPjws+4C8qr3AM2g2HLhOgXNCVX9tLpWSk8PHWj5m9fTapmal0qtOJoS2GElk90tOhlWqe+rNnJxAPhBtjZubVyBhjROR3YBDQEGskC9vjUKxRqd/sTgkA0nJdZoiTMa21PfYFctZcVcC687DYrrm6HMaYrSKyE7D/15eINUqYWyUcj2hhjPk38G+Atm3bOkzAlFKlR8K5dCbGbOX7zUdoWjOIt+5sRUQNFyU+p+Lg+9HWgvXqLWHQbAhr75pre6HcI1U9w3vyyNWP0Di4sadDU3gouTLGZIvIWOAz2x1pS7BKA9THWlR+hzEmxdb8V2AysNMYkzNF9xvwBJACrLe79DKsBfETgDVYJQq6ORnTNhFZCLxvi+kI1h2FKfmf6dXsE6JYrLVVF4hIXax1a7HuDEop5Zz4+HgAatd24Tqmy/TH3lM8+fUmjp9J44muDXm8WyPK+Lpgmi4jFX6fCqveAh8/6P2GtR9gKS2vcPTcUT7b/hnf7PqGlMwUbqpzE/9o+Q9aV2vt6dCUHY/932mMmSciyVhro4YCWcBe4HsursGUMzL1q4Nja4wxGXbHP8BK0EZhrbFaBtyNtd7IGQ9grdd6GziLdUfiWuAOJ8/3CiLSAmiC9fPKsQQYJyIVjTFnbMfuxFoA/4ubQ1RKOeHs2bOeDoG0zCxe/n47c/44SFhIIPMeaU8bV+0LeGQTxDwGR7dA077QaxIE1XLNtb3MoTOH+GTrJ3y751uMMdwcfjMPtXiIJiFNPB2ackBsa8GVlxKRQKwROrAKowZhLVgH64aBLsA9WEnrYazRqeewpk9b55ResBUR3Q5sxSq/UB9rPdvbxpgCi4i2bdvWrFu3zkWvSinljJ07dwLQpIlnPmD/OpDAxJhtbDuczAPXhzP+liYE+rvgb/bMNPj1Dfj9bQgIgVv+BS0GXPl1vdDepL3M3DyTxfsW4yM+DGg0gAeaP6CbKRcDIvKXMaato+dK57hqyVINq0iqvZzvrwIO2dq8jbWm6hSwFHjWvqaVMSZRRLphVaVfhLXO6i0guiiDV0p5n8ysbN7/OY43l++iSoWy/Pvea7i5uYs2+d33//wz0QAAIABJREFUG/wwBk7ugpaDoOc/oYLX31dUKDlb1MzcPJP/Hvkv5XzLcV+z+xjSdIhupuwlNLnycsaY/Vh39OXH2XVn24GuVxqTUqrk2nY4iafnb2FLfBJRrWrxWv+WlC/rgo+S80mwPBrWfQyV68GQ+dCo+5Vf18tsPL6Rd9a/w7pj6wgp9//s3Xd0lFX6wPHvnZreC6SHJJTQu2IvqNhAEXVVrKuuu65dV1fdVde6RX/uuqtrZ22ICCqKoqKCgCAiJQnpvZJKQspk2v39MaEakZKe53POnAPve+edZ+5hhmfuve9zQ7hl4i1ckHIBYd5dWM1edDtJroQQop+yWA62nWjXcrs1L6zO5/++zMXfauLfl03inHFdsKeh1rBtEXx2L7TVw7E3e8orWAbXfnebdmzi9YzX+ab0G4KsQdw++XYuHXGp7PvXT0lyJYQQ/VRiYmKPvE5hbQt/WLyN74vqOWv0EP4yZwzh/tajv3BVmqcYaOEqiJ3uWbAeNfHor9uPbKnewitpr7CqbBUB1gBuGn8TV4++WpKqfk6SKyGEEJ1yuzVvbSjmseWZmI0G/nbROC6aHHP0Fb+d7bD+P/D142D2gTMeg+k3grGL9hvsBzLqMngl7RW+KP6CQGsgV4+5mt+M+40kVQOEJFdCCNFPlZaWAhAbG/sLLQ9fVaONe97fxuqcGmYkhfLU3HHEhnTBf/zF6+DjO6AmE5JOhTnPg//gWKSttWZN+Rpez3id76u+x8/sx03jb+KK1CsIsAzeKvMDkSRXQgjRT7W2dn2NY601H2wp5+Fl22l3uHlk9mjmHxN/9KNVbTvhiz/Bj/+DgGi4bBEMP7Nrgu7jtNasrVjLM5ueIachhwifCO6cfCdzh8/F3+Lf2+GJbiDJlRBCCABK61t56KMMVmZVMy4mkGcumUBSuN/RXdTthu9fhFVPQlsDHPNbz4J161Fetx/YPVL1323/ZWvNVmL8Ynjs+MeYlTAL8yCaAh2MJLkSQgjBsq0V/HFJGg63m/vPHsW1xydiPNrNlovWwCd37Z0CPPk+iJ3WNQH3YVprVhStYHHOYjZUbWCo71Dun34/F6RcgNXYBTcCiD5PkishhBjE6lvsPLwsgw+3VDAxLoh/Xjrx6NdWNdfAV490TAHGwNxXPBXWj3ZqsY9zuBy8kfkGnxV+RmZ9JjF+Mfx2wm/59Zhfy0jVICPJlRBC9FNeXl5H9fzv8uu4Y9EWqpps3HjSMO4+YwSmo9lseU/Nqj94ioJOuxFmPgxm76OKs69rdbTyUf5HvJL+ClUtVaSGpvLH6X/k4uEXYzQYezs80QskuRJCiH4qPj7+iJ5nd7p57us8/vVVLlGB3nzw2+MYHxt0dMHU5cPSG6FsIwwZB1cvh8jUo7tmH+dwOViat5TnNj9HQ3sDE8In8NCxDzEjasbR3wAg+jVJroQQYhDJq27mN29uIq+6mQsnRfPYnLF4W45idKWtAdb8H6x/3jNCdc7TMPkaMBzFCFgf1+poZXHOYhZsX0B1azWTIibxj4n/YErkFEmqBCDJlRBC9FvFxcXAoY1gaa15Y30xjy/PxNdi4rWrp3LKyKPYEFlrSFsMnz8AzVUw7hLPXYDBRzaa1h80tjfydtbbvJ35NjvbdzJ1yFQemfGIjFSJn5DkSggh+imbzXZI7UrrW7l3yTbW5tVx4vBw/jp3HEMCj2K9VlMFfPoHyPwIIsfCpW9BzJQjv14fV9VSxYKMBXyQ9wEtjhZmRM/gpvE3MT58fG+HJvooSa6EEGIAe2N9MY9/konRoPjLnDFcPi0Ow9GUWNi0AFY+DO3NcNxtcNqfB+wUYIOtgf9s+Q9L85bicDuYGT+TG8bdwPDg4b0dmujjJLkSQogBqHqXjev/t4mtpTuZlhDC3+eNJy70KEos1BfChzdD8RqImwFn/w2GjOm6gPuQiuYK3sx8k8U5i7E5bZwUexJ3Tr6ThMCE3g5N9BOSXAkhxACitebz7Tu4f2k6ze0O7ps1kl+fMOzIC4I67bDhefjqMTBZYdZfYcp1YBx4/31UtVTxwtYX+DDvQzSaWYmzuH7s9QwLGtbboYl+ZuB9OoQQYpDw8dl/JKq+xc4DH6SxPK2K4ZF+vH7NVMZEBx7ZxbWGjKXw1aNQnw/DZ3lGq4K6fpPo3lZvq+eN7W/wxvY3cGs380bM49ox1zLEd3BsKC26niRXQgjRT8XGehIdrTVLfiznqc+yqG1u564zhnPDiUlYTEe4FqqpwrNtTfYnEBQPv1oIw88acBXW6231vLTtJRbnLKbd1c5ZCWdx6+RbifaL7u3QRD8nyZUQQvRjja0OHvgwnWVbKxgXE8hr10xldNQRjla5XZ5Nllf+BbQLZv4Fjv0dDLAq4+XN5by07SU+KfiEdlc75yedz7Vjr2VYoEz/ia4hyZUQQvRT76z8gQXrishr8+Ga4xJ44JzUI19bVf4jvH8d1BdA8kzPFGBIYtcG3MsKGgt4L/s9FmYtRCnF+UnnMz91PklBSb0dmhhgJLkSQoh+Zvdmyz9uyyYm2JvFV89gwpFuX2NrhM8f9Gyy7Bc5IDdZzqjN4NX0V/mi+As0mvOTzueWibcQ6RvZ26GJAUqSKyGE6EfW5NZy68LN1Lfa+fXYIcyeEMWYI0ms3G7Y9Cp88xS01sExN8FJfwDvo9xjsA/ZUr2F5zY/x4aqDfib/blu7HVcNvIywn3Cezs0McBJciWEEP1AS7uTJz7N5M31JQwJ8OKD3x6HV+uOI7tY8Tr47F6o3Apxx3oWrMdM7tqAe4nWmrUVa3k9/XU2VG0gzDuMOyffyUXDL8LP4tfb4YlBQpIrIYTo477OrubPH2ZQ2tDKdccncveZI/AyG8nOPszkqrXeMwW45U3wj4ILX4Kx8wbEFKDL7WJF0QpeTn+Z3IZcInwiuGPyHcwbPk+SKtHjJLkSQog+yuZw8cTyTBZ8V0xSuC8Lrz+G6cNC95z38zvEpMHlhI0vwdePg70Fjr/dMwVo9u6myHuOy+3is6LPeGHrCxQ1FZEUmMSjxz3K2YlnYzaaezs8MUhJciWEEH3QltKd3LZwM0V1ntGqe84agdW0f0mE6OhDqMdUtgk+vg2qtkHiSXDWExA5upui7jlu7WZN+Rqe2fQMeTvzGB48nKdPfprT4k7DoAbmXoei/5DkSggh+hCny83/fZnLc1/nMSTAizevm87xKWGHf6G2nfDln2HT6+ATChe9CqMv7PdTgO2udj7O/5j/bf8fBY0FRPtF87cT/8YZCWdIUiX6DEmuhBCij8jdsYt73t/G5pKdXDAxmkdmj8bf6+entvLz8wFIStqnTpPWsHUhrHwYmqvhmN/BKfeB1b+7w+9WrY5W3sl6h/9t/x/1tnpGhYziiROe4MyEMzEbZPpP9C2SXAkhRC/TWvPyt4X8/fNszEYDz146gdkTfnnKz+l07n+geB0svwd2pMHQCXDJW/3+LsAGWwNvZr7Ju9nv0tjeyLFDj+W6sdcxbcg0VD8fhRMDlyRXQgjRi/Kqm7l78VY2l+zktJERPDJnDNFBh7nQvL0Z1v0TVv0VfMNg1l9h6vVg6L/TZA22Bl5Lf42F2QuxOW2cHHsy1465lgkRE3o7NCF+kSRXQgjRC1xuzYJ1RTz5WRbeZiNPXDiWS6bEYjic7Wu09oxWffQEtFR7yiqc+QT49d8imWk1abyW8RorS1YCcFbCWdww7gbZokb0K5Jc9XNKqWTgbuAYYAzwrdb65APaKOA+4CYgDNgI3KK13nJAu1TgX8CxwE7gZeBhrbWrm9+GEINKQU0zdyzaypbSnZwyIpwn544jMsDr8C5S/iN8/TTsyIChUXDpWxA7rXsC7mZaa9aUr+HV9Ff5YccP+Fv8uTL1Ss4Zdg4jQ0b2dnhCHDZJrvq/0cDZwHrA8jNt7gUexJOEZQF3AF8qpcZorasAlFLBwJfAdmA2kAT8AzAAD3TnGxBisNDaM1r11GfZmAyKv88bz9xJ0Ye3dsjWBJ8/AJvfIMCUANOvgDNv77dTgJt2bOK/W//Ld5XfEekTyd1T7mbu8Ln4mn17OzQhjpgkV/3fMq31hwBKqcV4Rqb2UEp54UmuntBaP9dx7DugCLiZvYnTbwBv4EKtdRPwhVIqAHhIKfXXjmNCiCO0o8nG79/ezPdF9RyXHMrfLhpP1OGsrXK7Yes78MWDnkrrx9zE0BPuAt/QX35uH+Nyu1hVtorXM15nc/Vmgq3B3DP1Hi4deanc+ScGBEmu+jmttfsXmswAAoBF+zynRSm1DJjF3uRqFrDigCRqIfAUcBKwrMuCFmKQ+WRbJX94fxt2l5uHzkvlqhkJhzdaVbEFlt8FZRsh9hi4/AmIntR9AXeTVkcrH+R9wFuZb1Gyq4Qo3yjum3YfF6RcgLep/1eLF2I3Sa4GvpGAC8g94HgmcMkB7b7at4HWukQp1dpxTpIrIQ5TY5uDRz/eznubyhgXE8jTF08gOeIw9rlrb/ZsWbPhefAKgnOehslXg8FTqT031/OxTklJ6Ybou05VSxXvZL3Deznvscu+i3Fh4/j9pN9zetzpmAzy35AYeORf9cAXDDR3sii9AfBRSlm01vaOdjs7eX5Dx7mfUErdANwAEBcX13URCzEAfJtbw73vp1HZ2MbNpyRz6+kpmI2HuC5Ka9j+AXx2H+yq9CRUMx8Br8D9mrndvzRw3bsy6jL4X8b/+Lzoc9y4OS3uNK5MvVLKKYgBT5KrwUF3ckx1cu7n2nV2HK31i8CLAFOmTOm0jRCDzS6bgwc+SOfDLRUMC/Nl8U0zmBTX6e+TzpX94Emqyr6HIWPh4jcgdmr3BdzFnG4nXxZ/yavpr5JZn4mv2ZdfjfoVl428jBj/mN4OT4geIcnVwNcA+CuljAeMXgUBrVprxz7tgjp5fiCdj2gJIQ7wdVY1dy/eRn1LO9cel8jdZ47A22L85ScCtNR6ioB+/6JnL8Cz/w6TrwFj//iabne182Heh7ya/irlzeUkByVzz9R7mJM8B39L/956R4jD1T8+teJoZAFGIBnI3uf4yI5z+7bbr6CMUioW8D2gnRDiALXN7Tz1aRbvbSpjeKQfL181hQmxnf1W6YTWkLYYPrkD7M0w5Ro47U/gfRijXb2oqqWKlSUreTXtVarbqhkXNo7bJ9/OaXGnyXoqMWjJv/yBbx3QBMwDHgVQSvkA59ExpdfhU+BupZS/1npXx7FLgDZgVc+FK0T/8sm2Sh78MJ3GNgc3nZzErael4GU+xNGq2jz48HdQuh6GjocLXoSIQy+aGRR0iAlcNyjdVcrbmW+zMHshTreTYYHDeOKEJ5g6ZKrs+ScGPUmu+rmOROnsjr9GAwFKqYs6/r5ca92qlHoSeFAp1cDeIqIGPNXYd3sBuAVYopR6ChgGPAQ8LTWuhPipNruLv63I5tW1haQODWDhDccwPPIQp7/adsKXD8Gm1z2L1M99BiZdfdiFQCMjIw837KNWuquUhVkLeTvrbdAwK3EW14y5huSgZEmqhOggyVX/FwG8d8Cx3X9PxFMs9Ek8ydR9QCjwAzBTa71j9xO01g1KqdOA5/CUXdgJPIMnwRJC7GNTcQO3v7uF0oZWLpsexyPnj8Z0KHcCag3b3oUV90NbPUy/EY67DQKGdn/QRymrPouX015mRdEKjMrIWYlnccvEW4jyi+rt0ITocyS56ue01kXsvfPv59po4LGOx8HabQdO7bLghBhgHC43//g8hxdX5xMZ4MXbvz6GY5MOsUJ6xRZPUlW8BqKnwGWLIGbyUcWTne1ZRjlixIijus7P0VqzsWoj/932X76v+h4/sx+/Hvtr5g2fJ0mVEAchyZUQQhyCtLJG/rg0jbTyRuZMiOLh88cQ6HMIW7U42mDtP2HVk55CoP3gLkCtNesr1/PclufYVrONMO8wbpt0G/NGzCPAEtDb4QnR5/XdT7cQQvQB7U4Xz36Zy8trCgnwMvHcZRM5d9whjtrkfA6f/QHqCyB1Npz/r58UAu1L7C47nxZ+ypuZb5JVn0W4dzgPHvMgs5NnYzVaezs8IfoNSa6EEOJn/FjSwB8WbyO3upnzxkfxp3NTCfc/hCRjZyl8fj9s/xBCU2D+B5B0SvcHfIRq22p5L/s9FmYvpN5WT3JQMg8d+xDnDDsHL5NXb4cnRL8jyZUQQhzA7nTz76/zeO7rPML8LPz7skmcM+4QFp27HLDyYdjwIigDnPQHOP52MPfNTYkz6jJ4J/Mdlhcux+F2cGLMiVwx6gqOGXqM3PknxFGQ5EoIIfaxrWwn9yzeRlbVLuZMiOLP540m2Nfyy0/M/xqW3wV1eTDmIk8h0OD4bo01JCTkiJ6XXZ/NgowFfFzwMVajlQtTLuTyUZeTGJjYxREKMThJciWEEHhGq57/Jp9nvswh3N/KS1dOYWbqIdSRqsmGrx6FzI8gOBEufRtGntP9AQPh4eGH1X595XpeTXuV7yq/w9vkzRWpV3D92OsJ9uof1eCF6C8kuRJCDHpbSndy7/ue0arZE6J46FBGq+yt8O0/YM3TninAE++BE+4Ec8+tUXK73QAYDlJ81K3dfF78OUtzl7KuYh3h3uHcOulW5g2fR6C17y6uF6I/k+RKCDFo2RwunlieyZsbSgj3s/LCFZM4a8wvrK3SGnJWwJd/hposGDsPTn2w26cAO5Obmwt0XufK5XaxNG8pi7IXkVmfSbh3OLdPvp0rRl2BxXgI05xCiCMmyZUQYlD6oaieu97bSlFdK/OPiee201MI9fuFOwErt8LXT0DOpxAUB1e8D8mn90zAh6jJ3sTK4pW8mv4qRU1FDAscxqPHPcp5SedhUIe3vY4Q4shIciWEGFRa7U6e+SKHl9cUEhPszevXTOXkEREHf1JzDax5Btb/Byx+cPrDcOzvwHgIRUR7SNmuMl7PeJ0luUtwuB2MDBnJP076BzPjZ8qdf0L0MEmuhBCDxqbiBu5fmkZW1S7mTY7hz+ePxs96kK9BrSFjKXxyB7Q1wKSrPHcB+ob1XNAHobWmoLGAl1a9xJfFX6JQXJByAbMSZzEpYhJGg7G3QxRiUJLkSggx4Lndmv98k8czX+YS7mflv/Mnc+boIQd/UnUmfHYvFHwDQyfAVctgyNgeifeXtDpaWZyzmE+//5Q6Wx0tQS1cOvJSrkq9iqF+fX8TaCEGOkmuhBADWn5NM3cs2srW0p2cOTqSR+eMPXiVdYfNUwj0+5c8W9Wc/jAce3Of2AuwoLGA/2X8jxVFK2h2NDPRfyLXjLuG2eNm42P26e3whBAdev/bQgghuoHD5ebVNYU89VkW3mYjT1w4lkunxv78+iOtYdu7sPIv0FQGE+fDqQ+A/y+McHUzt3aTVpvGgowFfFH8Bd4mb2bGz2RO8hymRE6R9VRC9EGSXAkhBpzMyiYeWbad7wrqOC45lGcvnUjYwe4E3JHhmQIsXO2ZApz9L0g6tecC7oTL7eKLki94edvLZDdkYzaYuWzkZVw+6nLiAuIAcDqdAJhM8lUuRF8in0ghxIDhdmsW/VDKw8u2oxQ8fsFYfjXtIKNVDhus/iusfRbMvjDrbzD5ajD1Xh0om9PGR/kf8WbmmxQ2FpIQkMDDMx7m1NhTCfIK2q9tfn4+0HmdKyFE75HkSggxIGRX7eKPS9PYVNzAjKRQ/u+SCUQE/Ey1dLcb0t7zFALdVQnjLoUzHwff0J4Neh+1bbUsyFjA8sLlVLdWkxKcwl9P/CtnxJ8hd/0J0c9IciWE6Ndcbs2CdUU8vjwTX6uJJy8cy7wpsRgNPzNaVZXu2WC55DuImggXvgiJJ/Zs0PvIrs/m7ay3WZa/DKfbyXHRx/GX4/7CsUOPlfVUQvRTklwJIfqtwtoWfvvWj2RWNnFCShjPXjqRkJ/bE7ClDr79e0chUH84/zmYcBn0wqiQ0+1kTfkaluQu4evSr/EyenFhyoXMT51PfEDPb6MjhOhaklwJIfqd3XcC/uPzHKxmA89eOoHzx0d1PtKz+y7AT/8A7U2eQqAzHwbv4B6Pu9XRyoKMBSzKWURtWy3B1mB+PfbXXJl6JcFePR+PEKJ7SHIlhOhX8qqb+eOSNL4vqueElDAemzOWuNCfqfFUk+O5CzB/JYSmwJUfQtSEng0YKG0qZcH2BSzLX0ars5WTYk5ibspcjo85HrPhyLfQCQ8P78IohRBdRZIrIUS/4HZrnvs6j/98k4fTpXlk9mgunx7f+doqewus/husew7M3p7F6tNvAkPPblycVpPGaxmvsbJkJQZl4KyEs7h4xMVMjJjYJdcPCQnpkusIIbqWJFdCiD6vYmcbd723lXX5dcwaM4QHzk0lOsj7pw3dbtj+AXx6D7TUwLhLPIVAg+J6LFaHy8H3Vd/zSvorbKzaiL/Zn2tGX8Nloy4jwucXNog+THa7HQCLpfdKRwjRH2i3G+10Yuihz4okV0KIPktrzVsbSnjqsyzanW4eOi+Vq2YkdL62qr4QPr4dCr6G8FFw4UuQdEqPxdpga+DTwk95K/MtSnaVEOIVwt1T7mbu8Ln4mn275TULCwsBqXMlxG5aa+wFBdiLS3BWV9P64yYc5RXYMjMJu+k3hF1/fY/EIcmVEKJPamixc++SbazI2MHk+GAemT2a0VGBP21oa4RvnoKNL4EywNl/hynX9thdgJXNlbya/iqLcxbj1E6Sg5L5+0l/56SYk/Ay/UydLSHEUdNa46qroz0nh9YtW3BWVtK68QfsRUV72pjCwzHHxBB04YV4jxvfY7FJciWE6HNWZFTxpw/TqW+xc9cZw7nhxCQspgPWS7ldkP4+fPmQpxDohMvglPshIKpHYsyqz+KFrS+wqnQVALMSZ3H5qMtJDU2V+lRCdDHtdmMvKKBt6zZa1q3DXliIvbQU965de9oYw8PwSkkh+Mr5eI8ejTEkBHNMTK98HiW5EkL0GTtb7dz/QTqfbKtk1NAAXr5yKmNjOhmtqkqDT+6E0g0wZCxc9BrETe/2+NzazZryNbyx/Q3WV67H3+LPr0b9ivmj5jPUb2i3v74Qg4GrqQl7URG2rCzsBYW0bduGLSsL3doKdCRRo0YRMH4c1sRELImJeE+chNGve6bfj4QkV0KIPuHrrGruW5JGfYudO2YO56aTkzAbDxitatsJX/0FfngNvIPg/H/B+MvA2L1fZa2OVj7K/4i3Mt+iqKmICJ8Ibp10K/OGzyPQ2knyJ4Q4JFprHOXltG3dSuv69bRtS6M9O3vPeWU2Y01JIWjObLzGjMV77BgsSUmoHr7z93BJciWE6FX1LXYeWZbBB1sqGBHpzwvzJzMhdv8NitEafngFvn7ck2BNvgpO+1O3FwKtaqni7ay3WZyzmF32XYwJHcNTJzzFzISZR1WfqqtERkb2dghCHDJXUxO2jAxs2zNpL8jHtj0TR2kp7uZmAAyBgXiNGEH4rbdgHT4c64gRmCMjUebe/6wdLkmuhBC95rP0Su5fmk6TzcHvT03md6ck42U+YCF60Vr44kEo3wSRY+GyRRAzpVvjKmws5Pmtz/N50edoNKfHnc781PmMDx/fp9ZTBQUF/XIjIXqY1hpHcTH2khLa0tNpXfcdtpwc3E1Ne9oYw8KwpiTjM2kSlvg4vCdOxCs1FWUcGJuUS3I1CCilrgZe6+TUTVrrFzraKOA+4CYgDNgI3KK13tJTcYrBo7a5ncc+yWTp5nISw3x56/rpjBwSsH+jllr4+jH44VXwi/RMAU64otsKgWqtWV+5npfTXub7qu+xGCxcMeoKLht1GVF+PbNI/nDZbDYAvLzkrkTRO7TbjbO2lrYfN3sWmpeU0J6VhWvnzj1tvFJTCTjzDCzx8VhHjMBr9GhMA7wAriRXg8upQNs+fy/Y58/3Ag8CdwNZwB3Al0qpMVrrqp4LUQxkWmuWbi7nkY+302xzcsupyfzu1GSsJuO+jTx3AX7xJ89dgFN/Dac+6Flj1Q3c2s1XJV/xctrLZNRlEOEdwW2TbuPcYecS6du3p92Ki4sBqXMlup/WGtfOnbRnZdGWlk7b1q04SktpLygApxMAg58f1qQk/E47Fe9x47EmJ2FNTsYYOPjWJUpyNbhs1Fo3H3hQKeWFJ7l6Qmv9XMex74Ai4GbggZ4MUgxMJXWt3P9BGt/m1jIxLoi/XTSO5Aj//RvVF8KK+yH7E4gYDfMWQOzUbonH5rTxVclXvLjtRfIb84nzj+NPx/6J2UmzsRil4rkYvNw2G666OtoyMrAXFdP6w0ZsW7fhamzc08YybBjmmGj8TjoR05AhWJOS8Zk8qV+uj+oOklwJgBlAALBo9wGtdYtSahkwC0muxFFwuty8sqaQZ1fmYlCq8z0BbY2evQDXvwBGi2fLmuPv6JZCoLvsu3g/530WbF9AbVstMX4xPHHCE5yVcBYmg3wlisFDa42zugZ7URH2oiLac3JoWbsWe3GxZwS5gyU+Hv8zZmJJHIbXqJFYhiVhjuzarZwGGvkmGVzylVKhQD7wtNb6vx3HRwIuIPeA9pnAJT0YnxhgMioa+cP720gvb+LkEeE8fsFYovbdE1Br2LYIVvwRWuv2FgINjO7yWCqaK3gr8y3ez32fFkcL04ZM47HjHmPKkCkyUiUGPK017Tm52LZvx5aRQVvaNtozs9Ad+1MCKG9vfCZOJOCcczBFRmBNScGakoLRz68XI++fJLkaHCrxrKf6HjACvwJeUEr5aK2fAYKBZq2164DnNQA+SimL1tqOEIeosc3BM1/ksOC7IoJ9LDx98XgunBSzf6PyTfDlw1C4CqKnwBWLIWpil8ahtWZz9WZe3PYiayvWYlRGzkw4k6tGX0VqaGqXvpYQfYGruQVHSTH24mJaNmygPScX544dOOvr0W2eJbfKxwevkSMJvvxyzNHRWBISsA5LxBQRgTJJWtAVpBcHAa31CmDFPoc+VUpZgQeUUs/ubtbJU9VBzqGUugG4ASAuLq6xXO96AAAgAElEQVSLohX93feF9dz89o9U72rn8ulx3HPmSAJ99lmH0VoP3zwB37/oqVN19t9hynVdehegw+Xgs6LPeDPzTbbXbSfAEsD1Y69n3vB5A6qS+tChA+e9iMOjHQ5sWVmemlG5ubh3NWEvLqEtLQ1cnt/JBl9fvEaNwnviREyhIViHj8B7/Dgsw4b1+SKc/Z0kV4PXYuBiIAHPCJW/Usp4wOhVENCqtXZ0dgGt9YvAiwBTpkzpNAETg8eOJhtPfprFh1vKGRLgxYe/O47x+xYDtbfA+udh3b+gvcmzufLpD4NXwM9f9DDVtdWxKGcRi7IXUdtWy7DAYTx4zIOcO+xcfMw+XfY6fUVAQNf1neh73K2ttHz3HY7ycpz19bTn5XkSqcYmXM3Ne+/S8/HBGByMKTyc0Ot/jdeoVMwx0XilpKAsMuXdGyS5EhpP6QUjkAxk73NuZMc5IX6W1pr3fijj0U+2Y3e5uXpGInecMRw/q2l3A9jyNnz7D6jPh5QzPdXVh4zpshiy6rN4c/ubLC9cjsPt4Pjo45k/aj7HRh3bp4p+drXWjr3WfHwGXuI4mLjtdhxl5Z5SBznZtKWnY88vwJaRsXdNlNHoSZhGpWIKCcbg54/XqJF4jR7t2ZxYRqL6FEmuBq+5QC1QjGdNVhMwD3gUQCnlA5xHx8iUEJ3JrtrFU59l8VVWNWOjA3nmkvH7l1coWQ/L7/JstBw5Bi57D4af0SWv7XK7+Kb0G97MfJMfdvyAt8mbC1Mu5PJRl5MYmNglr9HXlZaWAlLnqr/QDgeOHTtw1dbSvG4d7dk5OKuqsG3fjnbsnSAwBgVhTU4m+LLL8Dv5JLxGjsTg7z9gqpcPBpJcDQJKqffxLGbfhmeE6pKOxy1aazdgU0o9CTyolGpgbxFRA/Cv3ola9GU2h4t/rszl1bWFaA33nz2Ka49P3FteoakCPn/AUwzULxJm/9uzwXIX/LreZd/FktwlvJP1DuXN5UT5RnHn5Du5IOUC2URZ9LrdxTZddXU4a2poLyzEWVlFe2EBLWvWojuq6qMUloQETGFhBF9+OV6jRmIMCcESG4s5Pn5Aj7gOBpJcDQ7ZwLVALJ5F6tuBK7XWb+zT5kk8ydR9QCjwAzBTa72jh2MVfdzqnBr+uDSNsoY2ZqZG8ticMUQEdGy/4myHNf8Ha54Bt9NTq+qEO8F69LdyFzcV81bmW3yQ9wFtzjYmRUziril3cXLsyVKfSvQ4d1sb7dnZ2EvLcNXXYcvOwV5cjD0vb79imwCYTFiiowk49xx8Jk7EGBSE97hxmMLDeyd40e3kG2kQ0Fr/EfjjL7TRwGMdDyF+YveC9aWby0kK9+Xt66czIynMc9Lt8tSrWvUkNBTByHPhzMcgOOGoXlNrzXeV3/FW5lusLluN2WBmVuIsLh91uZRSED3C3dJCW0YGzuoa2vPzsKWl46iqxF5cAvtO5YWEYImLw/+MM7AmJ2EMC8MUFo4lPs5T4kDWRA0qklwJIQ5Ka827G0t5eNl2nG43N5+SzM2nJuNl7lj/UbQGlt8D1RkwdDxcvhhSZh7VazbZm1hesJx3s98lb2ceIV4h3DT+Ji4ecTFh3mFd8K6E2EtrjW5txdXUhL2oiLa0dM8eeunpOMrKwO3e09Y6YgTWxET8TzkF7wkTsCQkYAwJwRgUJFN5Yg9JroQQPyurqokHlqbzQ3ED0xJCeOyCMaREdixYr831bK6cvRz8o+CiVyH1gqNaV1XdWs2b299kUc4iWhwtjAoZxaPHPcqsxFlSRb0T0dFdX8l+oNJOJ47KShwVlbibd+Gsr8dRUuqpVr5tG+7m/bddNUdF4TU6lcBzz8V74gRMkZFYYmMxeHv/zCsIsZckV0KIn2i1O3l2ZS7/XVVAoLeZp+aOZd7kWAwG5SkCuuYZ+O45MFo9ZRWm3XhU66o2Vm3k/dz3+bzoc1zaxZnxZ3LVmKtIDUmV0YCD8JNtSfajtcZVW4stKxt7aQmO0jLshYXYtm/HWVOz3355AJhMWJOSCDjnHCyxMRj8/LHEx2FNScEUJiOk4shJciWE2ENrzSdplTz2SSaVjTbmTIjirjNHEBPs4ykC+t1/4Pv/QkstjJkLMx85qn0Avy37lgUZC9hQtQFvkzfnJ53PdWOuIzYgtgvf1cDV3DHaMtiSLHdrK/bSMmxp23DW1OCorKItPQ17UTG6o/YXgLJascTF4jN9Opa4OEyREVji4jD4+mEKCfashTKbD/JKQhwZSa6EEAAU1bbwyMfb+SqrmsQwX9694RimDwsFhw02vwmrnoKdJTDsZDjtzxA96Yhep83ZxmeFn7EweyHb67YT7h3O7yf+nitTr8TL5NWl72mgKy8vBwZunStnfT227ZnYi4poz/Hcjdeel4errm6/dsbgYKwpKQTPuwhzTCzW5CQsw4Z5kicZ+RS9QJIrIQY5m8PFK2sK+efKXIwGxX2zRnLVjATPgvXcLzxFQBuKIDQZrl4OCccd0esUNxXzbva7fJD3Abvsu0gOSubeafcyN2WuJFWDmLu9nfacHNrz83FUVODcUY2rvo62tHScVVV72hkCA7EmJOB34olYEhIwRw3Fa/QYzDHRGGSLF9HHSHIlxCD2dVY1D3yQTvlOT82qR+eMITLAC8p/hK8fh7wvIGw4XPo2DJ912IvVnW4nq8tW8272u6yrWIdJmTg9/nQuGXEJkyMny6jCIOG22XDu2IG9qAh7eTntOTk4yiuwFxTgqKras9EwsOfOO59JE/EaMxav1FFYkzylDeTfi+gvJLkSYhCqbGzr2GS5gqhAL16/Zionj4iApkpY+jBsfQesgZ6NladdDxbfw7p+eXM5S3KX8FH+R1S1VBHpE8nNE25m7vC5UkphAHPsqMaen4e9vBxXXT3OmhqaV63ylDPYh8HPD0tCAt7jxxFw/nlYk5PxSk3FPHQoBi8ZxRT9nyRXQgwiDpeb19YW8swXubjcmltPS+G3pyRhdTbDV4/C+ufB5YAZt8CJd4HXoW8n43K7WFO+hkU5i/i27Fs0muOijuPeqfdyUuxJUkV9AHHt3Im9uBhbdjb2wiKcNTW0bduGo6Rkv3bK2xufqVMIuugiTBERWOLjMMfGYgoNlX3yxIAm33ZCDBLr8mp54tMs0sobOX1UBH8+bzSxfho2/NtTWqGtHkadD6c/BKFJh3zd2rZaluYuZXHOYipaKgjzDuOGcTdwYcqFRPlFddv7ERAb2z13VboaGz3lDIqLsBcV42pqxLmjGmd1Nc6qqv22d1FWK6awMKwjRhB8ycV4jR2LeehQTJGRshZKDFqSXAkxwFXvsvHk8iyWbC4nOsibZy+dwOxxQ2DrQvj6MWgqh7hj4YxHIWbKIV3T6XbyTek3LM5ZzIbKDTi1k+lDpnPnlDs5Je4UzAa5vb0n+Pj4HPFzXTt30paRgau2FntxCc6Getpzcz3JVG3tnnbKasUYEIApPBzz0KH4TJ6EKSIC6/ARWOLjsCQmytYuQhxAkishBiibw8VLqwt4cXUB7U43N540jNtPH45XyWp48RKoSoMh4+C8ZyH5dDiExcIVzRV8mPchH+V/RFlzGdF+0cxPnc8FKReQGJjYA+9K7KupqQmAgICATs+729qwFxZiLyvDVVeHvbgEW0YGjuodOEpK9xbVNBgwBgZijonB/5STPdXJx47DkhCPeehQmcIT4jBJciXEAON2a5ZuLuevK7LY0dTOqSMjeOCcUQxzFcE7c6HgawiM82xXM/rCX0yqtNak16azMHshH+V/hEIxdchUfj/x98xMmCmjVL2oorwc965dJFosuJqaaM/NxZadjaOsHGdt7U/2xVMWC9ZRI/EalUrg+efjM3kypogIzDExMoUnRBeS5EqIAWRb2U4e+CCdbWWNjBoawP9dMpFj/ath1S2QsRQs/nDmEzD1OjBZD3qtA4t9+ph8+NXIXzE/dT6x/lJBvadppxNbRgYt6zfgrKvFWVlFZVER7pYWVEXFnnamIUOwxMbiPWY0geeegyVxGNbkJIwhoZhCQ1Am+doXorvJp0yIAaCsoZV/f53Hwo2lhPlZeXTOGC6KacLruzs7kio/mPF7OP528A4+6LWKGotYlLNov2Kf90+/n3OHnYufZXBts9LTtN1Oe0EB7dnZ2IuLcdbV46iooD0rC2dDAzidgKeUgSk0FK/Jk7AkJBCTkoIxMAhLfBym0NBefhdCCEmuhOjHmmwOnv8mn5dWFwAw/5h47pnowm/DQ7DiAzD7wnG3wXG3gk/Iz16n3dXOyuKVLMlbwobKDVLssxtprdHt7TjKymhZ9x3tubmeNVBl5diLivYW1FQKY7Bn/zvf44/33JE3cgS+06ZhCg8HwJmdDYD/AN3+Roj+SpIrIfohl1vz/o9lPPVpFnUtduZMiOKe6d5EbfobvLbEk1TN+D3MuBV8f34ko2BnAYtzF/NR/kc0tjcS7RctxT67gLOhgfbMTBxVO/aUMXCUlWIvKcVeVIRub9/T1hgYiCkqCkt8PP4zT8eamIjXmDFY4uNlCk+Ifko+uUL0M9srmrhj0RayqnYxJjqAN+YEk5r/MvzvHTCaPQVADzJS5XA7WF22miW5S1hdthqTMnFq3KnMHT6XY4Yeg0HJbfWHQrvduHbuxFFaSnteHm3b0rDn52MvL8dZWblfW2W1Yo6JwRwdhe+xx3pGpMLC8Jk8CXN8/BGPDMbHx3fFWxFCdDFJroToJ4pqW/j313ks/rGMYB8Lr54fyikVL6Hef9+zOH3a9Z6kKqDzwp2N7Y28lv4aH+Z/SG1bLRHeEVw35jquSL1CRql+htYaV0MDtowMnNXVOHbswLZ1G46KChxVVbh37drT1uDnh3X4cHynTcOSmIj3hPGYo6MxBgRg8PfvllpQXrJVjBB9kiRXQvRxrXYnz3+Tz8vfFuLSmtsmmfiNYSnWz9/2JFXH3wbH/A78wn/yXKfbydrytSzJXcLairU43A5OiD6BuSlzOSHmBNmSpoO7rQ17aSn2vDzsZeU4ysux5+fTlp6Ottn2a2tJSMCSlIT3lMlYE4dhGjoErxEjMEdH93g9qJ07dwIQFBTUo68rhDg4+WYVoo/ava7qnytzKWto47JRZu4PXIFv2hugXTDtBjjhDvAf8pPnFjYWsiR3CR8XfExtWy0hXiHMSZ7D3JS5jAod1Qvvpm9wt7Rgy86hPT8PR3k5trR02vPycO7YsV87g78/1mHDCDjzTKwjR+I1aiTmmBiMQcEY/Q5vE+vutKMjbkmuhOhbJLkSoo9xutx8uKWCf3+TR0FNC6eFN7Fk7FdEFH0CRTYY/ys46W4ITtjveY3tjXxe/Dkf53/Mj9U/YlImTow5kfOTz+fEmBMHTbFPZ0MDtvQM2rOzcDU20Z6fjy0rE3fTLtwtLftVJbcmJ+MzbRrW5GTMUVFYk5OwxMdjOIptZYQQQpIrIfqQ7/LreHhZBllVu5gdWc2bSZ8ytPxzVJsVRp4Dp9y/36bKDreDteVrWZq7lNVlq3FqJ/EB8dw26TZmJ88esGup3DabZyuXzO20Z+fgqKrEnpePo7wcd2vr3oYmE+ahQ/EeNx5TRDjGoCC8hg/HOnIU5iGRcjeeEKJbyDeLEH1Aenkj/1yZy+fbd3CqfykvpawhtnQZ2AI8hT+PuQn8Iva0z2vIY1nBMj7O/5jqtmpCvEK4IvUKTo8/nfHh43vxnXQdZ00N9tJSHKWl2IuLsWXn4KyqwlFZiau+fk87ZbViiozEmpSEz/TpnhGo4cPxnjAeg6+v1OgSQvQ4Sa6E6EWbSxp46dsClqdVMd1azOohS4nb+T3s8IcJV8BZj4NXIAC1bbUsL1jOsoJlZNVnYVRGZkTN4P7h93NCzAn9ctpPa427pQVnVRWtmzd7CmqWlGLLysJZVbW3ocGAJSEBc0w0XqmjMEdHY46JxZqSgjU5STYWFkL0KZJcCdHDnC43n2VU8cqaQjaXNHC6VxarI5YT17QJbIFw/B1w3C3gHUxtWy3f5i5leeFyNlRuQKMZEzqGu6fczTnDziHUu39sdeJubcVRVUV7djbtubnYi0s6RqOyweHY087g44MpMhKfyZPxGjMGa9IwzDGxWGKiUbKx8E8kJib2dghCiE5IciVED2lsc/DuxhIWrCumZWc11wes55WwNYQ054J7CJzxKEycT6NB8VXJV3xc8DEbqzai0cT4xXDj+Bs5K+EskoKSfvnFeoGzpoa2jAzs+QW05+VhLynBVVuLs64Od3Pz3oYGA+aoKMxDhxJy5XxMIaGYIsLxGjUKS1KSTOMdBosknEL0SZJcCdHNimpbeG1tIUs3FTHOmc5fA9dxrM86DHYH+CfDSU9jH3cxa3f8wKcbH+fL4i9xuB1E+0Vz/bjrOT3udEaGjOzVpENrjbu5GWd1taeYZkUF9sJCHBWVtBcU4Cgr2y+BMoaHYY1PwDpyJL6REZhCwzBFRmBNScErJUVGobpIfcfas5CQn983UgjR8yS5EqIb2BwuNhTW88a6IqpyNjDXuIbV1h8IMtSADoKp19E+7hI26GZWla7ii6Xn0NDegLfJmznJc5iTPIexYWN7NKFyt7fv2crFuWMH9pJSnNU7cO1qpj0/D1dN7f5PMJsxRw3FEh2Nz7SpmCOH4D1xAuahQzEPHdpjcQ9mNTU1gCRXQvQ1klwJ0UW01mwra2TJj2Vs2baF6bY13GreyFhLHtpoQSWcSNXwmaz2C2BT7VZWr/odzY5mvE3enBB9Aucnnc+M6BndtjDd1dyMvaAAx44dOGtqcFZW0l5YiKOiAndjE47KSnC797Q3+PpijhqKwdcPvxnHYR2egikiAlNEJOaooZiHDEGZ+98ieiGE6G6SXAlxFFrtTjIrm/gio5zy9LUkNm7kKtM6HlYVYIaW8BGsGnETX5jdbK3PpCjz3wCEeIVwatypnJ14NpMiJ+Ft8j6qONx2O66aGuzFxTjr6nCUleGoqMRZW4tzxw6c9fX7330HYDZjiYnBEheHITmZgKgoLAkJeI0ciSkiAmNwsKx/EkKIIyDJldhDKZUK/As4FtgJvAw8rLV29WpgfUxZQyvr8+vIT99Aa/5aTmAztxoysCo7eT5mNg1N5YWgUeRqGwUt5bjLP8Hb5M3UIVO5IOUCTo49mcSAxMNKXNzt7TjKyrAXF+MoLcXd1oazugZ7USHtBYU/TZyUwhgaiik0FFNEBNaUZCxJyViHJWIaOhTz7uRJimgKIUSXk29WAYBSKhj4EtgOzAaSgH8ABuCBXgytV7ndmuL6Vr7PraQiZxOOyjSSWjYzzZDFOEsjeQFmtvoEsyR4DFvczexy2YAG/NudTIqYxCmJZzE5cjLThkzDbOx8Ck27XDirqnDWN+BqqMdZXY0tK9uzaLy4GEd5+U82D4aOabvoaHynT8ccH4cpNAxLQgKm8HDMkREYfPvOHnhCCDGYSHIldvsN4A1cqLVuAr5QSgUADyml/tpxbMBrbneSXlBGefYmbCUbcTf+iI+lEKOpBS+jkVo/E2+GevOE2Zd25dl/zqiMxHr7cUbkSYwLH8fEiInEB8SDrR1XQwP24mKaVy/G2dCAq7YOt83mqftUWuq5+66ubr+1TuCp92SOjsI6LBG/44/DGByCaUgk1sREzHFxGP38ZL2TICmpb5blEGKwk+RK7DYLWHFAErUQeAo4CVjWK1F1Me1209pYS011JcXluRRXbaOppRpHWzk2ZxU2UyMNJhdVJhNlfkYMRgNeditml5WgRk0IvpzgF0+kMYT4XVZC3T4EOEzo5hacVdm4mjbistvJa23db4uW3QwBARh8fDB4eWGOjsY6aiTmiAhMQ4ZgCgvDGBSMKSwUc3S0VB0Xv8gk07pC9EnyyRS7jQS+2veA1rpEKdXaca7HkquP/3039sZ6tNbgdoHWaLcbrd2gNbjdnnMdf9faDW4NWuO2teJ22tFOJ26XHeV2opwutMuNW7twa40LhVODwaUIaIEop8biBKsDzC4jFrcZi1vhZXNjdB643GwXkL7nb8rbmxZfX4z+/pjCwrAOH47BakFZrJijozGGBGOJi8OSmIgpJERGm0SXqqurAyA0tH9U6hdisJDkSuwWjGcR+4EaOs79hFLqBuAGgLi4uC4LxOedj0mq/eV2h8plAIcRtAG0wYA2GMBgALMJQ0gQ5kA/jD7+ePkFYvHyxWAyo8xmjAH+mIYMxejvmYIzBgdj6JiOUxYL5uhoDFZr1wUqxGGqrfV8UCS5EqJvkeRK7Et3ckz9zHG01i8CLwJMmTKl0zZHwvveu6hqbkQZzRiUQhmNGI0mlMGAMppQSmEwmFFGhdFgBoMBo8kEykBQWDQhwUPw8vXHaDKDyfM8IYQQoqdIciV2awCCOjkeSOcjWt3m2HOv68mXE0IIIbqU/KQXu2XhWVu1h1IqFvDtOCeEEEKIQyDJldjtU+BMpZT/PscuAdqAVb0TkhBCCNH/yLSg2O0F4BZgiVLqKWAY8BDw9GCpcSVEf5OSktLbIQghOiHJlQBAa92glDoNeA5P2YWdwDN4EiwhRB9kkJs1hOiTJLkSe2ittwOn9nYcQohDU1NTA0B4eHgvRyKE2Jf87BFCiH6qvr6e+k52AhBC9C5JroQQQgghupAkV0IIIYQQXUiSKyGEEEKILiTJlRBCCCFEF1Jad9mWcGIQU0rVAMVdeMkwoAu3b+73pD/2kr7Yn/TH/qQ/9pK+2F9X90e81rrTW3UluRJ9klLqB631lN6Oo6+Q/thL+mJ/0h/7k/7YS/pifz3ZHzItKIQQQgjRhSS5EkIIIYToQpJcib7qxd4OoI+R/thL+mJ/0h/7k/7YS/pifz3WH7LmSgghhBCiC8nIlRBCCCFEF5LkSvQZSqlUpdRKpVSrUqpCKfWIUsrY23EdDaVUslLqv0qprUopl1Lqm07aKKXUH5VSpUqpNqXUaqXUhE7a/WL/HOq1eoNSap5S6iOlVLlSqlkptUkp9asD2gyKvgBQSl2klFqnlKpTStmUUtlKqQeUUpZ92gya/tiXUiq649+IVkr57XN8UPSHUurqjvd+4OM3+7QZFH2xm1LKpJS6VymVq5RqV0qVKaWeOaBN3+kTrbU85NHrDyAYqAC+BGYCvwFagEd7O7ajfF+zgVLgPSAT+KaTNvcBbcDNwOnAcjy1WIYcbv8cyrV6sS++A94GLgZOBf4OaOD3g60vOuK7EXgMuAA4BfhDR7zPDcb+OCDWt4Gqjn8ffoOtP4CrO977KcAx+zwiBltf7BPjGx3v5UbgJOAK4PHDfR891Se93mHykIfWe/4hNwAB+xy7B2jd91h/ewCGff68mAOSK8ALaAT+tM8xX6Bm3w/7ofTPoV6rF/sirJNjbwOFg60vDtJHjwE7ATVY+wM4AagH7mKf5Gow9Qd7kyu/nzk/aPqiI56zAAeQepA2fapPZFpQ9BWzgBVa66Z9ji0EvPH8SumXtNbuX2gyAwgAFu3znBZgGZ4+2e1Q+udQr9UrtNadVUbeDER0/HnQ9MVB1AG7pwUHXX90TM38C3iEn1bSHnT9cRCDrS+uBb7SWm8/SJs+1SeSXIm+YiSQte8BrXUJnl8TI3slop4xEnABuQccz2T/930o/XOo1+pLZgC7vzAHZV8opYxKKR+l1PHALcDz2vNTeTD2x2/wjBr8u5Nzg7E/8pVSzo71eDfuc3yw9cV0IEcp9ZxSqqljrdQSpVTUPm36VJ9IciX6imA80yEHaug4N1AFA81aa9cBxxsAn30WNx9K/xzqtfoEpdRpeNak7f6PdLD2RUvH41tgFXB3x/FB1R9KqVDgL8AdWmtHJ00GU39UAg8C84HzgA3AC0qp2zvOD6a+ABiCZ6p0AnApcA0wGViqlFIdbfpUn5h+qYEQPaizomvqZ44PJD/3vg88dyj9c6jX6lVKqQQ8660+1Fq/vs+pQdcXeEbvfIBpwJ+A54DfdpwbTP3xGLBBa738IG0GRX9orVcAK/Y59KlSygo8oJR6dnezTp464Pqig+p4zNZa1wEopSrx/Bg5FVjZ0a7P9IkkV6KvaACCOjkeSOe/MgaKBsBfKWU84FdSENC6zy/4Q+mfQ71Wr1JKhQCfAiV47vjZbdD1BYDW/9/evcZKVZ1hHP8/AhFPFdQqrTEatKCNVGNNNFCM8dKqSI0x3pI2LWoEY7R+MNEUNcFLvd+aUI1Xgn4wxuAtHiMRRZrSHttY1EQRDCh4CfF4weKFFpG3H9baYRjmcOYcN2eG2c8vWZmZPWuvs/b7Yc47e10mluSniyV9Cjws6Q4qFA9JE0jzao6RVFxLV34cLek7KhSPPswjrbQdS/VisRZ4t0isssXABuAQUnLVVjHxsKC1i2XUjWVL2o+0QmNZwzM6wzJgGDCu7nj9vIBm4tNsWy0jqQvoJk3anponiRYqFYs+FInWAVQrHuOBEaTtOtbmUgwXf0ia5F6leGxLUL1YvN3HcQHFoqG2iomTK2sXzwMnSdqt5tg5pH1G/tqaLg2JfwDrgLOKAzkBOZUUk0Iz8Wm2rZaQNJy039d4YEpE9NZVqUwstmFyfnyPasVjMWlPp9pyS37vFOA2qhWPRs4graBcTfVi0Q0cJmmvmmPHkBLyN/Lr9orJUO9X4eLSqJAmEK4BFpA2bJsBfEWb7LPyPa6rCzgzlx7grZrXXbnOTNJKlYuBE4DnSB+iPxpofJppq4WxuJ/0rftSttwYcSKwc5Vikfs3n7SX0xTgRODafB2PDeQaOiUeDeJzLo03Ee34eABPkDaVnQL8mrSBZrD1hrsdH4vcv1GkaQQ9pATnN6TNmRcM9DqGKiYtD5qLS1FIY+cLSd8g1pBWDg1rdb++5zWNzR+KjcrYXEfAVaThj/WkVWM/H0x8mm2rRbFY5Vhs0b/rgTfzB/sXpCHBPwAjBnoNnRCPBtd0LlsnV5WIB3AjsJz0z3098G/gdzs+5xsAAAQVSURBVIPp/44ei5o+jiPtkv41adh4LrBHu8ZEuREzMzMzK4HnXJmZmZmVyMmVmZmZWYmcXJmZmZmVyMmVmZmZWYmcXJmZmZmVyMmVmZmZWYmcXJmZ9UNSNFGOlbRK0u2t7m9B0hWSjm11P8yqxvtcmZn1Q9LEmpe7kDYg/BNp1+bCUuAnwGcR8f4Qdq9P+Yeg/xIR17S6L2ZVMrzVHTAza3cR8UrxXNKu+enK2uPZa0PXKzNrVx4WNDMrSf2woKS5kl6VNFXSUknfSHpO0p6Sxkl6WdLXuc5hdW3tJOmPklZI+p+kdyRNq6tztKS/SVqXy+uSzir6AvwQmFU7dDmAthdJmidpRr6u9bnv+9bVm5nb+a+kjyXNl/TjMuNqtqPxnSszs+1rf+A64GrSD3nPJv2I9VjgAeBW4CbgMUkTYvNcjdnAtHzuEuBXwBxJn0VEt6RRQDfwTK4j4FBg93z+6cDLwDzgwXxsaTNt1/R9EnAwcBkwErgFeBo4EkDS74ErST8y/BYpmTse+MGgo2XWAZxcmZltX3sCkyJiJUC+Q3U5MC0iHsnHRJq/9VPgbUnjgIuA8yLi4dzOi5L2AWaRkqqDgNHAJRHxZa7zQvFHI+I1SRuBD+uGNZtpuzAG+EVErM7nrgYWSzo5IuYDRwEvRMQ9Nec8OehImXUIDwuamW1fq4rEKluRHxc2OFYMuZ0AbAKekjS8KMBLwOGShgErga+ARyWdJml3mtNM24UlRWIFEBF/B3pJSRXA68Apkq6VdFTduWaV5eTKzGz7+qLu9YYGx4tjI/PjXsAw4D/AtzVlLmnEYZ+IWAucCIwAHgc+yXOiDuynP/22XVO3t8H5vTV15pCGBc8G/gl8LOl6J1lWdR4WNDNrP58DG4HJpLtM9XoBIqIHOFnSLsAvgTuBR4GJDc4ZUNvZmAbvjwHW5L+/CbgLuEvSfsBvgRuAj4B7t9EHs47m5MrMrP0sJN1dGh0RC/qrHBHrgWcl/QyYWfPWBjbfDRtM20dI2r/Yt0vSZFJy9a8GffgAuFnSecAh/fXZrJM5uTIzazMRsVzSvaQVhLcCr5KSpAnAQRFxgaSpwPmk1Xvvk+ZrXciWc7mWAVMlzSfNz1reTNs15/cC3ZKuYfNqwSV5MjuS7iPdCXuFNMx4HDCetHrQrLKcXJmZtaeLgXeA6aQtE9aRtlJ4KL+/AgjgRtLdpE9IK/2urGnjcuBu0krELlLys6iJtgs9wIvAn4G987kz6t6fTkrqRuY+TY+Ipwd/2WY7Pv/8jZmZbUXSIuDTiDiz1X0x29F4taCZmZlZiZxcmZmZmZXIw4JmZmZmJfKdKzMzM7MSObkyMzMzK5GTKzMzM7MSObkyMzMzK5GTKzMzM7MSObkyMzMzK9H/Ab+aM2A0eTYpAAAAAElFTkSuQmCC\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",
" for i in range(self.num_actions):\n",
" self.model[past_state][i]=(past_state,0)\n",
" self.model[past_state][past_action] = (state, reward)\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",
" counter = 0\n",
" while counter < 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",
" state, reward = self.model[past_state][past_action]\n",
" reward += self.kappa*(self.tau[past_state][past_action])**0.5\n",
" if state != -1: \n",
" self.q_values[past_state][past_action] += self.step_size*(reward + self.gamma*np.max(self.q_values[state]) - self.q_values[past_state][past_action])\n",
" else:\n",
" self.q_values[past_state][past_action] += self.step_size*(reward - self.q_values[past_state][past_action])\n",
" counter += 1\n",
" # ----------------"
]
},
{
"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",
" self.past_state = state\n",
" self.past_action = self.choose_action_egreedy(state)\n",
" # ----------------\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",
" # your code here\n",
" self.tau += 1\n",
" self.tau[self.past_state, self.past_action] = 0\n",
" action = self.choose_action_egreedy(state)\n",
" self.q_values[self.past_state][self.past_action] += self.step_size*(reward + self.gamma*np.max(self.q_values[state]) - self.q_values[self.past_state][self.past_action])\n",
" self.update_model(self.past_state, self.past_action, state, reward)\n",
" self.planning_step()\n",
" self.past_state = state\n",
" self.past_action = action\n",
" \n",
" # ----------------\n",
" \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",
" # your code here\n",
" self.tau += 1\n",
" self.tau[self.past_state, self.past_action] = 0\n",
" self.q_values[self.past_state, self.past_action] += self.step_size*(reward + 0 - self.q_values[self.past_state, self.past_action])\n",
" self.update_model(self.past_state, self.past_action, -1, reward)\n",
" self.planning_step()\n",
" # ----------------"
]
},
{
"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 [03:58<00:00, 7.95s/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"
]
}
],
"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
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment