BabysFirstReinforcementLearning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Baby's First Reinforcement Learning\n",
    "----------------------------------------------------\n",
    "\n",
    "In this notebook we will begin to explore the fundamentals of reinforcement learning. From Wikipedia:\n",
    "\n",
    "**Reinforcement learning (RL)** is an area of machine learning concerned with how software agents ought to take actions in an environment so as to maximize some notion of cumulative reward. (see: https://en.wikipedia.org/wiki/Reinforcement_learning)\n",
    "\n",
    "Reinforcement learning has seen numerous successes in recent years. Groups such as OpenAI and\n",
    "Google Deepmind have successfully trained agents to play Atari games 1 with super-human skill. More recently,\n",
    "groups have trained agents to play considerably more complex games like Dota II. In each of these cases, the AI\n",
    "agent is trained by allowing it to explore the environment, and discovering on it’s own which sequences of\n",
    "actions lead to maximization of the chosen reward.\n",
    "\n",
    "We will begin by exploring an old idea known as a **Markov Decision Process** (MDP). MDP's can be applied in reinforcement learning contexts, but as we will see they have limitations. If time allows, we will also explore **Deep Reinforcement Learning** which is a collection of newer techniques designed to overcome the limitations of MDP's by using **Neural Networks**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is what our environment looks like. The Agent 'A' needs to learn to seek out the food/reward 'R'.\n",
      "----------\n",
      "|R       |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|    A   |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "from importlib import reload #allow us to reload custom modules any time we like with modifications\n",
    "from IPython.display import clear_output #so we can iteratively update the output without filling the screen\n",
    "from collections import deque #fast queue implementation\n",
    "from pprint import pprint\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import environment #custom module\n",
    "import markov_decision_process #custom module\n",
    "import progress_bar #custom module\n",
    "reload(environment)\n",
    "reload(markov_decision_process)\n",
    "reload(progress_bar)\n",
    "\n",
    "#Step 1: Set up the environment such that we can view it, modify it, determine rewards\n",
    "env = environment.Environment()\n",
    "print(\"This is what our environment looks like. The Agent 'A' needs to learn to seek out the food/reward 'R'.\")\n",
    "env.render()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "|R     A |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "#Step 2: Initialize trainable MDP\n",
    "mdp = markov_decision_process.MarkovDecisionProcess()\n",
    "mdp.set_possible_actions(env.agent.get_possible_movement_directions())\n",
    "\n",
    "#Define the observe->action step functionality we use during training\n",
    "def train_step(env, mdp, epsilon=0.5):\n",
    "    #Observe the environment (get the current state).\n",
    "    state = env.get_state_vector(as_string=True) #String is easier for our MDP class to store\n",
    "    \n",
    "    #Given the state, select an action.\n",
    "    action = mdp.get_predicted_action(state, epsilon)\n",
    "    env.agent.move(action)\n",
    "    \n",
    "    #Determine if we got a reward. \n",
    "    reward = 0\n",
    "    if env.has_agent_food_collision():\n",
    "        reward = 1\n",
    "        env.reset_food()\n",
    "        \n",
    "    return state, action, reward #This will be used by the outer training loop to encourage rewarding actions\n",
    "\n",
    "#Observe that prior to training the MDP, our agent moves around essentially randomly\n",
    "for i in range(0,10):\n",
    "    train_step(env, mdp)\n",
    "    clear_output()\n",
    "    env.render()\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [####################] 100.0%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Step 3: Run MDP training algorithm on the environment from step 1. Observe reward/time curve.\n",
    "training_steps = 100000\n",
    "initial_epsilon = 1\n",
    "epsilon = initial_epsilon \n",
    "anneal_epsilon = True #do we decrease epsilon over time?\n",
    "max_history_length = 10 #how many past actions do we want to encourage?\n",
    "history = deque([])\n",
    "progress = progress_bar.ProgressBar(total_elements=training_steps)\n",
    "reward_trends = []\n",
    "reward_trend_interval = 1000\n",
    "cumulative_reward_trend = 0\n",
    "\n",
    "#This is the main training loop.\n",
    "for i in range(0, training_steps):\n",
    "    state, action, reward = train_step(env, mdp, epsilon)\n",
    "    history.append({\"state\": state, \"action\": action})\n",
    "    while len(history) > max_history_length:\n",
    "        history.popleft()\n",
    "        \n",
    "    if reward > 0:\n",
    "        for sa in history:\n",
    "            mdp.encourage(sa[\"state\"], sa[\"action\"])\n",
    "        cumulative_reward_trend += reward\n",
    "        \n",
    "    #We just \"turn down\" epsilon by a linear interpolation from initial_epsilon to 0.\n",
    "    if anneal_epsilon:\n",
    "        epsilon_lerp = initial_epsilon / training_steps\n",
    "        epsilon = epsilon - epsilon_lerp\n",
    "        if epsilon < 0:\n",
    "            epsilon = 0 #might happen due to floating point error stacking up?\n",
    "            \n",
    "    if i % reward_trend_interval == 0:\n",
    "        reward_trends.append(cumulative_reward_trend / reward_trend_interval)\n",
    "        cumulative_reward_trend = 0\n",
    "        progress.update(i).draw()\n",
    "            \n",
    "progress.update(training_steps).draw()\n",
    "            \n",
    "plt.plot(range(len(reward_trends)), reward_trends)\n",
    "plt.ylabel(\"Reward per 1000 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 1000)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'00000001': {0: 1404, 1: 1407, 2: 19296, 3: 1261},\n",
      " '00000010': {0: 566, 1: 7822, 2: 1047, 3: 631},\n",
      " '00000100': {0: 669, 1: 10022, 2: 723, 3: 767},\n",
      " '00001000': {0: 459, 1: 846, 2: 483, 3: 7004},\n",
      " '00010000': {0: 701, 1: 662, 2: 627, 3: 9627},\n",
      " '00100000': {0: 6199, 1: 414, 2: 415, 3: 719},\n",
      " '01000000': {0: 2456, 1: 176, 2: 235, 3: 229},\n",
      " '10000000': {0: 7033, 1: 486, 2: 838, 3: 436}}\n"
     ]
    }
   ],
   "source": [
    "#What do the MDP internal state->action pairs look like?\n",
    "pprint(mdp.state_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "|        |  \n",
      "|        |  \n",
      "|      A |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|       R|  \n",
      "|        |  \n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "#Observe our agent after training for a while. Does it appear to have learned anything?\n",
    "for i in range(0,50):\n",
    "    train_step(env, mdp, epsilon=0)\n",
    "    clear_output()\n",
    "    env.render()\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Success! What's next?\n",
    "--------------------------------\n",
    "\n",
    "Huzzah! Our Markov Decision Process was trained (unless your run was exceptionially unlucky) and can navigate the environment, collecting reward with ease. Where can we go from here?\n",
    "\n",
    "The logical next step given my goals is to attempt to model the Markov Decision Process with a Neural Network. It would be great if we could just drop in a Neural Network where the MDP was an train it with exactly the same process. Will that work? I'm thinking it should (with some minor tweaks) since neural networks are effectively arbitrary function approximators. Thus, it should be able to learn a simple mapping like the MDP. Let's find out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of trainable parameters in Neural MDP:  1476\n"
     ]
    }
   ],
   "source": [
    "#If you do not already have PyTorch, you can download & install it from instructions here:\n",
    "#https://pytorch.org/get-started/locally/\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "#This class allows us to quickly and easily build a generic feedforward neural network\n",
    "#We can make it behave like the MDP by adding the same functions we gave the MDP class\n",
    "class NeuralNet(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, activation_function = torch.sigmoid, num_layers = 1):\n",
    "        super(NeuralNet, self).__init__()\n",
    "        self.activation_function = activation_function\n",
    "        self.input_size = input_size\n",
    "        self.output_size = output_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.layers = nn.ModuleList()\n",
    "        \n",
    "        if self.num_layers < 1:\n",
    "            self.num_layers = 1\n",
    "            print(\"Zero hidden layers not allowed, defaulted to one.\")\n",
    "\n",
    "        self.layers.append(nn.Linear(self.input_size, self.hidden_size))\n",
    "        for i in range(0, self.num_layers):\n",
    "            self.layers.append(nn.Linear(self.hidden_size, self.hidden_size))\n",
    "        self.layers.append(nn.Linear(self.hidden_size, self.output_size))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        for layer in self.layers:\n",
    "            x = self.activation_function(layer(x))\n",
    "        return x\n",
    "\n",
    "\n",
    "input_size = len(env.get_state_vector())\n",
    "hidden_size = input_size * 4\n",
    "output_size = len(env.agent.get_possible_movement_directions())\n",
    "neural_mdp = NeuralNet(input_size, hidden_size, output_size, num_layers = 1) #maybe we'll play with the other parameters later\n",
    "\n",
    "#how many parameters to train?\n",
    "pytorch_total_params = sum(p.numel() for p in neural_mdp.parameters() if p.requires_grad)\n",
    "print(\"Number of trainable parameters in Neural MDP: \", pytorch_total_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "#Takes an integer \"target\" in the range [0, num_classes] and returns the one-hot \n",
    "#encoding of that target as a tensor of length num_classes where the value at index\n",
    "#target is 1.0 and all other values are 0.\n",
    "def one_hot(target, num_classes):\n",
    "    one_hot = torch.zeros(num_classes, dtype=torch.float32)\n",
    "    one_hot[target] = 1.0\n",
    "    return one_hot\n",
    "\n",
    "#Define the observe->action step functionality we use during training\n",
    "def train_step_nn(env, neural_net, epsilon=0.5):\n",
    "    #Observe the environment (get the current state).\n",
    "    state = torch.tensor(env.get_state_vector(as_string=False), dtype=torch.float32)\n",
    "    \n",
    "    #Given the state, choose an action. Either from the network, or randomly according to epsilon.\n",
    "    action_predicted = neural_net(state) #We need to get an output from the network either way\n",
    "    num_possible_directions = len(env.agent.get_possible_movement_directions())\n",
    "    choice = random.random()\n",
    "    if choice < epsilon:\n",
    "        action_taken = one_hot(random.randint(0, num_possible_directions-1), num_possible_directions)\n",
    "    else:\n",
    "        action_taken = one_hot(torch.argmax(action_predicted), action_predicted.shape[0]) \n",
    "        \n",
    "    env.agent.move(torch.argmax(action_taken).item())\n",
    "    \n",
    "    #Determine if we got a reward. \n",
    "    reward = 0\n",
    "    if env.has_agent_food_collision():\n",
    "        reward = 1\n",
    "        env.reset_food()\n",
    "        \n",
    "    return state, action_predicted, action_taken, reward #This will be used by the outer training loop to encourage rewarding actions\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before training, let's take a look again at how the agent behaves. It should basically sit still or run in to a wall and stay there. This is because with **epsilon=0** we're giving full control of the agent to the Neural Network, the same network which hasn't learned anything yet! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "|        |  \n",
      "|        |  \n",
      "|A       |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|       R|  \n",
      "|        |  \n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "#How does the agent move around prior to training the new NN?\n",
    "#Clearly not the way we want it to!\n",
    "#The NN's actions are deterministic, we need to add some randomness like the MDP had for training to work!\n",
    "for i in range(0,10):\n",
    "    train_step_nn(env, neural_mdp, epsilon=0)\n",
    "    clear_output()\n",
    "    env.render()\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [####################] 100.0%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEKCAYAAAA4t9PUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xuc3HV97/HXe2Z2N8kmuzEhibBJSChBDDfFiFSo2uIFLDVoQWLVWsVDbeGIntoe6AVbK0c5erxVtKWCRbwAoj3mWJSqqIhVIFwEAkZjAAkXCZAbSXaun/PH7/vb/e1kLr/d2cnO7nyej8c+mPnN7/eb72R1Pvv5Xj5fmRnOOefcRGWmugHOOeemNw8kzjnnWuKBxDnnXEs8kDjnnGuJBxLnnHMt8UDinHOuJR5InHPOtcQDiXPOuZZ4IHHOOdeS3FQ34EA46KCDbMWKFVPdDOecm1buuOOOp8xsUbPzuiKQrFixgg0bNkx1M5xzblqR9HCa87xryznnXEs8kDjnnGuJBxLnnHMt8UDinHOuJR5InHPOtcQDiXPOuZZ4IHHOOdcSDyQtevCpPfx481NT3QznnJsyHkha9C8//BV/+dWfTXUznHNuynggadHeQpnhUmWqm+Gcc1PGA0mL8qUyxbIHEudc9/JA0qJCqUKpbFPdDOecmzIeSFpUKFcoVTwjcc51Lw8kLcoXKxTLhplnJc657uSBpEWFMD5Srnggcc51Jw8kLcoXo0BS9HES51yX8kDSojgjKfo4iXOuS3kgaVEhrCHxmVvOuW7lgaRF+VIZgJKvJXHOdSkPJC3Kl+KuLc9InHPdqa2BRNKpkjZJ2izpwhqv90m6Nrx+q6QV4fhCSd+X9KykTyfOnyPpPyT9XNJGSR9uZ/vTyI90bXlG4pzrTm0LJJKywGXAacBq4E2SVleddg6w3cwOBz4OXBqODwN/B7yvxq0/amZHAi8ETpJ0Wjvan4aZjYyReJkU51y3amdGcgKw2cy2mFkBuAZYW3XOWuCq8Ph64BRJMrM9ZnYLUUAZYWZ7zez74XEBuBNY2sbP0FByyq9P/3XOdat2BpIh4JHE863hWM1zzKwE7AQWprm5pPnAHwDfq/P6uZI2SNqwbdu2cTY9nXigHXzWlnOue7UzkKjGsepv2zTn7H9jKQd8BfiUmW2pdY6ZXW5ma8xszaJFi5o2diIKifLxvo7EOdet2hlItgLLEs+XAo/VOycEh0HgmRT3vhz4pZl9YhLaOWGFxLiIZyTOuW7VzkByO7BK0kpJvcA6YH3VOeuBt4XHZwI3WZPqh5I+SBRw3jPJ7R23uDwK+Kwt51z3yrXrxmZWknQ+cCOQBa40s42SPgBsMLP1wBXA1ZI2E2Ui6+LrJT0EDAC9ks4AXg3sAv4G+DlwpySAT5vZ59r1ORpJZiQFDyTOuS7VtkACYGY3ADdUHbs48XgYOKvOtSvq3LbWuMqUGJuReNeWc647jatrS1JG0kC7GjPdFMqJWVs+2O6c61JNA4mkL0sakNQP3A9skvSX7W9a58snZ215RuKc61JpMpLVZrYLOIOom2o58Na2tmqaSAYSz0icc90qTSDpkdRDFEi+YWZFUqz16AZj1pGU/J/EOded0gSSfwEeAvqBmyUdSjR7quvlfUGic841n7VlZp8CPpU49LCk321fk6aPZEbis7acc90qzWD7QkmfknSnpDskfZJoQWDXG9O15etInHNdKk3X1jXANuAPiVafbwOubWejposxRRt9YyvnXJdKsyBxgZn9Y+L5B8NK8643tmvLMxLnXHdKk5F8X9K6sBgxI+mNwH+0u2HTQTKQFHyMxDnXpdIEkj8FvgwUgDxRV9f/kLRbUlfP3sqXKmQEuYw8I3HOda00s7bmHYiGTEeFcoW+XBbDfIzEOde10szakqS3SPq78HyZpBPa37TOly+W6c1l6MlkfNaWc65rpena+gzw28AfhefPApe1rUXTSJSRZMhl5etInHNdK82srZeY2fGS7gIws+1ho6quly9V6M1lMLzWlnOue6UJJEVJWUJ9LUmLAP/WJBFIDApea8s516XSdG19Cvh3YLGkS4BbgA+1tVXTRKEUDbbnsvKMxDnXtdLM2vqSpDuAU4h2JzzDzB5oe8umgTgjKZR8jMQ5172aBhJJV5vZW4n2Sa8+1tUKpTJ92Qz5rM/acs51rzRdW0cln4Txkhe1pznTS6FUoa8nzNrydSTOuS5VN5BIukjSbuBYSbvCz27gSeAbB6yFHSxfqtCbzZDzdSTOuS5WN5CY2YfCqvaPmNlA+JlnZgvN7KI0N5d0qqRNkjZLurDG632Srg2v3yppRTi+UNL3JT0r6dNV17xI0r3hmk9J0rg+8SSKM5Je79pyznWxNF1b35TUDxBWuH8s7JLYUOgCuww4DVgNvEnS6qrTzgG2m9nhwMeBS8PxYeDvgPfVuPVngXOBVeHn1BSfoS1GMhJfkOic62JpAslngb2SjgP+CngY+EKK604ANpvZFjMrEBV7XFt1zlrgqvD4euAUSTKzPWZ2C1FAGSHpYGDAzH5iZhbaMWUl7Qth1lYum6HoYyTOuS6VJpCUwpf2WuCTZvZJIE0hxyHgkcTzreFYzXPMrATsBBY2uefWJvc8YOKijT1e/dc518XSBJLdki4C3gL8R+iy6klxXa2xi+o/29OcM6HzJZ0raYOkDdu2bWtwy4mLizZ615ZzrpulCSRnE+1Dco6ZPUGUAXwkxXVbgWWJ50uBx+qdIylHtBf8M03uubTJPQEws8vNbI2ZrVm0aFGK5o5fXLSxxwfbnXNdrGkgMbMnzOxjZvaj8PzXZpZmjOR2YJWklaHI4zpgfdU564G3hcdnAjeFbrR6bXmcKEM6MczW+mOmaCpypWIUyxaVkc9mKHqJFOdcl0pTtHFCzKwk6XzgRiALXGlmGyV9ANhgZuuBK4CrJW0mykTWxddLeggYAHrDHvGvNrP7gT8D/g2YDXwr/BxwhZCB9OYyYYdE79pyznWntgUSADO7Abih6tjFicfDwFl1rl1R5/gG4OjJa+XE5MN+7VHRxgxFDyTOuS6VZozE1ZAvlQFC15ZX/3XOda80RRvvZf+ZUTuBDcAHzezpdjSs0xVGMpKoRIp3bTnnulWarq1vAWXgy+F5PI6xi2is4g8mv1mdLxlIenIaGTNxzrlukyaQnGRmJyWe3yvpx2Z2kqS3tKthnS4eI+nNZujJZHxBonOua6UZI5kr6SXxE0knAHPD01JbWjUNjGQkoYx8xaIpwc45123SZCTvBK6UNJdoZfku4J2hkGPXbrk7mpFk6clG8bhYqdCXyU5ls5xz7oBLs9Xu7cAxkgYBmdmOxMvXta1lHW5MRpKJKreUykZfWydUO+dc50kza6sP+ENgBZCLt/8wsw+0tWUdrlAO03+zUfVfwGduOee6Upq/n79BNN33DqKaWw7IF0dXtvdmo+DqM7ecc90oTSBZamZTtnlUp4qDRl8ukZH4okTnXBdKM2vrvyQd0/aWTDPJjCQ5RuKcc90mTUZyMvAnkh4k6toSYGZ2bFtb1uHyiaKNI7O2vGvLOdeF0gSS09reimmoMKZoY8hIfB2Jc64L1Q0kkgbMbBew+wC2Z9qIizb2eUbinOtyjTKSLwOnE83WMsZuc2vAYW1sV8crJEukhIzES8k757pR3UBiZqeH/648cM2ZPgqlCj1ZkcmIXCZeR+IZiXOu+6Rahy1pCDg0eb6Z3dyuRk0H+VKF3tCllfOMxDnXxdKsbL8UOBu4n6icPERdW10dSAqlCn09UV2tHl9H4pzrYmkykjOA55mZr2pPyJfKoxmJryNxznWxNAsStwA97W7IdBNlJNE/X5yReIkU51w3SpOR7AXulvQ9ErW2zOzdbWvVNFAoj46R9HjRRudcF0sTSNaHH5eQL1bozY0dbPcxEudcN0qzH8lVE725pFOBTwJZ4HNm9uGq1/uALwAvAp4Gzjazh8JrFwHnEA3wv9vMbgzH30u02ZYB9wJvN7PhibZxogrlCn0hkPRk4gWJnpE457pP3TESSdeF/94r6Z7qn2Y3lpQFLiMqsbIaeJOk1VWnnQNsN7PDgY8Dl4ZrVwPrgKOAU4HPSMqGacjvBtaY2dFEAWrd+D7y5KiZkfgYiXOuCzXKSC4I/z19gvc+AdhsZlsAJF0DrCWaRhxbC/x9eHw98GlFO2etBa4JM8UelLQ53O/Xoc2zJRWBOcBjE2xfS/LlCvN7ozkII+tIUtTaKpQqfOu+x3ndcYcQbxLmnHPTWd2MxMweD/99uNZPinsPAY8knm8Nx2qeY2Ylog20Fta71sweBT5KFFAeB3aa2X/WenNJ50raIGnDtm3bUjR3fAql0YwkHnQvlppnJD/Y9CQXXHM3Gx/bNeltcs65qdB0+q+kEyXdLulZSQVJZUlpvgVr/bld/Sd7vXNqHpf0HKJsZSVwCNAv6S213tzMLjezNWa2ZtGiRSmaOz75UjnRtZV+QeKeQgmAZ/YUJr1Nzjk3FdKsI/k08Cbgl8BsooHuf0px3VZgWeL5Uvbvhho5R1IOGASeaXDtK4EHzWybmRWBrwMvTdGWSVcojQ62xwsS0wy2xxti7dxXbF/jnHPuAEoTSDCzzUDWzMpm9nngd1NcdjuwStJKSb1Eg+LV04jXA28Lj88EbjIzC8fXSeqTtBJYBdxG1KV1oqQ5YSzlFOCBNJ9hsuUTgWQ860iGi1GVGQ8kzrmZItWCxBAI7pb0v4nGJvqbXWRmJUnnAzcSza660sw2SvoAsMHM1gNXAFeHwfRnCDOwwnnXEQ3Ml4DzzKwM3CrpeuDOcPwu4PLxfeTJEWUkUa2tbEZI6bq28iXPSJxzM0uaQPJWoszlfOC9RF1Of5jm5mZ2A3BD1bGLE4+HgbPqXHsJcEmN4+8H3p/m/dspOdgOUVaSpmtr2Lu2nHMzTMNAEtaCXGJmbwGGgX84IK2aBpJFGwF6Mkq1Q+Jw2Flx514PJM65maHhGEnoTloUurZcUCpXqBgjYyQQzdxKsyDRB9udczNNmq6th4AfS1oP7IkPmtnH2tWoThdX+R3btaVUCxLjjGTHPp/+65ybGdIEksfCTwaYF451dVGpOKtIBpJcJl1GMjprq9Sexjnn3AGWJpDcb2ZfTR6QVHOAvFvEGUk8awuiMilppv/Gs7Z2edeWc26GSLOO5KKUx7pGrYykN5tJ1bWV93UkzrkZpm5GIuk04LXAkKRPJV4aIFrD0bUK5SgYjB1sV6paW3FG8my+RLFcGVnM6Jxz01Wjrq3HgA3A64A7Esd3E60n6VpxMNhvjCTFgsR4jASi7q2Fc/smv4HOOXcA1Q0kZvYz4GeSvhzqWrmgViDpyWpcCxIh6t7yQOKcm+6a9qt4ENlfoRQPtletI0lVIqXMrJ7oOh8ncc7NBN5BPwH5WoEkkz4jWTIwC4AdHkicczOAB5IJGM1IRqf/9uYyqUqk5EtlFs+LurN8CrBzbiZotGf7oKQPS/q5pKfDzwPh2PwD2chOU6g52J5uHclwscLikJF415ZzbiZolJFcB2wHXmFmC81sIdE+JNuBrza4bsbLhzInyaKNuWy6jGS4WGbJvBBIvHCjc24GaBRIVpjZpWb2RHzAzJ4ws0uB5e1vWuca6drqGTtrq9RkQaKZkS9VmDsrx5zerI+ROOdmhEaB5GFJfyVpSXxA0hJJ/xN4pP1N61wjRRuz46u1lRykH5zd411bzrkZoVEgORtYCPxQ0nZJ24EfAAuANx6AtnWsuERKX8/oYHuaja3i62b1ZD2QOOdmjEYLErcD/zP8uIRaGUm0ILFZRjJaWsUDiXNupmi2Q+JrgDOAIaLS8Y8B3zCzbx+AtnWsuPBiT1Yjx3IpxkiGqzKSh5/e275GOufcAdKoaOMngCOALwBbw+GlwLslnWZmFxyA9nWkfLlCXy6DlAgkmeaztuKMZFaPZyTOuZmjUUbyWjM7ovqgpGuBXwBdG0gKpcqYNSQQZm01GSOJM5K+nI+ROOdmjkaD7cOSTqhx/MXAcJqbSzpV0iZJmyVdWOP1PknXhtdvlbQi8dpF4fim0MUWH58v6fqwUPIBSb+dpi2TKV+qjFnVDulqbQ0nMpL5c3rYVyyPZCnOOTddNcpI/gT4rKR5jHZtLQN2hdcakpQFLgNeFa6/XdJ6M7s/cdo5wHYzO1zSOuBS4GxJq4F1wFHAIcB3JR1hZmXgk8C3zexMSb3AnNSfdpIUSpUxdbZgdNaWmY3p8kqqnrUF0er2xfOyNc93zrnpoNGsrTuBl0h6LtFgu4CtyQWKTZwAbDazLQCSrgHWAslAshb4+/D4euDTir6F1wLXmFkeeFDSZuAESRuBlxECmZkVgELK9rSkUjF2D0f7ee3Jl/bv2spEwaNUsTGD8EnxXiR9uQwDIZDs2ldkcVjp7pxz01GzWVuDwMtJzNqSdKOZ7Uhx7yHGLlzcCryk3jlmVpK0k2jtyhDw06prh4B9wDbg85KOI9pw6wIz25OiPS1573V38427Hxt5ftQhA2Nez4WpwKWy0VMnwRjt2soyf04v4PW2nHPTX6OijX8M3Am8gqj7qJ+o1tYd4bVmav1ZXj0aXe+cesdzwPHAZ83shcAeYL+xl9D+cyVtkLRh27ZtKZrb2ENP7eHwxXO5+PTVXHz6aj54xtFjXo+zkGKDcZKRhYxhHQl4IHHOTX+NMpK/AV5UnX1Ieg5wK9G04Ea2Eo2pxJYSrUOpdc5WSTlgEHimwbVbibrXbg3Hr6dOIDGzy4HLAdasWdO8LG8Tw8UKhx3UzztOXlnz9VzctdVg5lYyIxmcHR3b4YUbnXPTXKNZW2L/DAKgQu2ModrtwCpJK8Og+DpgfdU564G3hcdnAjeZmYXj68KsrpXAKuC2MD7ziKTnhWtOYeyYS9tEOxvWHxQf7dpqnpHMymU9I3HOzRiNMpJLgDsl/SejYx3LiWZh/WOzG4cxj/OBG4EscKWZbZT0AWCDma0HrgCuDoPpzxAFG8J51xEFiRJwXpixBfDfgS+F4LQFePu4PvEEDRcrI1vk1hKXSyk0CCRxRtLXkxnJYDyQOOemu0aztq6StB54DaOztn4AXBTqcDVlZjcAN1QduzjxeBg4q861lxAFs+rjdwNr0rz/ZBoulfdbO5KUy6bo2kqMkUhiXl/OA4lzbtprOGsrBIxrDlBbOlq+SUYy0rXVaLC9VB5TWmVgdo9vbuWcm/YmtGe7pHsnuyGdzMwYbjJGEq8jaVRKPl8cu5DRy6Q452aCRkUb31DvJeC57WlOZ4pWrLPfavak5DqSeqoH7OfP8UDinJv+GnVtXQt8idozt7pqKXZy2m49adaRDBcrY7bnHZzdw+Ynn52kVjrn3NRoFEjuAT5qZvdVvyDple1rUudJljappydkJMVSo0BSZlZiwH5wdo/v2+6cm/YajZG8h6hAYy2vb0NbOlatrXWr5RK1turep1QZk9UMeteWc24GaDT990cNXtvQnuZ0pnyKrq14jKTR5lbDxfJ+g+2FUiXKVBrc2znnOtmEZm11m+T6j3p6Uq0jGRswfHW7c24m8ECSQqqMJJNmHcnYtShxIPF6W8656axhIJGUkfTGA9WYTjU8UiOrQYmUXPN1JFHXVmL67+yolPyOvem3VLno6/dw48a0W8I451z7NQwkZlYBzj9AbelY+ZEaWc0zkkZjJPnS2Om/yxdEmzv+alv67VS+fuej3PyL1sviO+fcZEnTtfUdSe+TtEzSgvin7S3rICMZScMSKelqbSUzkmULZjM4u4d7H02zTxiUK0a+VGFPvpTqfOecOxAa1toK3hH+e17imAGHTX5zOlO8jmRWg6KNI+tIGm5sVR4TjCRx7NJB7tm6c1zteDZfbnKmc84dOE0DiZnV3smpi+RL8TqSBhlJio2tqteRABwzNMjlN29JNQV4XwgknpE45zpJ064tSXMk/a2ky8PzVZJOb3/TOkeajKTZOpJyxSiUK/tNIT5maJBSxdj0xO6m7dhXCIGk4IHEOdc50oyRfB4oAC8Nz7cCH2xbizrQyDqSFBtb1VvZXijF4yxVGcnSQQDuebR599a+ka4tDyTOuc6RJpD8lpn9b6AIYGb7SLfV7owxso4kxcZW9WptjWY1Y//Jh+bPZkF/L/dubT7gPpKReCBxznWQNIGkIGk2oQqwpN8C8m1tVYcZLlbozWbIZOrHz3iMpFgnIxmuM4VYEscMpRtw3zsSSHyw3TnXOdIEkvcD3waWSfoS8D3gr9raqg4T72zYiCRyGVGqM0aSbzCF+JihQX755LMjWUs98et7CiXM6g/qO+fcgZRm1tZ3JN0JnEjUpXWBmT3V9pZ1kGgfkeZFFXNZ1R0jGclIanSPHbN0kHLFuP/xXRy//Dl17x9nJGbR4/6+NLO3nXOuvdLW2no5cArwu8DvtK85nal6/Uc9PdlM3VlbjRY1HhsG3O9t0r21L5Gx+DiJc65TpJn++xngXcC9wH3An0q6LM3NJZ0qaZOkzZIurPF6n6Rrw+u3SlqReO2icHyTpNdUXZeVdJekb6ZpR6vypf2n7dbSKJDkG0whfu7ALA6a29d0nCQZSHzmlnOuU6TpG3k5cLSFTnlJVxEFlYYkZYHLgFcRTRm+XdJ6M7s/cdo5wHYzO1zSOuBS4GxJq4F1wFHAIcB3JR1hZvE36QXAA8BAmg/ZqrT7hURjJPW6tupPIY4G3Ae4r8kU4H2J9SM+4O6c6xRpurY2AcsTz5cRbcPbzAnAZjPbYmYF4BpgbdU5a4GrwuPrgVMkKRy/xszyZvYgsDncD0lLgd8HPpeiDZOi1or0WqKMpHYgyRfrj5EAHLN0Pr98cjd7Gyw23FcYzXY8I3HOdYo0GclC4AFJt4XnLwZ+Imk9gJm9rs51Q8AjiedbgZfUO8fMSpJ2hvcbAn5ade1QePwJollj81K0fVJU72xYTzTYXmeMpM6CxNixQ4NUDP7si3cyb1aOnmyG97xyFYcu7B85x8dInHOdKE0guXiC96616KL6z/V659Q8HkqzPGlmd0h6RcM3l84FzgVYvnx5o1ObGi6VGQibUDXSsGtrJCOpHZBevHIBL1w+n0e278UMHnxqD8cMDfKOk0dLnY3p2vIyKc65DpFm+u8PJ3jvrUTdYLGlwGN1ztkqKQcMAs80uPZ1wOskvRaYBQxI+qKZvaVGuy8HLgdYs2ZNS4su8sVJGGxvkpEMzu7h3//8JCAqp3LE335rv6xjX7FMNiPKFfMxEudcx2jnVru3A6skrZTUSzR4vr7qnPXA28LjM4GbwqD+emBdmNW1ElgF3GZmF5nZUjNbEe53U60gMtmGS+kG29PM2mpUryvWm8vQm83wbKE6kFRY0B/tquhdW865TtG2FW1hzON84EYgC1xpZhslfQDYYGbrgSuAqyVtJspE1oVrN0q6DrgfKAHnJWZsHXDDxUqqdSSNFiSOZCQN6nUl9fdl989ICiUW9veybXfeB9udcx2jrUujzewG4IaqYxcnHg8DZ9W59hLgkgb3/gHwg8loZzP5qr3W6+nJNFqQWCYj6Mmmq3fZ35djb1X31b5imbl9Oeb07h9knHNuqtQNJJLuZf/B8RFmdmxbWtSBhqv2Wq8nl9VIufj97hGCUTS7ubm5fbn9so69hSiQ9PflfLDdOdcxGmUk8eZV8Ra7V4f/vhnY27YWdRgzo1CqpOqSymUz7CnU7oGL1qKkH5KqFSz2FcocNLcvBBkfbHfOdYa6gcTMHgaQdJKZnZR46UJJPwY+0O7GdYI02+zGerP1q/+mXR0f6+/LsXNfcb97zOnN1hw/cc65qZLmT+R+SSfHTyS9FOhvcP6Mkmab3Viu4RhJuinEsbk1gsXeQpnZPVn6e/fv9nLOuamSZrD9HcDnJQ0SjZnsDMe6QrP1H0m5bP0FifmUU4hj/b25mutIZvVkmduX44ldw6nv5Zxz7dQwkEjKAIeb2XGSBgCZWfOt/GaQZivSk3qyGYr1SqSMMyPprzHYPtq1tX+Qcc65qdLwm83MKsD54fGubgsikNxHpLXqv/lSOdXmWLG5IVjEOyEWyxWKZYu6tnyw3TnXQdL8ifwdSe+TtEzSgvin7S3rEPnSODKSXP3qv9GixvENtldsNJDFBRtn92Zrjp8459xUSTtGAqPTgCEaKzls8pvTecaTkfRkGlT/LZZZNK8v9fvO7Yve79l8idm9WYYLo4Gkvy/HvmKZcsXIZtKtS3HOuXZJU7RxZbNzZrI4I0lXIiXD3nyZf715CwBDz5nNa485GIgKMY43I4GoptaieX0j+7XPDoPtEFUAHpjVvCpxM7uHi9z+0DP83pFLWr6Xc677pCqRIuloYDVRxV0AzOwL7WpUJ4kzkjQlUlYc1E+hXOGSGx4YOXbb35zC4nmzonUk4xxsh9ENrEa6tsIYCURBZjICyb/f9SgXf2Mjt/31KSwemNX8AuecS2gaSCS9H3gFUSC5ATgNuAXokkCSPiN564mH8oYXDmHAXb/ezluvuI37Ht3J7x05K3WZldjcRLCAsWMkxVAYcrLGSZ56tgDA4zuHPZA458YtzTfbmcApwBNm9nbgOCB9Z/80N551JBBlEnP7chy//DlIcM/WaKJbvlhOXfk3vg+MbmC1L9G11d8bj59MzsytnXujQPLk7vyk3M85113SdG3tM7OKpFJYS/IkXTLQDuNbR5LU35fj8EVzuTcEkvFnJGODRRxI5vTmRipp7p2kjCQuxfIbX+TonJuANIFkg6T5wL8CdwDPArc1vmTmGAkk4xgojx2zdJAf/fIpiuUK5YqNKyOZ0zu2a2vvSNdWhmgzSSatTEocSJ70QOKcm4A0s7b+PDz8Z0nfBgbM7J72NqtzjBRtHGdGAnDs0CBfv/NRHn46KpY80VlbwMj031k9WbKZqC2TVUp+NCPxri3n3PilGWz/AvAj4Edm9vP2N6mz5ItlpIkFkmOWzgfg9oeeAdJVEI7F4yDx3uzxYPuc3tzIWpXJGiPZEQeS3Z6ROOfGL803278BBwP/JOlXkr4m6YL2Nqtz5EtRjay0G1IlrT54gIxGA8l4urZy2QyzejIjWUfNdSST1LW1yzMS51wL0nRt3STph8BMsbf9AAAWe0lEQVSLgd8F3gUcBXyyzW3rCMMpt9mtZXZvliOWzGPDQ9uB8WUkMHaXxH2JQX8JMpqcQGJmPkbinGtJ0282Sd8DfgycDWwCXmxmR7a7YZ0iqpE1/m6t2DFDg/z6mWiMZLwBKVnld7gY7UWSyQhJk7Ynyb5imWLZmNOb5ek9hbpbBTvnXD1pviHvAQrA0cCxwNGSZre1VR1kvPuIVDt26eDI4/EGpOSeJHsLUc2tkdcmqZT8jr1RNrJq8VwAtj3r3VvOufFp+s1mZu81s5cBrweeBj4P7Gh3wzrFePcRqXb00GggGW9GMqZrq1Bhdk8ykGRHBuJbEXdrrVoyD/DuLefc+KXp2jpf0rXA3cAZwJVEZVKaknSqpE2SNku6sMbrfZKuDa/fKmlF4rWLwvFNkl4Tji2T9H1JD0jaeCAG/VvNSJ5/8AC5UKF33BlJIlgMF8tjMpK5NTa+mog4kByxJMpIfMDdOTdeaRYkzgY+BtxhZqm/uSRlgcuAVwFbgdslrTez+xOnnQNsN7PDJa0DLgXOlrQaWEc0qH8I8F1JRwAl4C/M7E5J84A7JH2n6p6TarhYGddsq2qzeqIB9/sf3zXugNTflxtZg7K3UKrKSCana2s0kISMxKcAO+fGKU3X1keAHuCtAJIWSUpTWv4EYLOZbTGzAnANsLbqnLXAVeHx9cApiubZrgWuMbO8mT0IbAZOMLPHzezO0K7dwAPAUIq2TNhwqTzu2VbV4nGS8XaRVc/aqh4jSWYk23bn+emWp0d+nko51rEzjJEcdtBcshl5mRTn3Lilrf67Bnge0fhID/BF4KQmlw4BjySebwVeUu8cMytJ2gksDMd/WnXtmIARusFeCNza7DO0Il+ssLB/4hkJwItXLOD6O7Yyf07vuK5LZh37CuUx18/ty41Z2f7OL2zgZ4+MDl29ZOUCrv3T3276HnFGMr+/h8Xz+rxryzk3bmm6tl5P9IUdZwKPhW6lZmqt4Kveh7beOQ2vlTQX+BrwHjPbVfPNpXOBcwGWL1+eorm1TUZG8voXDvHiFQtY0D+BQFIoU6kY+4plDq4z2D5cLLPx0Z284fghznzRUi6/eQubntid6j127iuSzYh5fTkWD8zyjMQ5N25pviELZmaEL3JJ/SnvvRVYlni+FHis3jmKKhEOAs80ulZSD1EQ+ZKZfb3em5vZ5Wa2xszWLFq0KGWT95dvcYwEIJMRyxfOGfd1cQXgvcUy+4pl5tTp2nrg8V2UKsarVy/hpb91EEcdMsCTu/NUKrX3j0/aua/IwKwcklg8r48nPSNxzo1TmkBynaR/AeZL+m/Ad4HPpbjudmCVpJWSeokGz9dXnbMeeFt4fCZwUwha64F1YVbXSmAVcFsYP7kCeMDMPpaiDS2LZm21lpFMVLJw475CmVnJWVu9OQqlCsVyhfsejUrVx7W9lgzMolwxnt5TaPoeO/YVGZzdE67r83pbzrlxS1Mi5aOSXgXsIhonudjMvpPiupKk84EbgSxwpZltlPQBYIOZrScKCldL2kyUiawL126UdB1wP9FMrfPMrCzpZKJB/3sl3R3e6q/N7IZxfu7UonUkrWUkEzU3sd3uvkJ5zKytOYkgc8/WnSzo7+WQwWh3w8Xzon3HfrNrmEXzGu9BtjMZSObNYsfeIvnSxMvCOOe6T6o920Pg+A5E03olvdnMvpTiuhuItudNHrs48XgYOKvOtZcAl1Qdu4Xa4ydtM6UZSWJPkuqurbjba0+hzL2P7uSYocGRwpLxdrnRVN5BGtm5r8hgGMRfEl+3K8+yBePvinPOdae635CSBsKiwE9LerUi5wNbgDceuCZOnXLFKJatpQWJrYi7tp7ZU6BiY/cziV97+tk8v/jN7jGlWOKAkGYG1s69hZGMZPFAlL34WhLn3Hg0ykiuBrYDPwHeCfwl0AusNbO7G1w3Y0x0m93J0h+yjm1hL/XqBYkAtz34DBWLikPGFs0NASFNINlXZHB2dK/xBCDnnIs1CiSHmdkxAJI+BzwFLA8LAbtCvDviVGck8aD5nKoSKQA/3fI0EG3rG+vNZVjY39t04NzM2DVcSgy2x4HEMxLnXHqN/tQuxg/MrAw82E1BBEYzkqkaI4mDxVNxRpKc/hvGT2598BkOmtvHc0MQiC0emNW0AOOz+RLlijF/djRG8pw5PfRk5RmJc25cGmUkx0mKF/sJmB2eCzAzG2h766bYaNfW1GYkcWn3ZNdWHGR2D5d48ZEL9tvBcclA81XqcQn5OCOJ1pI0D0DOOZdUN5CYWdfP/xzt2pqajGROCBxx3ayxtbZGHyfHR2JL5s3i/sdqLvofEZdHGQiBBKIBd19L4pwbj6n5hpwmpjojyWREf2+Wp3ZHYyS1BtuhTiAZ6OOpZ/OUyvV3PIz3ah9MBJIl82b56nbn3Lh4IGkgzkharbXViv6+3GjXViIj6ctlRvY5SQ60xxYPzKJiNFzdPlKwcU4ikAz0+WC7c25cPJA0MDrYPnW9fHP7cmzfu39GIon+vhxLBvpGZlslxavbG2UXO2pkJIsHZrFrOFpJ75xzaXggaWC4GDKSKVpHAlFGYqH2YjIjgSgAHBvqa1VLM5V3Z62urXDd4zv3TbjNzrnukqpESrfKl6Y+I0kOqs/pGfvr+vjZx3HQ3Nq1tEYCSYOB8537iuQyGrM+5Xlhp8SfP7GbwxbNnXC7nXPdwzOSBvLFqV2QCKPTfAFm9Y79db3o0AUcurB2Vf+D5vYiNV6lvnNfkflzesZMHT7iuXPpyYp7tu5sseXOuW7hgaSB4dLUlkiB0dlZGUFvNn07ctkMB83ta7gmZOfe4pipvxDNUDvyuQPc++iOOlc559xYHkga6ISMJA4kc3pz+y06bKbZDKxkCfmkY5YOcu/WnZg13xjLOec8kDQwMmtrCjOSuGtrIsFsybxZTbu2agWSY4cG2TVc4tfP7B33ezrnuo8HkgbypQrZjMiNo0tpssU1tWb3jr8Niwdm8eTuJmMkNQLJ0WGBo4+TOOfS8EDSwHCxPKXZCIzO2qqesZXGkoE+nt6Tp1hndfuOxF4kSUcsmUdvLsO9j3ogcc4154GkgeFSmb4pHB+BRNdW7/jbsXjeLMxGa3UlVSrG7nypZiDpzWV4/sED3LPVB9ydc815IGkgX6x0QEYSBtsnMkYyEO/dvn8g2T1cwoyRbXarHTs0yMZHd1Gp+IC7c64xDyQNDJcqUzpjC0a7tqpXtafRaHV7rVXtSccMDbI7X+Khp/eM+32dc93FA0kD+WKZ3qnOSOLB9gkEtJE92GsEkh37ovpddQNJKATp4yTOuWba+i0p6VRJmyRtlnRhjdf7JF0bXr9V0orEaxeF45skvSbtPSdTZ2Qk8ayt8bdjYX8f2UztHQ+bZSSrFs+lL5fxmVvOuabaFkgkZYHLgNOA1cCbJK2uOu0cYLuZHQ58HLg0XLsaWAccBZwKfEZSNuU9J81wsTxlm1rF4sH2iWQk2YxYNLePJ2vU26pVQj4pl81w1CEDnpE455pq57fkCcBmM9tiZgXgGmBt1TlrgavC4+uBUxQt314LXGNmeTN7ENgc7pfmnpMmX6pM2aZWsVYyEqi/5W6zjASicZKNj+6k7APuzrkG2ln9dwh4JPF8K/CSeueYWUnSTmBhOP7TqmuHwuNm95w0+WKZWQO1q+seKK2sbIdoUeLNv9jGqz72wzHHt+9NEUiWzueqnzzMqz72Q7KZ8ZVncc51hm++++S2/0HczkBS65un+k/beufUO14rg6r557Kkc4FzAZYvX16/lQ2cdPhBHDy4/6ZRB9Ls3iwXnnYkr3z+4gld/9YTD6UnWzsIHHbQ3IYB6pQjF/OG44dGSsU456Yf1fw6nVztDCRbgWWJ50uBx+qcs1VSDhgEnmlybbN7AmBmlwOXA6xZs2ZCfTN/d3rbhl/G5V0v/60JX/uyIxbxsiMWTeja5/T38rE3vmDC7+2c6w7tHCO5HVglaaWkXqLB8/VV56wH3hYenwncZFHJ2fXAujCrayWwCrgt5T2dc84dQG3LSMKYx/nAjUAWuNLMNkr6ALDBzNYDVwBXS9pMlImsC9dulHQdcD9QAs4zszJArXu26zM455xrTt2w58SaNWtsw4YNU90M55ybViTdYWZrmp3nK9udc861xAOJc865lnggcc451xIPJM4551rigcQ551xLumLWlqRtwMMTvPwg4KlJbM500I2fGbrzc3fjZ4bu/NwT+cyHmlnTFc1dEUhaIWlDmulvM0k3fmbozs/djZ8ZuvNzt/Mze9eWc865lnggcc451xIPJM1dPtUNmALd+JmhOz93N35m6M7P3bbP7GMkzjnnWuIZiXPOuZZ4IKlD0qmSNknaLOnCqW5Pu0haJun7kh6QtFHSBeH4AknfkfTL8N/nTHVbJ5ukrKS7JH0zPF8p6dbwma8NWxXMKJLmS7pe0s/D7/y3Z/rvWtJ7w/+275P0FUmzZuLvWtKVkp6UdF/iWM3frSKfCt9v90g6vpX39kBSg6QscBlwGrAaeJOkztjlavKVgL8ws+cDJwLnhc96IfA9M1sFfC88n2kuAB5IPL8U+Hj4zNuBc6akVe31SeDbZnYkcBzR55+xv2tJQ8C7gTVmdjTR9hPrmJm/638DTq06Vu93exrRPk+riHaS/Wwrb+yBpLYTgM1mtsXMCsA1wNopblNbmNnjZnZneLyb6ItliOjzXhVOuwo4Y2pa2B6SlgK/D3wuPBfwe8D14ZSZ+JkHgJcR7QOEmRXMbAcz/HdNtO/S7LAL6xzgcWbg79rMbiba1ymp3u92LfAFi/wUmC/p4Im+tweS2oaARxLPt4ZjM5qkFcALgVuBJWb2OETBBpjYpvGd6xPAXwGV8HwhsMPMSuH5TPydHwZsAz4fuvQ+J6mfGfy7NrNHgY8CvyYKIDuBO5j5v+tYvd/tpH7HeSCpTTWOzejpbZLmAl8D3mNmu6a6Pe0k6XTgSTO7I3m4xqkz7XeeA44HPmtmLwT2MIO6sWoJYwJrgZXAIUA/UbdOtZn2u25mUv/37oGktq3AssTzpcBjU9SWtpPUQxREvmRmXw+HfxOnuuG/T05V+9rgJOB1kh4i6rb8PaIMZX7o/oCZ+TvfCmw1s1vD8+uJAstM/l2/EnjQzLaZWRH4OvBSZv7vOlbvdzup33EeSGq7HVgVZnb0Eg3OrZ/iNrVFGBu4AnjAzD6WeGk98Lbw+G3ANw5029rFzC4ys6VmtoLod3uTmb0Z+D5wZjhtRn1mADN7AnhE0vPCoVOA+5nBv2uiLq0TJc0J/1uPP/OM/l0n1Pvdrgf+OMzeOhHYGXeBTYQvSKxD0muJ/krNAlea2SVT3KS2kHQy8CPgXkbHC/6aaJzkOmA50f8ZzzKz6oG8aU/SK4D3mdnpkg4jylAWAHcBbzGz/FS2b7JJegHRBINeYAvwdqI/KGfs71rSPwBnE81QvAt4J9F4wIz6XUv6CvAKoiq/vwHeD/xfavxuQ1D9NNEsr73A281sw4Tf2wOJc865VnjXlnPOuZZ4IHHOOdcSDyTOOeda4oHEOedcSzyQOOeca4kHEjcpJC2UdHf4eULSo4nnqSqrSvp8Yo1DvXPOk/TmyWl1zfu/QdKRk3i/pZJqrlGQdEuYjoukGyXNa3CfZZKubXaflG16paT/W+P4OyV9Iu19alx/laRtku6uOr5Q0vdCBdobJQ2G45L0mVCB9mfJzyDpnHD+LyW9JXH8e/H1rnN4IHGTwsyeNrMXmNkLgH8mqqz6gvBTgJEvjrr/mzOzt5vZpibvc5mZfWlyWz/GG4BJCyTAX5BiZzoze00omlnv9UfM7OxJbFc7XElUCLPa3wDfChVof0RU4wzgD4BlZnY4cB5RxW0kHUS0lunFRBWp/zERPL4MvKttn8BNiAcS11aSDle0D8Q/A3cCB0u6XNIGRXtEXJw49xZJL5CUk7RD0ofDX6o/kbQ4nPNBSe9JnP9hSbcp2jvmpeF4v6SvhWu/Et5rv7/YJX1E0v2K9mO4VNLvAK8FPh4yqRWSVoW/ou+QdLOkI8K1X5T0WUk/kvQLSfvVbwqLvs4AvhOez5H01fB+1wCzEuduVbRXyP+RdG7i+AclXRD+He9OcZ/Twr/XnYr22egPx38//BvdQuNK1oeGz7tJ0t+Gaz8k6bzEe1wq6c+rLzSzH7J/9VloUoE2XHsL8FxJi4hqYX3bzHaY2dPATcCrwzXfAP6oQfvdFPBA4g6E1cAVZvbCUI31QjNbQ7QfxqtUe6+XQeCHZnYc8BPgHXXuLTM7AfhLIA5K/x14Ilz7YaKKxmMvkpYQBY2jzOxY4ENm9iPgBuC9IZN6iCib+HMzexFwEdFq4Ngy4OVEf1lfLqmv6m0OJyoOWQjPzwe2h/e7tFa7iFZbJzOPs4CvVp1T8z4h2F4InGJmxwP3ABdImgP8S/i8v0NUvLCeE4jKxhwP/JFGV8L/SXiPbGjTVxrco9pCM9sWHj8KxOXK61WgrVuZ1syeAuZJmj+O93dt5oHEHQi/MrPbE8/fJOlOogzl+USBpto+M/tWeHwHsKLOvb9e45yTib6QMbOfARtrXPcMUUmYf5X0eqJKuGOEL6sTga+FbOAyxn4JX2dmldAd9wjRJkFJBxOVbY+9DPhiaNddtdoV/p2WSVoi6UVEAbG6mF69+7yU6N/yv0J73xz+TVYDvzCzX1lUyqJR1+CNZrbdzPYQldc42cx+BeyWdAxRtnCbmW1vcI9m4nIa9SrQNqtMu43RYOQ6QK75Kc61bORLWtIqop0JTzCzHZK+SKJrJqGQeFym/v9W8zXOqfVFNIaZFSWtAV5F9Bf4nzHafTLSXOCpMO5T8zZNnu9j/8+WpibR14A/JAoC16R8b4ja+20ze+uYg9HnTFsLqd5nuoIoK1lBlN2Mx9OSFoWsZAh4IhyPK9D+NDyPK9BuJQrgJI7fl3g+i+jf1nUIz0jcgTYA7AZ2KSpr/Zo2vMctwBsBwl/R+2U8imZIDZjZN4H3MtrNtBuYBxD+6n48ZCxIykg6LnGbs8IEgiOIvhB/WfU2m4j2wYjdTJQlEO5zVJ32X0MU3N5AFFSq1bvPfwEvV1R8Mh4rWkVU7fYIRdWsBbypzvsCvDqM1cwhGsP4cTj+NaIuvBcA321wfS0NK9CGtp4M/CYEm28Dp4V2LCSq2Puf4bwMUVHCZNeXm2IeSNyBdifRF9t9wL8y+kU1mf4JGJJ0D9GsqfuIdsZLGgT+Q9LPiAZz/0c4/hXgr+PBdqIv9HeF8zYCpyfusZnoS/3/AecmxkIACBuEPSIpDiafBhaGdr0XqFltNXTHLSLaR6PW3iA172NmvyHae/za0N7/Ao4ws71EM52+RTRrakut9w1uIZoZdRfwFTO7O9x7OHzWr5hZpdaFkr4a7r86TB74k/DS/wJ+X9IvibrlPhKO/z/gUUm/Aj5DNHOLEEw+FD7XrcDFZhb//k4AbjGzcoPP4A4wr/7rZhxFGxblzGw4/EX+n8CqxNaqk/EeXwSuN7P91mNUnXcW0YD+30/We0+FkAncDZxhZo0CUbvbcRnR2NQPp6oNbn8+RuJmornA90JAEfCnkxlExul6ouxn2grdg+uBr05lEAnu8iDSeTwjcc451xIfI3HOOdcSDyTOOeda4oHEOedcSzyQOOeca4kHEueccy3xQOKcc64l/x/29HNa/WtZqwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#So let's train the neural network using essentially the same algorithm as before\n",
    "training_steps = 100000\n",
    "initial_epsilon = 1\n",
    "epsilon = initial_epsilon \n",
    "anneal_epsilon = True #do we decrease epsilon over time?\n",
    "max_history_length = 10 #how many past actions do we want to encourage?\n",
    "history = deque([])\n",
    "progress = progress_bar.ProgressBar(total_elements=training_steps)\n",
    "reward_trends = []\n",
    "loss_trends = []\n",
    "trend_interval = 1000\n",
    "cumulative_reward_trend = 0\n",
    "cumulative_loss_trend = 0\n",
    "\n",
    "#nn specific setup\n",
    "criteria = nn.BCELoss()\n",
    "#optimizer = optim.SGD(neural_mdp.parameters(), lr = 0.01, momentum = 0.9)\n",
    "optimizer = optim.Adam(neural_mdp.parameters()) #Adam is a pretty \"safe\"/forgiving optimizer\n",
    "\n",
    "#This is the main training loop.\n",
    "for i in range(0, training_steps):\n",
    "    state, action_predicted, action_taken, reward = train_step_nn(env, neural_mdp, epsilon)\n",
    "    history.append({\"state\": state, \"action_predicted\": action_predicted, \"action_taken\": action_taken, \"reward\": reward})\n",
    "    while len(history) > max_history_length:\n",
    "        history.popleft()\n",
    "        \n",
    "    loss_sum = 0\n",
    "    if reward > 0: #Only if we got a reward do we backpropogate and adjust any network weights\n",
    "        for h in history:\n",
    "            optimizer.zero_grad()\n",
    "            loss_immediate = criteria(neural_mdp(h[\"state\"]), h[\"action_taken\"])\n",
    "            loss_immediate.backward(retain_graph=True)\n",
    "            loss_sum += loss_immediate\n",
    "            optimizer.step()\n",
    "            \n",
    "        cumulative_loss_trend += loss_sum.item()\n",
    "        cumulative_reward_trend += reward\n",
    "        \n",
    "    #We just \"turn down\" epsilon by a linear interpolation from initial_epsilon to 0.\n",
    "    if anneal_epsilon:\n",
    "        epsilon_lerp = initial_epsilon / training_steps\n",
    "        epsilon = epsilon - epsilon_lerp\n",
    "        if epsilon < 0:\n",
    "            epsilon = 0 #might happen due to floating point error stacking up?\n",
    "            \n",
    "    if i % trend_interval == 0:\n",
    "        reward_trends.append(cumulative_reward_trend / trend_interval)\n",
    "        cumulative_reward_trend = 0\n",
    "        loss_trends.append(cumulative_loss_trend / trend_interval)\n",
    "        cumulative_loss_trend = 0\n",
    "        progress.update(i).draw()\n",
    "            \n",
    "progress.update(training_steps).draw()\n",
    "            \n",
    "plt.plot(range(len(reward_trends)), reward_trends)\n",
    "plt.ylabel(\"Reward per 1000 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 1000)\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(loss_trends)), loss_trends)\n",
    "plt.ylabel(\"Loss per 1000 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 1000)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well...\n",
    "-------\n",
    "\n",
    "By looking at the learning curves above, we can already tell that something isn't right.\n",
    "They don't look at all like the curve from the vanilla MDP implementation! What's going on?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|        |  \n",
      "|      R |  \n",
      "|A       |  \n",
      "|        |  \n",
      "|        |  \n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "#Observe our agent after training for a while. Does it appear to have learned anything?\n",
    "for i in range(0,25):\n",
    "    train_step_nn(env, neural_mdp, epsilon=0)\n",
    "    clear_output()\n",
    "    env.render()\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This definitely isn't working. At least, it doesn't work using the exact same training methodology. Is there anything we can do to improve this?\n",
    "\n",
    "First let's examine the network output and see if there might be any clues as to what's going on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In:  tensor([1., 0., 0., 0., 0., 0., 0., 0.])  out:  tensor([0.2093, 0.2125, 0.3100, 0.2762], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 1., 0., 0., 0., 0., 0., 0.])  out:  tensor([0.2085, 0.2135, 0.3079, 0.2768], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 1., 0., 0., 0., 0., 0.])  out:  tensor([0.2049, 0.2090, 0.3044, 0.2778], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 1., 0., 0., 0., 0.])  out:  tensor([0.2062, 0.2110, 0.3046, 0.2785], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 1., 0., 0., 0.])  out:  tensor([0.2038, 0.2104, 0.3032, 0.2768], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 1., 0., 0.])  out:  tensor([0.2081, 0.2146, 0.3075, 0.2780], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 0., 1., 0.])  out:  tensor([0.2092, 0.2152, 0.3089, 0.2765], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 0., 0., 1.])  out:  tensor([0.2080, 0.2140, 0.3113, 0.2787], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "#What does the output look like for each possible state? Maybe we (humans) can learn something from it...\n",
    "tensor_list = []\n",
    "def print_states_predictions(nnmdp):\n",
    "    for i in range(0,8):\n",
    "        inp = one_hot(i, 8)\n",
    "        output = nnmdp(inp) #get the activation for this state, which is a one-hot vector\n",
    "        tensor_list.append(output)\n",
    "        print(\"In: \", inp, \" out: \", output)\n",
    "        \n",
    "print_states_predictions(neural_mdp)\n",
    "if tensor_list[0] is tensor_list[1]:\n",
    "    print(\"Yeah, they're the same\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's quite unusual, each of our states yields the same predicted action! Why is this happening? It's hard to say without diving in to a bunch of math, but we can clearly see that the outputs for each state are very similar and that's NOT what we want. \n",
    "\n",
    "As a sanity check, let's make sure the network is actually capable of learning an ideal policy. There are several, but I already know one so let's jut train it directly. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [####################] 99.9%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([9.9806e-01, 1.0886e-03, 2.9373e-04, 1.4020e-03], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([9.9798e-01, 1.1151e-03, 2.9057e-04, 1.4234e-03], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([9.9806e-01, 1.0871e-03, 2.9841e-04, 1.3987e-03], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([0.0031, 0.0020, 0.0079, 0.9871], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([8.4554e-04, 9.9760e-01, 1.5521e-03, 2.3028e-04], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([8.4717e-04, 9.9760e-01, 1.5693e-03, 2.2826e-04], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([8.6991e-04, 9.9759e-01, 1.4830e-03, 2.3582e-04], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "tensor([3.6107e-04, 5.8860e-03, 9.8516e-01, 8.0534e-03], dtype=torch.float64,\n",
      "       grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "#Let's see if I can just brute force train the network, since the mapping is trivial\n",
    "#and it will rule out some setting being wrong or other stupid bugs.\n",
    "neural_mdp = NeuralNet(8, 32, 4, num_layers = 1).double()\n",
    "\n",
    "criteria = nn.BCELoss()\n",
    "#optimizer = optim.SGD(neural_mdp.parameters(), lr = 0.01, momentum = 0.9)\n",
    "optimizer = optim.Adam(neural_mdp.parameters())\n",
    "\n",
    "training_steps = 1000\n",
    "\n",
    "progress = progress_bar.ProgressBar(total_elements=training_steps)\n",
    "\n",
    "state_action_mapping = [\n",
    "    {\"state\": torch.tensor([1.0,0,0,0,0,0,0,0], dtype=torch.double), \"action\": torch.tensor([1.0,0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,1.0,0,0,0,0,0,0], dtype=torch.double), \"action\": torch.tensor([1.0,0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,1.0,0,0,0,0,0], dtype=torch.double), \"action\": torch.tensor([1.0,0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,0,1.0,0,0,0,0], dtype=torch.double), \"action\": torch.tensor([0,0,0,1.0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,0,0,1.0,0,0,0], dtype=torch.double), \"action\": torch.tensor([0,1.0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,0,0,0,1.0,0,0], dtype=torch.double), \"action\": torch.tensor([0,1.0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,0,0,0,0,1.0,0], dtype=torch.double), \"action\": torch.tensor([0,1.0,0,0], dtype=torch.double)},\n",
    "    {\"state\": torch.tensor([0,0,0,0,0,0,0,1.0], dtype=torch.double), \"action\": torch.tensor([0,0,1.0,0], dtype=torch.double)},\n",
    "]\n",
    "loss_log = []\n",
    "for i in range(0, training_steps):\n",
    "    avg_loss = 0\n",
    "    for k in range(0,8):\n",
    "        #TODO unroll this loop and make sure nothing funny happens\n",
    "        j = state_action_mapping[random.randint(0, len(state_action_mapping)-1)]\n",
    "        optimizer.zero_grad()\n",
    "        out = neural_mdp(j[\"state\"])\n",
    "        loss = criteria(out, j[\"action\"])\n",
    "        loss.backward()\n",
    "        avg_loss += loss.item()\n",
    "        optimizer.step()\n",
    "    avg_loss = avg_loss / len(j)\n",
    "    loss_log.append(avg_loss)\n",
    "    progress.update(i).draw()\n",
    "\n",
    "plt.plot(range(len(loss_log)), loss_log)\n",
    "plt.ylabel(\"Loss per 8 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 8)\")\n",
    "plt.show()\n",
    "\n",
    "for s in state_action_mapping:\n",
    "    pprint(neural_mdp(s['state']).double())\n",
    "\n",
    "#Beautiful! So yes, the network is clearly *capable* of learning the mapping."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "What if we kept a history of all the sequences that led to a reward? A sort of... memory of good experiences?\n",
    "This is basically what DeepMind did in their paper \"Playing Atari with Deep Reinforcement Learning\".\n",
    "They're using a different algorithm (based on more typical Q-learning) but perhaps we just need to have more\n",
    "good examples to train the network on? That should provide some insight in any case.\n",
    "\n",
    "**Forewarning**: This algorithm will take quite some time to run, possibly more than an hour if you're on a laptop or slow computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [####################] 100.0%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xd4VGX2wPHvSYcUSgi9hF4EaRHFSlMUxMK6rmV3Xcviru7afuqy2Luu665b7LqIu4q9oyKiNOm9Su+9hRZISHJ+f9ybMCGTyRCmZGbO53nmmbnv3DtzbgbmzFvu+4qqYowxJnbFhTsAY4wx4WWJwBhjYpwlAmOMiXGWCIwxJsZZIjDGmBhnicAYY2KcJQJjjIlxlgiMMSbGWSIwxpgYlxDuAPxRr149zc7ODncYxhgTUebMmbNLVbMq2y8iEkF2djazZ88OdxjGGBNRRGS9P/tZ05AxxsQ4SwTGGBPjLBEYY0yMs0RgjDExzhKBMcbEOEsExhgT4ywRGGNMjLNEEGDzNuxlwcbc0u2CwmK27z9S6XFHjhaxbOv+YIZmjDFeBTURiMg6EVkkIvNFZLZbVldExonISve+TjBjCIX8wiJ2HcznyNEiLn9xKpe+8CP7Dh8FYMQnizj9yfHkFxZx5GgRCzflljlWVRk9cwMdHviGi/4xmf9NX8+Vr0wjN68gHKdijIlBobiyuK+q7vLYHg6MV9WnRWS4u/2nEMThN1Xlwc+WkJaSQOusNLo0qUX7humoKjeOmk3tmomMGNSRjXvy6N68Dje8OYsfV+1maPcmpa/R9ZFvy7zm38et5OvFW1m/O4+pw/vx3qyNFBYX89GczWzzqDHc/+liAN6ZuYGpq3azbf8RerWsyyOXnMKPq3Yxauo6/n1NDz6Zt5lJK3bylytOpXbNpND8YYwxUUlUNXgvLrIOyPFMBCKyHOijqltFpBEwQVXb+3qdnJwcDcUUE7sO5tP/uYmlv+Y9vfzLHjz25TI25x4uU35Ln9a8OGF10GO7rX9b/jl+JQBDujbmiwVbAGiVlcq4O8/j7Rnr6dgog9Oy6wY9FmNMZBCROaqaU+l+QU4Ea4G9gAKvqOqrIpKrqrU99tmrqj6bh0KVCO7+YAEfztlUpWNrJMZz+GjRCR3zwMWdeGnCai7p2pi7B7YjN+8oD362mO+W7ahSDAAJccJLv+xJo1opvDJpDd8v207v1pkkJ8Tz3JVdSUmMR1UREcYv284Hszfx0i97ICJVfk9jTPVUXRJBY1XdIiL1gXHAH4HP/UkEIjIMGAbQvHnznuvX+zV3UpV9PHcTd72/oEzZJ7ecyfJtBxj+8aIy5Q0zUti2/wjtGqSRnBBPfJzwv5tO57EvlrJhTx6v/LonSfFx5B8t5u2Z68lMTeJPHzmvse7pwWQPH1P62JuvF23lQH4hXy3ayoTlOzktuw6z1u0NyHmOvP407v9kMXee3467P1hQWrZgYy79OtSnUa0a7DhwhNcnr+XZK04lId7GExgTqapFIijzRiIPAweB31LNmoYO5hfS+aGxpdspiXHc3r8dv+/TGoD/TlvHA58tIT05gRvObskf+7Uhv7CYxPg4khL8+6LcuCePA0cK6dQ4g4178th1MJ/uzX33kxcUFnO4oIgjhUWMnrmB8ct2sGjzvtLnv779HG4aNZv0lASe+dmpXPrCjwB0bJQRkBFI3//febTKSuONKWs5XFDIb89thSrMXb+XM9vUO+nXN8YEV9gTgYikAnGqesB9PA54FOgP7PboLK6rqvf6eq1gJ4IFG3O59IUfeeZnXbgyp5nXZpItuYdpmJFCXFz4m1Cmrd5NUkIcPVvUobCoGICE+Dg27M6jfkYycSK0u/9rAC7o1IBvl25n5n39+cPb85i5bs8Jvde/r+nOH96ZV7rdKiuVNTsPMfnevgBkpiVRM8kZc1BUrMRXg7+PMcZRHRJBK+ATdzMBeEdVnxCRTOB9oDmwAfi5qvr8dgpmIth1MJ+cx78DYMLdfciulxqU9wm1GWt2k10vlfrpyRQrxMcJuXkFfDx3Mxef2oiHPl/ChZ0bcvu780uPyWlRh9nr/WuCuq53C0ZNc5rrOjfJoF2DdMYt2c70Ef3Zd/goqckJ1KqRGJRzM8b4J+yJIJCClQiKi5Xuj40rHSVUUZt9NFNVlm09QKfGGQB0fmgsB/MLq/x66SkJHDjiHD/41EZc0KkBg7s0sr4GY8LA30QQESuUBcucDXtLk0B2Zs0wRxMeIlKaBAAWPzLQud+8j/W785i5djf3XNiBJZv3kZqcwJGjRVzx8rQKX68kCQCMWbiVMQu3cvu785lz/wDSUhJITohn76EC3pq2nt/3ae13H4sxJnhiOhEc8vjl+/7veocxkuqnc5NadG5Si8GnNgLg9FaZgFOD+EVOM96bvZGnh3bh7Lb1WL3zENf9ZyapSfEcKvA+hPa0J76jWOHJy7sw4hNnBNXfv1vB0O5N+NsvupXZ9/nvVpCeksiNZ7cM4hkaY0rEbNPQjv1HuG7kLJZt3c/4/zuP1llpAX39aHcwv5C05GO/I7bkHiajRiK5eQVMWbmLIlXu+8S5SjopIY6CQqdTu3bNRHLzyl6w998be5GWnEBifBy3vzuP1TsPAbHZVGdMIFnTkA/T1+zmqlenl27XS0sOYzSRyTMJADSuXaO0/KpezQFoVCuF+ukpvD97I2+5HcvHJwGAX70x0+t7vDJxNRd2bkiLzOjowDemuorJBlrPJACQkRKT+TDo+nVoQOcmtfjThR2Y8qe+pXMx3T+4o1/HP/X1T5z37ASufHkaa3YeDGaoxsS0mGsaWrJlH4P/OQWAXi3rcu/A9uTY/DwhUVhUzL7DR8lMSyY3r4Bida49OO0JZ/juRZ0b8vXibRUe/9qvczi/U4NQhWtMxLPhox56PfEd/Ts24KmhXWg94iuKipW+7bMYeX2vAEZpqmr7/iMcOVpEi8xU3p25gXkbcpm5bg9rdx0qt++aJwexJ6/AmvOM8YP1EXjYcSCf0TM38NTQLiTECUXFSr+O9suyumiQkVL6+KpezbmqV3PW7z7EzLV7SIyP4473jl301uGBbygoKuZfV3dnSNfG4QjXmKgTE4nA0896NuWdGRu4+rRm4Q7F+NAiM7W0k/iCUxowf0Mu17w+gwJ3So0/jp7HKY0zaFKnBskJ8eEM1ZiIF3OdxUVFSoOMZLvSNYLUTErgzDb1+Pr2c8qU93tuIu3v/4b7P11U5enDjTExmAiOFjmzhprI07FRBosevoA59w+gt3uBG8D/pm/g7g8WsPNAPqpaOhEfONOIfDx3E0c9yowxZcVc01BBUTFJlggiVnqKM5Hd6GFnsGrHAQb8bVLpcyWjjwA+/F1vWmelMf6nHdz9wQL2HCrgpnNahTxeYyJBzCWCwiK1GkGUaFM/vcLnjp8P6d8/rLJEYEwFYu4b8WhRMYkJNmd+tJh8b1+/LlDLzTvK3kMFRMJwaWNCLeZqBAXWRxBVmtWtyU3ntOKiLo1IS04gTqDLw9963bf7Y+O4+dxW3HROK+qlJdk6zca4Yi4RWGdxdGriznXk6Ye7+zBvw15OaVyLgc87fQmvTFrDa5PXULtmEg8N6cSl3ZxpLzbszmPCih38und2KMM2plqIqW/EtbsOsWrHQRJsOcWodu3pzqR3LeulMrRHU9rUT6Nzk2NrLhQr7DlUwJtT16GqFBUr17w+nQc/W0L28DGs2mHzGpnYEhNTTGQPH1OuzKY4jm6qWq7pZ/hHC3l31ka/jrd/HyYa+DvFREzVCEzs8Nb+//hlnRl357n8oW8b3rnpdJ/Hb9yTF6zQjKl2or6PwFuN59e9W4QhEhNuCfFxtG2Qzt0D2wOw5JGBbNybx4XPTy7d59rTm/P2jA2c85cfOLtNPXIPF7B+Vx5v3tCLtg3SyHCvYzAmmlSaCEQkFTisqsUi0g7oAHytquVXGKmGij3yQJzA6icH2WgRA0BqcgIdGmaw5slBFKlzfcnRomLenrEBgCmrdpXu+7OXpgJwS5/WdG1Wm4GnNAxLzMYEgz9NQ5OAFBFpAowHrgfeDGZQgVTsUSNITUqwJGDKiYuT0pFkifFx3N6/bYX7vjhhNTf/dw4Tlu8AnPUtHvliCcXF1b+vzZiK+NM0JKqaJyI3Av9S1b+IyLxgBxYoRR7/QVOTo74lzATAnee34/d9WpOSGM/cDXvZsDuvzFTYAL8ZOYtf5DRjyqpdbM49zG/OzLYlNU3E8qdGICLSG7gWKBl+EzHfqJ5dBOm2JKXxU0qiM7V1j+Z1GNK1MY9dekq5fd6bvZHNuYcBGD1zY5n+qB0HjrBht3U4m8jgzzfjHcCfgU9UdYmItAJ+CG5YgePZNNQis2YYIzGRKj5O+FXvbPILi8mokcjATg3p+mjZq5dfnrialyeupkuTWrx4bQ/O+YvzX8SGoZpIUGkiUNWJwEQRyRCRdFVdA9wW/NACo8gjETSva1V3U3Wek9bNuX8APR//rtw+izbvK00CxkSKSpuGRCRHRBYBC4HFIrJARHoGP7TAUI9p6Gsm2UpWJjAy05L58o9nhzsMYwLCn6ah/wC3qOpkABE5GxgJnBrMwALFs0aQEG8jhkzgdG5Si5eu7UHv1pmkJSfwm5Gzygw5Bfhq0VYa1kqhUa0UGtUqPx+SMdWBP4ngQEkSAFDVKSJyIIgxBZRnH4FNNmcC7aIujUof5xUUlnv+lrfnlj4ec9vZnNK4VkjiMuZE+PPNOFNEXhGRPiJynoi8CEwQkR4i0iPYAZ4sz0Rgk82ZYHrkks70yq7LWW0yufnc8ovgDP7nlDBEZUzl/KkRdHPvHzqu/ExAgX6+DhaReGA2sFlVLxaRlsC7QF1gLvArVS04oahPQLFHH4HVCEwwdWlai/d/1xtw5ip6ZdKacvs8MWYp9w3uFOrQjPHJn1FDfU/yPW4HlgEl8wA/A/xdVd8VkZeBG4GXTvI9KlS2achqBCY0mtWtyYS7+5CWksCn8zbz+JhlALw2eS1TVu3mjFZ1eWhI+WsTjAkHf0YNNRCRN0Tka3e7k3uVcaVEpCkwGHjd3RacGsSH7i6jgMuqEri/PK8sTrAagQmh7Hqp1EtLZkjXxmXKl23dz8gf1/HjcR3LxoSLP9+MbwJjgZJ/zStwLjLzx/PAvUBJA00mkKuqJb1qm4Amfr5WlXheWWx9BCYc0jymNmmQkVz6+I735vPIF0vYe6iAhz9fwtpdh8IRnjF+JYJ6qvo+7pe5+yVeVNlBInIxsENV53gWe9nV62xdIjJMRGaLyOydO3f6EaZ3NmrIhFvNpHiuPyubT289i+/uOq+0fOeBfEb+uI7uj43jzanryowwMiaU/PlmPCQimbhf2CJyBrDPj+POAi4RkXU4ncP9cGoItUWk5CdSU2CLt4NV9VVVzVHVnKysLD/ezrsiSwQmzESEh4acQrdmtUlPSWTSPX05r135f9Nrdh7kplGzGPSPyayz2oEJIX++Ge8CPgdai8iPwFv4McWEqv5ZVZuqajZwFfC9ql6LM0/RFe5u1wGfVSVwf6ldUGaqmeaZNfn3Nd3LlecXFvPdsh0s3bqf296dx6H8QnbsPxKGCE2s8ScRLAHOwxkuejNwCvDTSbznn4C7RGQVTp/BGyfxWpUqKjN81BKBqR7SK1np7HBBEVe9Op1eT44PUUQmlvlzHcE0Ve2BkxAAEJG5gN8Xk6nqBGCC+3gN0OuEojwJZS8os6YhU33US0uie/M6pKckcEXPpsxau5ejRcX8+4dVJMTHsWiz0wI7acVOzvXSlGRMoFSYCESkIc6Inhoi0p1jHb0ZQMTM51xsTUOmmpp9//llts9sXQ9w/p0+/93K0vJf/2emTWdtgsrXT+SBwF9xOnSf87jdBYwIfmiBV7LYiDHV2R/6tqFWjbJNR3cet0KaMYFUYSJQ1VHuVcW/UdV+qtrXvV2iqh+HMMaT4nkdQadGGRXvaEw1kRAfx9ThZWdu+WTeZqau2sWBI0fDFJWJZv40mjd1F6UREXldROaKyAVBjyzAStagNSYSlKyvnZacwAfu/EXXvD6DLg9/y13vzWfT3jye+3Y5+YXOJT0LN+XS8YFv2LjHlsc0J86fzuIbVPUfIjIQqA9cj7Mewbe+D6teujerHe4QjDkh7w47g6Z1atC0TtkuuY/nbebjeZsBaFSrBpd3b8KYRVs5fLSI/05fz4hBHcMRrolgfi1e794PAkaq6gK8XyFcLZU0DTnTHBkTOc5olVmaBH57Tkvi44Q7BrQts8+ITxbR8cFveGfGBgBenbSmtJZgjL/8SQRzRORbnEQwVkTSOTZ3UMSwNGAi2X2DO7H6yUHcMaAdb1yXU+75A0eOLYrzhDvTqTH+8qdp6EacNQnWqGqeO93E9cENK3DU+1RGxkSsni3q0Kd9FkN7NOW20fPKPT9z7R5UlZE/riMxXtiUe5g/9mtbZvI7Yzz5sx5BMc4CMiXbu4HdwQwqGKxlyESL2jWTePN655rMCzo14K1p63jyq2MX+/+07QAt//xVmWNSkxK4rX/ZZiVjSkT9TwS1CoGJYimJ8Qw7tzXZmansOVTA9z/t4Nul28vt97dxK1i98yBntanH0O5NOFJYzNIt++nVsm4YojbVTdQnghJWIzDR7IJTGgLQpE4Nvl26nVZZqazZWXYG08/mb+Gz+VvYfbCA6Wt2M3HFThY+fAEZlcx7ZKJfpYlARLz9ZDigqhFxZYtVCEwsOadtFvMfPJ/aNZOYtW4Pb0xeS/2MZN6atr50n2e+OdaM9MWCLZzVuh7Z9VLDEa6pJvypEcwFmgF7cQbf1Aa2isgO4LfHLTxTbYmNGzIxonbNJABOy67Ladl1UVVuPLslL09cw+iZG8rse98ni0mMF1Y+MSgcoZpqwp/ho98Ag1S1nqpmAhcB7wO3AC8GM7hAUOskMDFORGiRmcpTQ7sw9o5zyz1/tMj+j8Q6fxJBjqqOLdlQ1W+Bc1V1OpBc8WHVjFUIjKF9w3RuPLtluMMw1Yw/iWCPiPxJRFq4t3uBvSISTwRcWGa/dYwpa9i5rcqVLdniz+qzJlr5kwiuwZmK+lOcZSWbu2XxwJXBCy2wrEJgjKNBRgr/uro7XZrUokntGgAM/ucUnh37E0+MWcqMNbt5duxP7Dhgy2TGCn8uKNsF/LGCp1cFNpzAsy4CY8ob0rUxQ7o2Ztu+I5zxlLMc5gs/rAbgtclrAcg/Wsz9F3cKW4wmdPwZPtoOuBvI9txfVftVdEx1ZJPOGVNeg4yKu/kqW1fZRA9/ho9+ALwMvA5E4LSGViUwpiIiwhU9m/LhnE3lnjt8NAL/u5sq8ScRFKrqS0GPJMisPmCMdw8M7kTb+mls2JPHroP5jF3iTFHx8sTVrNx+gNevy7EadZTzJxF8ISK3AJ8A+SWFqronaFEFkPURGONbrZqJ3HxeawA27skrTQQA43/awT0fLuTZK07lh+U7mLh8J4nxcdw3uKMlhyjiTyK4zr2/x6NMgfJj0Kox+zdrTOWy0p0+g5TEOI4cdUaHfzhnE2MXb+NA/rE1D24+r3Xpviby+TNqKKKvPrEKgTH+S0mMZ+1TgygqVqas2sVvRs4CKJMEAK59fTpPDe1CYZFyeqvMcIRqAqjCRCAi/VT1exEZ6u15Vf04eGEFns01ZIx/RISEeKFhrZQK91mx/SA/e2kaAOueHhyq0EyQ+KoRnAd8Dwzx8pwCEZEIrI/AmKpJTSr/9eBthFFxsRIXZz+0IlmFiUBVH3LvI2ZZSm9KJp2zPgJjTkyql6UtvS13ufNgPg0yKq49mOqv0ikmRCRZRK4RkREi8mDJLRTBGWPCJzU5HoAWmTUZc9vZNMxIoU/7rHL7fblwa6hDMwHmz6ihz4B9wBw8ho9GipKWIasQGHNikhPief4X3TitZV2a1K7B9BH9OXDkKM3q1mD/4UL2HXbWpnrsy6U89uVSJtzdxxa4iVD+JIKmqnph0CMxxlQ7l3VvUmY7PSWRyff2Y+2uQ/T964Qyz01etYvC4mJa1UuzPoMI48/so1NFpMuJvrCIpIjITBFZICJLROQRt7yliMwQkZUi8p6IJJ1w1CdArUpgTMC1rJfKuDvLLnLzwKeLGfC3SZz59Pcs2mTTWkcSfxLB2cAcEVkuIgtFZJGILPTjuHygn6p2BboBF4rIGcAzwN9VtS3O8pc3VjX4E2HDR40JrOaZNenWrDZZ6cm0yKxZWr5t/xGG/HsKU1fvYs76vWGM0PjLn6ahi6rywuoM1znobia6NwX64axnADAKeBgI2lxGapeUGRMUyQnxfHrrWQDk5hXQ7dFxALStn8bKHQe55rUZgF1nEAkqrBGISIb78EAFt0qJSLyIzAd2AOOA1UCuqpZcprgJaFLBscNEZLaIzN65c6c/b1dJLCf9EsaYCtSueayF95s7zqWxx8VoqsrizfuYt8FqB9WVr6ahd9z7OcBs936Ox3alVLVIVbvhrHDWC+jobbcKjn1VVXNUNScrq/yQNb9ZhcCYkEhPTqBGYjzxccIFpzQsLR89cyMX/2sKl784NYzRGV98XVB2sXt/0nMNqWquiEwAzgBqi0iCWytoCmw52df3h1UIjAmu6SP6l/7uemhIJ1btOMiUVbsY8cmi0n3W7z5Ei0wbYlrd+NNZjIjUEZFeInJuyc2PY7JEpLb7uAYwAFgG/ABc4e52Hc51CkFjFQJjQiM1OaH0ymMR4drTm5fbZ+KKY828O/YfYf+RoyGLz1TMn6UqbwJux/n1Ph/nV/00nE5fXxoBo0QkHifhvK+qX4rIUuBdEXkcmAe8cRLx+83mTjcmtHpm1ymznZWezBcLtjCgYwP25hUw+J9TaJCRzIwRA8IUoSnhz6ih24HTgOmq2ldEOgCPVHaQqi4EunspX4PTXxASNumcMeFRPz2FpY8O5OWJa7jhrGxue3c+k1bs5Mynvy/dZ/v+iJusICr50zR0RFWPgDPvkKr+BLQPbliBZxUCY0KvZlICd53fjto1k9h1wPuX/q6DlgzCzZ9EsMlt6/8UGCcinxGiDt5AsOsIjKkeBp/ayGv5wk25IY7EHK/SRKCql6tqrqo+DDyA06Z/WbADCzSrEBgTXrf0ae21/IY3Z7N9/5EQR2M8+UwEIhInIotLtlV1oqp+rqoFwQ8tMKyPwJjqwdeAjatenR7CSMzxfCYCVS0GFohI+XFgEcb6CIwJv67Napc+vmfgsa7GtbsO8eRXyyguVvIKCq25KMT8GTXUCFgiIjOBQyWFqnpJ0KIKIKsQGFN9jP7t6RzKLyI9JYHkhDieHbu89LlXJ60hKy2ZGWv38N2y7Sx8+AIyUhLDGG3s8CcRVDpUNDJYlcCYcKuZlEBNj7WQZ97Xn15PjC/dfnbscgqKigHIyy+yRBAi/owaGuT2DZTegEHBDixQ1DoJjKm26qenMPI3p5VulyQBgIP5dtVxqPiTCM73UlalqanDoXRdGqsQGFMt9e1Q32v5gL9N4sY3Z4U4mtjkaxrq34vIIqC9uyBNyW0t4M/CNMYY45dPbz3L64+18T/tYMFG6zgOtsqmoR4CfO7el9x6quovQxBbYLhVAqsQGFN9dWtWm7VPDead355e7rlLX/iRkT+uDUNUsaPCRKCq+1R1naperarrPW57QhmgMSZ29G6VyQ1nlZ/5/pEvlgKw51ABew5FzGVMEcOfUUMRrWSKCZt91JjqT0R4cEgnioqLqZeWzHPjVpR5vsdj40hNimfJoxeGKcLoFPWJwBgTeR65tDMAyYlxPPnVTwBkDx8DwKGCorDFFa0qHTUkIg1EpIeIdBeRBqEIKpDU+giMiVjDzm1NckL5r6m3pq0LeSzRzNeooW4iMh2YAPwFeBaYKCLTRaRHiOILGGsZMiYy/bp3i3JlD362hOzhY7jq1WlhiCj6+KoRvAncrqodVXWAe+sA3AGMDEl0AWDXkxkT2f58UUeWPjqQemnJ5Z6bvmYP01bvDkNU0cVXIkhV1RnHF6rqdCDiVp8WaxwyJiLFxQk1kxL4/u7zuM5L7eDq16azfNsBtuQeDkN00cFXZ/HXIjIGeAvY6JY1A34NfBPswALFKgTGRIeMlETuv7gTv+/Thvkb9/LhnM18t2w7AAOfnwTAuqcHhzPEiFVhIlDV20TkIuBSoAlOf+sm4AVV/SpE8QWM9REYE/kS4+NoWCuFC2s1omOjDOLjYOyS7eEOK+L5HD6qql8DX4colqCwSeeMiU4tMlN55Vc5bNidx7nP/gDAPR8s4Nx2WQzq0oj4OPv15y9fo4ZqicjTIrJMRHa7t2VuWe2KjjPGmFBqVrdG6eMP5mzij6Pn2fDSE+Srs/h9YC/QV1UzVTUT6AvkAh+EIrhAsPqAMdFNRPj9ceshP/LFUp7/bgUjf1xLcbF9C1TGVyLIVtVnVHVbSYGqblPVp4GIW7rS+giMiV6HvVxt/Px3K3nki6W0GvEVRZYMfPKVCNaLyL2eVxO7Vxn/iWOjiKo96yIwJvrd1r8t9wxs7/XiM4BZ62yuTF98JYJfAJk4VxPvFZG9OFcZ1wWuDEFsAWXXERgTveqmJnFr3zY8cskpXp/PzbPVznzxNQ31XlX9k6p2UNU67q2jWxZB6dWqBMbEChGhZ4s65cp/97857Nh/JAwRRQafk86JyEAReUlEPheRz9zHETn/q/URGBMb3rz+NBpkONNR/O3KrqXlv31rNjeNmsV2SwjlVHgdgYg8D7TDubJ4k1vcFLhNRC5S1dtDEN9Jsz4CY2JLekoiOdl1GbNwK50aZ5SWL9i0D4CCooW8dUOvcIVXLfm6oGyQqrY7vlBE3gNWAJGRCNx7qxEYEzueHtqFgac0pEPDDN66oRf3fLiA7fvzAZi0YmeYo6t+fDUNHRERb2nzNKDSupWINBORH9yL0JaIyO1ueV0RGSciK9378g16xhhzEtJTErmka2MAzm2XRf+OZZdSKSwqDkdY1ZavRPAb4F8islREvnVvy4B/uc9VphD4P1XtCJwB3CoinYDhwHhVbQuMd7eD5tjCNFYlMCZW3TuwPX/9+bH+go17baZST75GDc1V1dOBfsCfgRE4VxmfrqpzKnthVd2qqnPdxweAZTjwDF6rAAAWFklEQVST110KjHJ3GwVcdnKnYIwxvtWumcQVPZtyzenOtbA3vjmLXQfzyS8sIjevIMzRhV+laxa7VxZv8ywTkQ6q+pO/byIi2UB3YAbQQFW3uq+9VUTqV3DMMGAYQPPmVb+Q+dji9VV+CWNMlHj80s58Om8za3YdIufx70rLf3dea4Zf1CGMkYVXpWsWV+Bbf3cUkTTgI+AOVd3v73Gq+qqq5qhqTlZWVlViNMaYMuLihD7ty3+fvDxxNdnDx/Dlwi1hiCr8fA0f/WdFTwF+zT4qIok4SeBtVf3YLd4uIo3c2kAjYMeJBHyibPF6Y4ynPC/zEpX4wzvzGNCxASmJ8SGMKPx81QiuBxYDc467zQYqbVQTEQHeAJap6t88nvocuM59fB3w2YmHbYwxVXPkaMWJAKDDA9/wr/ErQxRN9eArEcwCFqvqqONvwAE/Xvss4FdAPxGZ794GAU8D54vISuB8dzto7DoCY4ynDg2di8weHtKJzNQkr/s8N25FKEMKO1+dxVdQwfUCqtqyshdW1SlU3CLTv/LQAs0ygTEG/jyoAxef2oic7Lpc1as5HR7wvgT7fZ8s4onLu4Q4uvDwNXx0j6rmhTKYYLClKo0xnpIT4snJrgtASmI8654ezEe/711uv7dnbACIiYVtqjpqKOJY05AxpiI9W9Rl7gPnlyv/atFWWo34ivdnRcwSLFUSM4nAGGN8qeulv+CWt+cC8P7sGE4EIhIvIs+GKphgsgqBMaYyj13WuXQKa0/R3qLgMxGoahHQ0x0KGpGsi8AY469fndGCiff0LVc+a91eZqzZHYaIQsOfpqF5wGci8isRGVpyC3ZggRbBucwYE0IpifG0qpdarvwXr04PQzSh4U8iqAvsxpl8boh7uziYQQWS2lKVxpgT9Oqvc0of10s71ncQrSOI/Jl07vpQBBJsVh8wxvirTf00lj46kPyjxSzcvI/r/jMTgFYjvuLxyzpzYeeG1Esr35cQqSqtEYhIOxEZLyKL3e1TReT+4IcWGNZHYIypippJCdRJTeK8dlmM/u0ZpeX3f7q4zMyl0cCfpqHXcNYjOAqgqguBq4IZVDBYF4Expqp6t84sV3Y0ilY58ycR1FTVmceVFQYjmGCwGoExJhA+vfWsMts3/7fS9bkihj+JYJeItMadv01ErgC2BjWqACqddM56CYwxJ6FxrZQy29//tIP8Qt8zmUYKfxLBrcArQAcR2QzcAfwuqFEZY0w1Uz8jhYGnNChTdvcHC8MUTWBVmghUdY2qDgCygA6qeraqrg9+aIFRMumc9REYY07W0B5Ny2x/sSA6VjTzZ9RQprta2WRggoj8Q0TK95wYY0yUa163ZrmyW9+ZG4ZIAsufpqF3gZ3Az3DWKNgJvBfMoALJ+oqNMYHSsVEGE+7uw/LHL+Sa05sDMGZhxHSZVsivK4tV9TFVXeveHsfPNYuNMSbaZNdLJTkhnoeHnEJ8nNPm/OOqXWGO6uT4kwh+EJGrRCTOvV0JjAl2YAFTsni99REYYwIoKSGOxy/rDMC1r89g0D8mR+xCWP4kgpuBd4B89/YucJeIHBCR/cEMzhhjqrOrezWnT/ssAJZu3c+8jblhjqhq/Bk1lK6qcaqa6N7i3LJ0Vc0IRZAno2TSOZt91BgTDLVrJJY+HvriVBZt2hfGaKrGVigzxpiTcGHnRmW2h/x7Cpv2RtZy71GfCEqa7Kw+YIwJhgs7Nyy33vFd7y0IUzRVE/WJwBhjgq1uahIPXNypdHvd7kNhjObE+XNBWWsRSXYf9xGR20QkYoaPls41ZFUCY0wQ3Xh2Sy7t1hiA/MLImpnUnxrBR0CRiLQB3gBa4owiiig26ZwxJtj++vOu3HR2S/YdPspTXy+LmHWO/UkExapaCFwOPK+qdwKNKjmm2ojQYb3GmAiUGB9X2grxysQ1EbPOsT+J4KiIXA1cB3zpliX62L9asqYhY0wo9O9Qv8z2vryjYYrEf/4kguuB3sATqrpWRFoC/wtuWIFji9cbY0LpzDb1ePum00u3uz76Lf2em8CRo9V37QJ/Lihbqqq3qepoEakDpKvq0yGILaCsQmCMCZWz2tRjwt19SrfX7DzE4s3V90Izf0YNTRCRDBGpCywARorI3/w47j8isqNk0Xu3rK6IjBORle59nZMLv3LWR2CMCYcWmWWnrH5pwmoOF1TPWoE/TUO1VHU/MBQYqao9gQF+HPcmcOFxZcOB8araFhjvboeGVQmMMSEkIvysR1NGDOoAwPifdvDMNz+FOSrv/EkECSLSCLiSY53FlVLVScCe44ovBUa5j0cBl/n7elVlFQJjTLg8d2VXhp3bunT7zanrmLa6+g0p9ScRPAqMBVar6iwRaQWsrOL7NVDVrQDuff1K9j95JUtVWpXAGBMmI68/rfTxmEVb2Lgnj237joQxorISKttBVT8APvDYXoOzWllQicgwYBhA8+bNg/12xhgTNH3bH/vNO39jLuf85QcA1j09OFwhleFPZ3FTEfnE7fjdLiIfiUjTyo6rwHa3mQn3fkdFO6rqq6qao6o5WVlZVXw7m2LCGFM9TLqnLwCLNx9bxuVgfmG4winDn6ahkcDnQGOgCfCFW1YVn+NcmIZ7/1kVX8cYYyJK88zyC993fmgsv3pjBoVF4Z2byJ9EkKWqI1W10L29CVT6E11ERgPTgPYisklEbgSeBs4XkZXA+e52UNk01MaY6qJLk1rlyiav3MW0MM9JVGkfAbBLRH4JjHa3rwYqjVpVr67gqf5+xmaMMVHlvZvPYEvuYUZ8spgaifFMXLETgO3788Malz81ghtwho5uA7YCV+BMOxERShaTtqUqjTHhVjMpgTb103n/5t6MuqEX9w/uCMCanQfDGpc/U0xsUNVLVDVLVeur6mU4F5cZY4w5CTed04pmdWvw4oTVzNuwN2xxVHWFsrsCGkUQlY4aCmsUxhjj3c96OIMwL39xKuOXbQ9LDFVNBPa9aowxAXDHgHalj28cNTssMVQ1EUTMzA2lo4YsdRljqqlxd54LQNdm4VkFuMJRQyJyAO9f+ALUCFpExhgTY9o2SOesNpnsPxyeC8wqTASqmh7KQILlWB+BVQmMMdXX6h2H2Lb/CGt2HqRVVlpI37uqTUPGGGMC6OpezpxqP395GodCPPVE1CcCtUuLjTER4PYBbTmvXRa7DxXw1aKtPPz5kpAlhKhPBCWss9gYU929cV0ONRLjuefDhbw5dR2jZ24IyfvGTCIwxpjqLiE+rsx8RO9YIggsqxAYYyJBp8YZpY/X7DwUkveM+kRgi9cbYyLJPQPbl9nec6gg6O8Z9YmghE06Z4yJBKnJCcy6bwDPXnEqreqlhiQR+DMNdUTTyLkI2hhjAMhKT+bnOc34eU6zkLxf1NcIbPSoMcb4FvWJwBhjjG9Rnwhs8XpjjPEt6hOBMcYY36I+ERzrI7AqgTHGeBP1icAYY4xvUZ8ISoaPWh+BMcZ4F/WJwBhjjG9RnwhsigljjPEt6hOBMcYY32ImEVgfgTHGeBczicAYY4x3UZ8ISpaqtOsIjDHGu6hPBMYYY3yL+kRQemWxVQiMMcarsCQCEblQRJaLyCoRGR6OGIwxxjhCnghEJB54AbgI6ARcLSKdgvV+pbOPBusNjDEmwoWjRtALWKWqa1S1AHgXuDTYb2pLVRpjjHfhWKqyCbDRY3sTcHow3ui+TxbxzeJtwXhpY4yJGuFIBN5+mpebCEJEhgHDAJo3b16lN2pcuwant6pL66w04uOsRmCMMd6EIxFsAjxXZG4KbDl+J1V9FXgVICcnp0ozBt3at01VDjPGmJgSjj6CWUBbEWkpIknAVcDnYYjDGGMMYagRqGqhiPwBGAvEA/9R1SWhjsMYY4wjHE1DqOpXwFfheG9jjDFlRf2VxcYYY3yzRGCMMTHOEoExxsQ4SwTGGBPjLBEYY0yME42A1d1FZCewvoqH1wN2BTCcSGDnHBvsnGPDyZxzC1XNqmyniEgEJ0NEZqtqTrjjCCU759hg5xwbQnHO1jRkjDExzhKBMcbEuFhIBK+GO4AwsHOODXbOsSHo5xz1fQTGGGN8i4UagTHGGB+iOhGIyIUislxEVonI8HDHEwgi0kxEfhCRZSKyRERud8vrisg4EVnp3tdxy0VE/un+DRaKSI/wnkHViUi8iMwTkS/d7ZYiMsM95/fcac0RkWR3e5X7fHY4464qEaktIh+KyE/u59072j9nEbnT/Xe9WERGi0hKtH3OIvIfEdkhIos9yk74cxWR69z9V4rIdScTU9QmAhGJB14ALgI6AVeLSKfwRhUQhcD/qWpH4AzgVve8hgPjVbUtMN7dBuf827q3YcBLoQ85YG4HlnlsPwP83T3nvcCNbvmNwF5VbQP83d0vEv0D+EZVOwBdcc49aj9nEWkC3AbkqGpnnGnqryL6Puc3gQuPKzuhz1VE6gIP4Szz2wt4qCR5VImqRuUN6A2M9dj+M/DncMcVhPP8DDgfWA40cssaAcvdx68AV3vsX7pfJN1wVrIbD/QDvsRZ8nQXkHD8542z1kVv93GCu5+E+xxO8HwzgLXHxx3NnzPH1jOv635uXwIDo/FzBrKBxVX9XIGrgVc8ysvsd6K3qK0RcOwfVYlNblnUcKvC3YEZQANV3Qrg3td3d4uWv8PzwL1AsbudCeSqaqG77XlepefsPr/P3T+StAJ2AiPd5rDXRSSVKP6cVXUz8FdgA7AV53ObQ3R/ziVO9HMN6OcdzYnA22r1UTNESkTSgI+AO1R1v69dvZRF1N9BRC4GdqjqHM9iL7uqH89FigSgB/CSqnYHDnGsucCbiD9nt2njUqAl0BhIxWkaOV40fc6VqegcA3ru0ZwINgHNPLabAlvCFEtAiUgiThJ4W1U/dou3i0gj9/lGwA63PBr+DmcBl4jIOuBdnOah54HaIlKyyp7neZWes/t8LWBPKAMOgE3AJlWd4W5/iJMYovlzHgCsVdWdqnoU+Bg4k+j+nEuc6Oca0M87mhPBLKCtO+IgCafT6fMwx3TSRESAN4Blqvo3j6c+B0pGDlyH03dQUv5rd/TBGcC+kipopFDVP6tqU1XNxvkcv1fVa4EfgCvc3Y4/55K/xRXu/hH1S1FVtwEbRaS9W9QfWEoUf844TUJniEhN9995yTlH7efs4UQ/17HABSJSx61JXeCWVU24O02C3CEzCFgBrAbuC3c8ATqns3GqgAuB+e5tEE7b6HhgpXtf191fcEZPrQYW4YzICPt5nMT59wG+dB+3AmYCq4APgGS3PMXdXuU+3yrccVfxXLsBs93P+lOgTrR/zsAjwE/AYuC/QHK0fc7AaJw+kKM4v+xvrMrnCtzgnvsq4PqTicmuLDbGmBgXzU1Dxhhj/GCJwBhjYpwlAmOMiXGWCIwxJsZZIjDGmBhnicAAICKZIjLfvW0Tkc0e20l+vsZIj3HvFe1zq4hcG5iovb7+UBHpEMDXayoin1Xw3BQR6eY+Hisi6T5ep5mIvFfZ6/gZ0wAR+dRL+U0i8ry/r+Pl+FEislNE5h9Xniki491ZLseKSC23XETkRXdmzAWe5yAiN3rMjPlLj/LxJceb6sMSgQFAVXerajdV7Qa8jDPbYzf3VgCl//Er/Dejqter6vJK3ucFVX07sNGXMRQIWCIA/g8/VohS1YGqesDH8xtV9RcBjCsY/gMM9lJ+H/C1OjNjTsaZ8wlgCNBMndk/b8UZ746I1ANGAKfhzJD7mMeX/zvA74J2BqZKLBEYn0SkjThzw78MzAUaicirIjJbnHnjH/TYd4qIdBORBBHJFZGn3V+K00SkvrvP4yJyh8f+T4vITHHWjTjTLU8VkY/cY0e771XuF7OIPCsiS8WZp/0ZETkH5+K6v7s1mWwRaev+ip0jIpNEpJ177P9E5CURmSwiK0Sk3Jw27tWtlwHj3O2aIvKB+37v4lzQVLLvJnHWD3hORIZ5lD8uIre7f8f5frzORe7fa644c+2nuuWD3b/RFJz5eCrSwj3f5SJyv3vsUyJyq8d7PCMitxx/oKpOxPsUDZcCo9zHo9y/SUn5W+6xU4CGIpKFMz/QN6qaq6q7ge9xrnwF54rZa3zEb8LAEoHxRyfgDVXtrs4MkcNVNQdnjvzzxfs6D7WAiaraFZiGcxWkN6KqvYB7gJKk8kdgm3vs0zgzrJY9SKQBzpf+Kap6KvCUqk4GvgLudGsy63B+zd+iqj1xpiL/t8fLNAPOw/ll+6qIJB/3Nm1wJrsrcLf/gDP//ak4c9+XiwtnLiTPX/4/x7n61ZPX13GT5XCgv6r2wLmi+HYRqYkzzfAg4BycCdkq0gtnGo4ewDVuAn0d+I37HvFuTKN9vMbxMlV1p/t4M840yFCFmTFVdReQLiK1T+D9TZBZIjD+WK2qszy2rxaRuTg1hI44ieJ4h1X1a/fxHJz517352Ms+Z+N8oaKqC4AlXo7bgzMl9WsicjnO7JxluF82ZwAfub/GX6Dsl+j7qlrsNmdtxFn8w1MjnKmgS5wL/M+Na563uNy/UzMRaSAiPXES2vGTgVX0Omfi/C2nuvFe6/5NOgErVHW1OlMB+GpaG6uqe1X1EM60FGer6mrggIh0wfm1PlNV9/p4jcpUNvtnZTNj7uRYMjHVQELluxhz7EtWRNrirBTWS1VzReR/eDRteCjweFxExf/W8r3s4+2LpAxVPSoiOTiL8lwF/J5jzQ+l4QK73H4Pry9TyfZhyp+bP3OyfAT8DOdL/F0/3xuceL9R1V+VKXTO09+5YCo6pzdwagXZOLWLE7FbRLLcWkETYJtbXjID5nR323NmzDM8jm+KM3dQiRScv62pJqxGYE5UBnAA2C/OdLkDg/AeU4ArAdxfseVqHOKM0MlQ1S+BOznWTHMASAdwf/VudWsMiEiciHT1eJmfux3g7XC+0FYe9zbLcebGLzEJ51c67uucUkH87+Ikp6E4SeF4Fb3OVOA8EWnlPpfqJt6lQDtxZtIVnNWpKnKB21dRE6cN/0e3/COcJrBuwHc+jvfG58yYbqxnA9vdZPENcJEbRybOLKLfuvvFAfUo23RkwswSgTlRc3G+mBYDr3HsiyaQ/gU0EZGFOKN2FuOsPuWpFjBGRBbgdEbe5ZaPBkaUdBbjfCH/zt1vCXCxx2uswvlS/gIY5tEXAIA6C/5sFJGSZPBvINON606cmUHLcZuzsnDm1t/hZRevr6Oq23FmonzPjXcq0E5V83BG2nyNM2pnjbf3dU3BGZkzDxitqvPd1z7inutoVS32dqCIfOC+fie38/s37lNPAoNFZCVOs9azbvkXwGYRWQ28iDNyCDcZPOWe1wzgQVUt+fx6AVNUtcjHOZgQs9lHTbUjziIjCap6xP1F/C3QVo8tVxiI9/gf8KGqlhuPf9x+P8fpkH44UO8dDu4v8fnAZarqK5EEO44XcPpmJoYrBlOe9RGY6igNGO8mBAFuDmQSOEEf4tQ+IpbbvPY58EE4k4BrniWB6sdqBMYYE+Osj8AYY2KcJQJjjIlxlgiMMSbGWSIwxpgYZ4nAGGNinCUCY4yJcf8PLhx7rXvEqVQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Reinitialize the Neural Network so that it has random weights and we aren't starting from a bad spot.\n",
    "neural_mdp = NeuralNet(input_size, hidden_size, output_size, num_layers = 1) #maybe we'll play with the other parameters later\n",
    "\n",
    "#Modify our algorithm to keep a buffer of past state->action sequences that ended in a reward.\n",
    "training_steps = 100000\n",
    "initial_epsilon = 1\n",
    "epsilon = initial_epsilon \n",
    "anneal_epsilon = True #do we decrease epsilon over time?\n",
    "max_history_length = 10 #how many past actions do we want to encourage?\n",
    "history = deque([])\n",
    "max_replay_memory = 1000 #Keep this many \"positive\" sequences to reinforce from\n",
    "replay_memory = deque([])\n",
    "progress = progress_bar.ProgressBar(total_elements=training_steps)\n",
    "reward_trends = []\n",
    "loss_trends = []\n",
    "trend_interval = 100\n",
    "cumulative_reward_trend = 0\n",
    "cumulative_loss_trend = 0\n",
    "\n",
    "#nn specific setup\n",
    "criteria = nn.BCELoss()\n",
    "optimizer = optim.Adam(neural_mdp.parameters()) #Adam is a pretty \"safe\"/forgiving optimizer\n",
    "\n",
    "#This is the main training loop.\n",
    "for i in range(0, training_steps):\n",
    "    state, action_predicted, action_taken, reward = train_step_nn(env, neural_mdp, epsilon)\n",
    "    state_action_reward = {\"state\": state, \"action_predicted\": action_predicted, \"action_taken\": action_taken, \"reward\": reward} \n",
    "    history.append(state_action_reward)\n",
    "    while len(history) > max_history_length:\n",
    "        history.popleft()\n",
    "        \n",
    "    loss_sum = 0\n",
    "    if reward > 0:\n",
    "        replay_memory.append(history.copy()) #must make a copy becase otherwise altering history alters everything in here\n",
    "        while len(replay_memory) > max_replay_memory:\n",
    "            replay_memory.popleft()\n",
    "            \n",
    "    cumulative_reward_trend += reward\n",
    "            \n",
    "    #Here's where the actual training happens. We select a random successful sequence state->action transition\n",
    "    #from the replay memory at every step and backpropogate + update weights from it.\n",
    "    loss_sum = 0\n",
    "    if len(replay_memory) > 0:\n",
    "        for j in range(0,100):\n",
    "            successful_sequence = replay_memory[random.randint(0, len(replay_memory) - 1)]\n",
    "            optimizer.zero_grad()\n",
    "            h = successful_sequence[random.randint(0, len(successful_sequence)-1)]\n",
    "            loss = criteria(neural_mdp(h[\"state\"]), h[\"action_taken\"])\n",
    "            loss_sum += loss\n",
    "            loss.backward(retain_graph=True)\n",
    "            optimizer.step()\n",
    "        cumulative_loss_trend += loss_sum.item()\n",
    "        \n",
    "    #We just \"turn down\" epsilon by a linear interpolation from initial_epsilon to 0.\n",
    "    if anneal_epsilon:\n",
    "        epsilon = initial_epsilon - (i / training_steps)\n",
    "            \n",
    "    if i % trend_interval == 0:\n",
    "        reward_trends.append(cumulative_reward_trend / trend_interval)\n",
    "        cumulative_reward_trend = 0\n",
    "        progress.update(i).draw()\n",
    "        loss_trends.append(cumulative_loss_trend / trend_interval)\n",
    "        print(\"Loss: \", cumulative_loss_trend)\n",
    "        cumulative_loss_trend = 0\n",
    "            \n",
    "progress.update(training_steps).draw()\n",
    "            \n",
    "plt.plot(range(len(reward_trends)), reward_trends)\n",
    "plt.ylabel(\"Reward per 1000 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 1000)\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(loss_trends)), loss_trends)\n",
    "plt.ylabel(\"Loss per 1000 training steps\")\n",
    "plt.xlabel(\"Training step (divided by 1000)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In:  tensor([1., 0., 0., 0., 0., 0., 0., 0.])  out:  tensor([0.9799, 0.0033, 0.0089, 0.0024], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 1., 0., 0., 0., 0., 0., 0.])  out:  tensor([0.9808, 0.0039, 0.0103, 0.0028], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 1., 0., 0., 0., 0., 0.])  out:  tensor([0.0119, 0.0030, 0.0046, 0.9803], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 1., 0., 0., 0., 0.])  out:  tensor([0.0053, 0.0082, 0.0349, 0.9731], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 1., 0., 0., 0.])  out:  tensor([0.0024, 0.0015, 0.0012, 0.9874], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 1., 0., 0.])  out:  tensor([0.0080, 0.9854, 0.0041, 0.0024], grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 0., 1., 0.])  out:  tensor([1.1483e-03, 3.7157e-03, 9.8759e-01, 1.5264e-04],\n",
      "       grad_fn=<SigmoidBackward>)\n",
      "In:  tensor([0., 0., 0., 0., 0., 0., 0., 1.])  out:  tensor([0.0066, 0.0068, 0.9807, 0.0041], grad_fn=<SigmoidBackward>)\n"
     ]
    }
   ],
   "source": [
    "#What does the output look like for each possible state? Maybe we (humans) can learn something from it...\n",
    "def print_states_predictions(nnmdp):\n",
    "    for i in range(0,8):\n",
    "        inp = one_hot(i, 8)\n",
    "        output = nnmdp(inp) #get the activation for this state, which is a one-hot vector\n",
    "        print(\"In: \", inp, \" out: \", output)\n",
    "        \n",
    "print_states_predictions(neural_mdp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Observe our agent after training for a while. Does it appear to have learned anything?\n",
    "for i in range(0,25):\n",
    "    train_step_nn(env, neural_mdp, epsilon=0)\n",
    "    clear_output()\n",
    "    env.render()\n",
    "    time.sleep(0.5)"
   ]
  }
 ],
 "metadata": {
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}