BayesianOpt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: gym in /opt/conda/lib/python3.7/site-packages (0.17.3)\n",
      "Requirement already satisfied: pyvirtualdisplay in /opt/conda/lib/python3.7/site-packages (0.2.5)\n",
      "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /opt/conda/lib/python3.7/site-packages (from gym) (1.5.0)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.7/site-packages (from gym) (1.5.3)\n",
      "Requirement already satisfied: numpy>=1.10.4 in /opt/conda/lib/python3.7/site-packages (from gym) (1.19.3)\n",
      "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /opt/conda/lib/python3.7/site-packages (from gym) (1.6.0)\n",
      "Requirement already satisfied: EasyProcess in /opt/conda/lib/python3.7/site-packages (from pyvirtualdisplay) (0.3)\n",
      "Requirement already satisfied: future in /opt/conda/lib/python3.7/site-packages (from pyglet<=1.5.0,>=1.4.0->gym) (0.18.2)\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "ffmpeg is already the newest version (7:4.1.6-1~deb10u1).\n",
      "python-opengl is already the newest version (3.1.0+dfsg-2).\n",
      "xvfb is already the newest version (2:1.20.4-1+deb10u2).\n",
      "0 upgraded, 0 newly installed, 0 to remove and 53 not upgraded.\n",
      "Hit:1 http://packages.cloud.google.com/apt cloud-sdk-buster InRelease\n",
      "Hit:2 http://packages.cloud.google.com/apt google-cloud-packages-archive-keyring-buster InRelease\n",
      "Hit:3 http://packages.cloud.google.com/apt gcsfuse-buster InRelease            \n",
      "Hit:4 http://security.debian.org/debian-security buster/updates InRelease      \n",
      "Hit:5 http://deb.debian.org/debian buster InRelease                            \n",
      "Hit:6 http://packages.cloud.google.com/apt google-compute-engine-buster-stable InRelease\n",
      "Hit:7 http://deb.debian.org/debian buster-updates InRelease                    \n",
      "Hit:8 http://deb.debian.org/debian buster-backports InRelease                  \n",
      "Hit:9 https://download.docker.com/linux/debian buster InRelease                \n",
      "Hit:10 https://nvidia.github.io/libnvidia-container/stable/debian10/amd64  InRelease\n",
      "Hit:11 https://packages.cloud.google.com/apt kubernetes-xenial InRelease\n",
      "Hit:12 https://nvidia.github.io/nvidia-container-runtime/stable/debian10/amd64  InRelease\n",
      "Hit:13 https://nvidia.github.io/nvidia-docker/debian10/amd64  InRelease\n",
      "Reading package lists... Done\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "cmake is already the newest version (3.13.4-1).\n",
      "0 upgraded, 0 newly installed, 0 to remove and 53 not upgraded.\n",
      "Requirement already up-to-date: setuptools in /opt/conda/lib/python3.7/site-packages (51.0.0)\n",
      "Requirement already satisfied: ez_setup in /opt/conda/lib/python3.7/site-packages (0.9)\n",
      "Requirement already satisfied: gym[atari] in /opt/conda/lib/python3.7/site-packages (0.17.3)\n",
      "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (1.6.0)\n",
      "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (1.5.0)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (1.5.3)\n",
      "Requirement already satisfied: numpy>=1.10.4 in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (1.19.3)\n",
      "Requirement already satisfied: Pillow; extra == \"atari\" in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (8.0.1)\n",
      "Requirement already satisfied: atari-py~=0.2.0; extra == \"atari\" in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (0.2.6)\n",
      "Requirement already satisfied: opencv-python; extra == \"atari\" in /opt/conda/lib/python3.7/site-packages (from gym[atari]) (4.4.0.46)\n",
      "Requirement already satisfied: future in /opt/conda/lib/python3.7/site-packages (from pyglet<=1.5.0,>=1.4.0->gym[atari]) (0.18.2)\n",
      "Requirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from atari-py~=0.2.0; extra == \"atari\"->gym[atari]) (1.15.0)\n",
      "Collecting package metadata (current_repodata.json): done\n",
      "Solving environment: done\n",
      "\n",
      "# All requested packages already installed.\n",
      "\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "x11-utils is already the newest version (7.7+4).\n",
      "xvfb is already the newest version (2:1.20.4-1+deb10u2).\n",
      "0 upgraded, 0 newly installed, 0 to remove and 53 not upgraded.\n",
      "Requirement already satisfied: gym[box2d]==0.17.* in /opt/conda/lib/python3.7/site-packages (0.17.3)\n",
      "Requirement already satisfied: pyvirtualdisplay==0.2.* in /opt/conda/lib/python3.7/site-packages (0.2.5)\n",
      "Requirement already satisfied: PyOpenGL==3.1.* in /opt/conda/lib/python3.7/site-packages (3.1.5)\n",
      "Requirement already satisfied: PyOpenGL-accelerate==3.1.* in /opt/conda/lib/python3.7/site-packages (3.1.5)\n",
      "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /opt/conda/lib/python3.7/site-packages (from gym[box2d]==0.17.*) (1.5.0)\n",
      "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /opt/conda/lib/python3.7/site-packages (from gym[box2d]==0.17.*) (1.6.0)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.7/site-packages (from gym[box2d]==0.17.*) (1.5.3)\n",
      "Requirement already satisfied: numpy>=1.10.4 in /opt/conda/lib/python3.7/site-packages (from gym[box2d]==0.17.*) (1.19.3)\n",
      "Requirement already satisfied: box2d-py~=2.3.5; extra == \"box2d\" in /opt/conda/lib/python3.7/site-packages (from gym[box2d]==0.17.*) (2.3.8)\n",
      "Requirement already satisfied: EasyProcess in /opt/conda/lib/python3.7/site-packages (from pyvirtualdisplay==0.2.*) (0.3)\n",
      "Requirement already satisfied: future in /opt/conda/lib/python3.7/site-packages (from pyglet<=1.5.0,>=1.4.0->gym[box2d]==0.17.*) (0.18.2)\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "E: Unable to locate package freeglut-devel\n",
      "Requirement already satisfied: hyperopt in /opt/conda/lib/python3.7/site-packages (0.2.5)\n",
      "Requirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from hyperopt) (1.15.0)\n",
      "Requirement already satisfied: future in /opt/conda/lib/python3.7/site-packages (from hyperopt) (0.18.2)\n",
      "Requirement already satisfied: cloudpickle in /opt/conda/lib/python3.7/site-packages (from hyperopt) (1.6.0)\n",
      "Requirement already satisfied: numpy in /opt/conda/lib/python3.7/site-packages (from hyperopt) (1.19.3)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.7/site-packages (from hyperopt) (1.5.3)\n",
      "Requirement already satisfied: networkx>=2.2 in /opt/conda/lib/python3.7/site-packages (from hyperopt) (2.5)\n",
      "Requirement already satisfied: tqdm in /opt/conda/lib/python3.7/site-packages (from hyperopt) (4.51.0)\n",
      "Requirement already satisfied: decorator>=4.3.0 in /opt/conda/lib/python3.7/site-packages (from networkx>=2.2->hyperopt) (4.4.2)\n"
     ]
    }
   ],
   "source": [
    "!pip install gym pyvirtualdisplay\n",
    "!sudo apt-get install -y xvfb python-opengl ffmpeg\n",
    "!sudo apt-get update\n",
    "!sudo apt-get install cmake\n",
    "!pip install --upgrade setuptools\n",
    "!pip install ez_setup\n",
    "!pip install gym[atari]\n",
    "!conda install -c conda-forge pyglet -y\n",
    "\n",
    "\n",
    "# install required system dependencies\n",
    "!sudo apt-get install -y xvfb x11-utils\n",
    "# install required python dependencies\n",
    "!pip install gym[box2d]==0.17.* \\\n",
    "            pyvirtualdisplay==0.2.* \\\n",
    "            PyOpenGL==3.1.* \\\n",
    "            PyOpenGL-accelerate==3.1.*\n",
    "\n",
    "!sudo apt install freeglut-devel\n",
    "!pip install hyperopt\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Display cmd_param=['Xvfb', '-br', '-nolisten', 'tcp', '-screen', '0', '1400x900x24', ':1007'] cmd=['Xvfb', '-br', '-nolisten', 'tcp', '-screen', '0', '1400x900x24', ':1007'] oserror=None return_code=None stdout=\"None\" stderr=\"None\" timeout_happened=False>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gym\n",
    "from gym import logger as gymlogger\n",
    "from gym.wrappers import Monitor\n",
    "gymlogger.set_level(40) #error only\n",
    "\n",
    "import numpy as np\n",
    "import random\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import math\n",
    "import glob\n",
    "import io\n",
    "import base64\n",
    "from IPython.display import HTML\n",
    "from IPython import display as ipythondisplay\n",
    "\n",
    "import argparse\n",
    "import pickle\n",
    "from collections import namedtuple\n",
    "from itertools import count\n",
    "\n",
    "import os, time, json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from timeit import default_timer as timer \n",
    "\n",
    "from torch.utils.data.sampler import BatchSampler, SubsetRandomSampler\n",
    "\n",
    "from pyvirtualdisplay import Display\n",
    "display = Display(visible=0, size=(1400, 900))\n",
    "display.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import pickle\n",
    "from collections import namedtuple\n",
    "from itertools import count\n",
    "\n",
    "import os, time, json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "from torch.utils.data.sampler import BatchSampler, SubsetRandomSampler\n",
    "\n",
    "# taken from https://github.com/sweetice/Deep-reinforcement-learning-with-pytorch, with heavy modifications.\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self, num_state, num_action):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(num_state, 64)\n",
    "        self.activation = nn.ReLU() \n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(64, num_action)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.activation(self.fc1(x))\n",
    "        action_prob = self.fc2(x)\n",
    "        return action_prob\n",
    "\n",
    "\n",
    "class DQN():\n",
    "    def __init__(self, num_state, num_action, params):\n",
    "        super(DQN, self).__init__()\n",
    "\n",
    "        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        # data collection aids\n",
    "        self.name = 'agents/' + params.env_name + '_' + params.model_name\n",
    "        self.losses = []\n",
    "        self.rewards = []\n",
    "        self.params = params \n",
    "        if self.params.mode == 'test':\n",
    "            self.load(self.name)\n",
    "        else:\n",
    "            self.target_net, self.act_net = Net(num_state, num_action), Net(num_state, num_action)\n",
    "            self.target_net, self.act_net = self.target_net.to(self.device), self.act_net.to(self.device)\n",
    "            self.unpack_params()\n",
    "            self.loss_func = nn.MSELoss()\n",
    "            self.num_actions = num_action \n",
    "            self.num_states = num_state\n",
    "            self.memory_count = 0 \n",
    "            self.update_count = 0\n",
    "\n",
    "    def unpack_params(self):\n",
    "        self.epsilon = self.params.exploration_noise\n",
    "        self.optimizer = get_optimizer(self.params.optimizer, self.act_net, self.params.learning_rate)\n",
    "        self.capacity = self.params.capacity\n",
    "        self.memory = [None]*self.capacity\n",
    "        self.update_point = self.params.update_count \n",
    "        self.gamma = self.params.gamma\n",
    "        self.batch_size = int(self.params.batch_size)\n",
    "        self.game = self.params.env_name\n",
    "        self.epsilon_decay = self.params.epsilon_decay \n",
    "\n",
    "    def select_action(self,state):\n",
    "        state = torch.tensor(state, dtype=torch.float).unsqueeze(0)\n",
    "        state = state.to(self.device)\n",
    "        value = self.act_net(state)\n",
    "        action_max_value, index = torch.max(value, 1)\n",
    "        action = index.item()\n",
    "        if np.random.uniform() <= self.epsilon: \n",
    "            action = np.random.choice(range(self.num_actions), 1).item()\n",
    "        return action\n",
    "\n",
    "    def store_transition(self,transition):\n",
    "        index = self.memory_count % self.capacity\n",
    "        self.memory[index] = transition\n",
    "        self.memory_count += 1\n",
    "\n",
    "    def update_epsilon(self, t):\n",
    "        self.epsilon = 0.1 + 0.99 * np.exp(-t/20000)\n",
    "    \n",
    "    def update_target_network_weights(self):\n",
    "        if self.update_count == self.update_point:\n",
    "            self.update_count = 0 \n",
    "            self.target_net.load_state_dict(self.act_net.state_dict())\n",
    "\n",
    "    def update(self):\n",
    "        if self.memory_count >= self.capacity:\n",
    "\n",
    "            # convert inputs to torch tensors. \n",
    "            state = torch.Tensor([t.old_state for t in self.memory]).float()\n",
    "            action = torch.LongTensor([t.action for t in self.memory]).view(-1,1).long()\n",
    "            reward = torch.Tensor([t.reward for t in self.memory]).float()\n",
    "            next_state = torch.Tensor([t.new_state for t in self.memory]).float()\n",
    "\n",
    "            # move to device. \n",
    "            state = state.to(self.device)\n",
    "            action = action.to(self.device)\n",
    "            reward = reward.to(self.device)\n",
    "            next_state = next_state.to(self.device)\n",
    "\n",
    "            # normalize rewards. \n",
    "            reward = (reward - reward.mean()) / (reward.std() + 1e-7)\n",
    "\n",
    "            # update Q value\n",
    "            with torch.no_grad():\n",
    "                target_v = reward + self.gamma * self.target_net(next_state).max(1)[0]\n",
    "            \n",
    "            batch_loss = 0\n",
    "\n",
    "            # sample from replay buffer, update actor network. \n",
    "            for index in BatchSampler(SubsetRandomSampler(range(len(self.memory))), batch_size=self.batch_size, drop_last=False):\n",
    "                v = (self.act_net(state).gather(1, action))[index]\n",
    "                loss = self.loss_func(target_v[index].unsqueeze(1), (self.act_net(state).gather(1, action))[index])\n",
    "                self.optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                self.optimizer.step()\n",
    "                batch_loss += loss.item()\n",
    "                \n",
    "                # update target Q network when sufficient iterations have passed. \n",
    "                self.update_count +=1\n",
    "                self.update_target_network_weights()\n",
    "\n",
    "            self.losses.append(batch_loss/self.batch_size)\n",
    "            self.rewards.append(reward.mean().item())\n",
    "    \n",
    "    def save(self, ep_number):\n",
    "        if not os.path.isdir('agents'):\n",
    "            os.mkdir('agents/')\n",
    "        act_model_path = 'agents/' + self.params.model_name + '_' + self.game + '_actor_episode' + str(ep_number) + '.pth'\n",
    "        target_model_path = 'agents/' + self.params.model_name + '_' + self.game + '_target_episode' + str(ep_number)+ '.pth'\n",
    "        torch.save(self.act_net.state_dict(), act_model_path)\n",
    "        torch.save(self.target_net.state_dict(), target_model_path)\n",
    "\n",
    "        save_dic = vars(self.params)\n",
    "\n",
    "        save_dic['num_actions'] = self.num_actions \n",
    "        save_dic['num_states'] = self.num_states \n",
    "        save_dic['memory_count'] = self.memory_count \n",
    "        save_dic['update_count'] = self.update_count\n",
    "        save_dic['losses'] = self.losses\n",
    "        save_dic['rewards'] = self.rewards\n",
    "\n",
    "        filename = self.name + '.json'\n",
    "        with open(filename, 'w') as fp:\n",
    "            json.dump(save_dic, fp, indent=4)\n",
    "\n",
    "    def load(self, name):\n",
    "        # name = 'agents/' + game + '_' + model_name\n",
    "        filename = name + '.json'\n",
    "        print('loading from : ', filename) \n",
    "        try:\n",
    "            with open(filename, 'r') as fp:\n",
    "                data = json.load(fp)\n",
    "        except FileNotFoundError:\n",
    "            raise FileNotFoundError(\"Specified agent does not exist. Aborting.\")\n",
    "        \n",
    "        self.params = argparse.Namespace(**data)\n",
    "        self.num_actions = data['num_actions']\n",
    "        self.num_states = data['num_states']\n",
    "        ep_number = self.params.num_episodes - 1\n",
    "        act_model_path = 'agents/' + self.params.model_name + '_' + self.params.env_name + '_actor_episode' + str(ep_number) + '.pth'\n",
    "        target_model_path = 'agents/' + self.params.model_name + '_' + self.params.env_name + '_target_episode' + str(ep_number)+ '.pth'\n",
    "\n",
    "        # load the models.\n",
    "        self.act_net, self.target_net = Net(self.num_states, self.num_actions), Net(self.num_states, self.num_actions)\n",
    "        self.act_net, self.target_net = self.act_net.to(self.device), self.target_net.to(self.device)\n",
    "        self.act_net.load_state_dict(torch.load(act_model_path))\n",
    "        self.target_net.load_state_dict(torch.load(target_model_path))\n",
    "        \n",
    "        # load other parameters.\n",
    "        self.unpack_params() \n",
    "        self.memory_count = data['memory_count']\n",
    "        self.update_count = data['update_count']\n",
    "        self.losses = data['losses']\n",
    "        self.rewards = data['rewards']\n",
    "    \n",
    "    def get_losses(self):\n",
    "        return self.losses\n",
    "    \n",
    "    def get_rewards(self):\n",
    "        return self.rewards\n",
    "\n",
    "\n",
    "class Transition(object):\n",
    "    def __init__(self, old_state, action, new_state, reward: float, terminate_: bool):\n",
    "        self.old_state = old_state\n",
    "        self.action = action\n",
    "        self.new_state = new_state\n",
    "        self.reward = reward\n",
    "        self.terminate = terminate_\n",
    "\n",
    "    @property\n",
    "    def terminate(self):\n",
    "        return self.__terminate\n",
    "\n",
    "    @terminate.setter\n",
    "    def terminate(self, terminate_):\n",
    "        if isinstance(terminate_, bool):\n",
    "            self.__terminate = terminate_\n",
    "        else:\n",
    "            raise TypeError(f'{terminate_} should be bool type')\n",
    "\n",
    "    def get_transition_tuple(self) -> tuple:\n",
    "        return self.old_state, self.action, self.new_state, self.reward, self.terminate\n",
    "\n",
    "\n",
    "def initialize_game(params):\n",
    "    env = gym.make(params.env_name).unwrapped\n",
    "    num_state = env.observation_space.shape[0]\n",
    "    num_action = env.action_space.n\n",
    "    dqn = DQN(num_state, num_action, params)\n",
    "    return env, num_state, num_action, dqn \n",
    "\n",
    "\n",
    "def get_optimizer(name, net, learning_rate):\n",
    "    if name.lower() == 'adam':\n",
    "        optimizer = optim.Adam(net.parameters(), learning_rate)\n",
    "    elif name.lower() == 'adagrad':\n",
    "        optimizer = optim.Adagrad(net.parameters(), learning_rate)\n",
    "    elif name.lower() == 'adadelta':\n",
    "        optimizer = optim.Adadelta(net.parameters(), learning_rate)\n",
    "    elif name.lower() == 'sgd':\n",
    "        optimizer = optim.SGD(net.parameters(), learning_rate)\n",
    "    elif name.lower() == 'rmsprop':\n",
    "        optimizer = optim.RMSprop(net.parameters(), learning_rate)\n",
    "    return optimizer \n",
    "\n",
    "\n",
    "def display_state_action_dims(games):\n",
    "    for env_name in games:\n",
    "        env = gym.make(env_name).unwrapped\n",
    "        num_state = env.observation_space.shape[0]\n",
    "        num_action = env.action_space.n\n",
    "        print(\"%s | num_states : %s | num_actions: %s\" % (env_name, num_state, num_action))\n",
    "\n",
    "\n",
    "def run(params, return_agent=False):\n",
    "    params = argparse.Namespace(**params)\n",
    "    env, num_state, num_action, agent = initialize_game(params)\n",
    "    all_rewards = []\n",
    "    for i_ep in range(params.num_episodes):\n",
    "        state = env.reset()\n",
    "        if i_ep % 10 == 0 and i_ep > 0:\n",
    "            print(\"episode: %s\" % i_ep)\n",
    "        # if i_ep % (params.log_interval-1) == 0 and i_ep > 0:\n",
    "        #     agent.save(i_ep)\n",
    "        for t in range(params.num_iterations):\n",
    "            action = agent.select_action(state)\n",
    "            next_state, reward, done, info = env.step(action)\n",
    "            if params.render: env.render()\n",
    "            transition = Transition(state, action, next_state, reward, done)\n",
    "            agent.store_transition(transition)\n",
    "            if (done or t == params.num_iterations - 1): \n",
    "                agent.update()\n",
    "            all_rewards.append(reward)\n",
    "            agent.update_epsilon(t)\n",
    "\n",
    "    if return_agent:\n",
    "        return agent \n",
    "    else:\n",
    "        return -np.mean(all_rewards)\n",
    "\n",
    "\n",
    "def show_video():\n",
    "  mp4list = glob.glob('video/*.mp4')\n",
    "  if len(mp4list) > 0:\n",
    "    mp4 = mp4list[0]\n",
    "    video = io.open(mp4, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    ipythondisplay.display(HTML(data='''<video alt=\"test\" autoplay \n",
    "                loop controls style=\"height: 400px;\">\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "             </video>'''.format(encoded.decode('ascii'))))\n",
    "  else: \n",
    "    print(\"Could not find video\")\n",
    "    \n",
    "\n",
    "def wrap_env(env):\n",
    "  env = Monitor(env, './video', force=True)\n",
    "  return env\n",
    "\n",
    "\n",
    "def test_agent(agent, env_name):\n",
    "    env = wrap_env(gym.make(env_name).unwrapped)\n",
    "    observation = env.reset()\n",
    "    num_iters = 0\n",
    "    while True:\n",
    "        if num_iters > 1000:\n",
    "            break\n",
    "        env.render() \n",
    "        action = agent.select_action(observation)\n",
    "        next_state, reward, done, info = env.step(action)\n",
    "        num_iters += 1\n",
    "        if done:\n",
    "            env.reset() \n",
    "#         if done: break \n",
    "        \n",
    "    env.close()\n",
    "    show_video() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "            'mode':'train',\n",
    "            'render': False,\n",
    "            'log_interval': 100,\n",
    "            'env_name': 'LunarLander-v2', \n",
    "            'num_episodes': 150,\n",
    "            'num_iterations':10000,\n",
    "            'exploration_noise': 0.3, \n",
    "            'capacity': 5000,\n",
    "            'model_name': 'trial_model',\n",
    "            'update_count': 10,\n",
    "            'gamma': 0.99,\n",
    "            'batch_size': 128,\n",
    "            'optimizer': 'adam',\n",
    "            'learning_rate': 0.01,\n",
    "            'epsilon_decay': 0.999995\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-c0aaa1cbbe2c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbasic_agent\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_agent\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-16-bb425787b284>\u001b[0m in \u001b[0;36mrun\u001b[0;34m(params, return_agent)\u001b[0m\n\u001b[1;32m    249\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_iterations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    250\u001b[0m             \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect_action\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 251\u001b[0;31m             \u001b[0mnext_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minfo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    252\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    253\u001b[0m             \u001b[0mtransition\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTransition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/gym/envs/box2d/lunar_lander.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, action)\u001b[0m\n\u001b[1;32m    300\u001b[0m                                            True)\n\u001b[1;32m    301\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 302\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mworld\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mFPS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    303\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    304\u001b[0m         \u001b[0mpos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlander\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "basic_agent = run(params, return_agent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot(range(len(basic_agent.rewards)), basic_agent.rewards)\n",
    "plt.title(\"Reward vs Iteration - Basic Agent\")\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "from hyperopt import hp, fmin, tpe, Trials\n",
    "\n",
    "def bayesian_opt(run, space, max_evals=50):\n",
    "    trials = Trials()\n",
    "    best_setting = fmin(run, space, algo=tpe.suggest, max_evals=100, trials=trials)\n",
    "    return best_setting, trials  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizers = ['adam', 'rmsprop', 'sgd', 'adagrad']\n",
    "default_params = {'mode': 'train',\n",
    "                  'render': False,\n",
    "                  'log_interval': 1000,\n",
    "                  'env_name': 'LunarLander-v2',\n",
    "                  'num_iterations': 100, \n",
    "                  'num_episodes': 100,\n",
    "                  'capacity': 5000,\n",
    "                  'model_name': 'trial_model'} \n",
    "\n",
    "hypopt_params = {\n",
    "                'exploration_noise': hp.uniform('exploration_noise', 0, 1),\n",
    "                'update_count': hp.quniform('update_count', 10, 100, 10),\n",
    "                'gamma': hp.uniform('gamma', 0, 1),\n",
    "                'batch_size': hp.quniform('batch_size', 2, 512, 2),\n",
    "                'optimizer': hp.choice('optimizer', optimizers),\n",
    "                'learning_rate': hp.uniform('learning_rate', 0, 1),\n",
    "                'epsilon_decay': hp.uniform('epsilon_decay', 0, 1)\n",
    "                }\n",
    "\n",
    "space = {}\n",
    "space.update(default_params)\n",
    "space.update(hypopt_params)\n",
    "best_setting, trials = bayesian_opt(run, space, max_evals=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_params = default_params \n",
    "final_params.update(best_setting)\n",
    "final_params['optimizer'] = optimizers[final_params['optimizer'] - 1]\n",
    "final_params['num_iterations'] *= 100 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avg best error: 11.867429620665076\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABCRklEQVR4nO2dd5hTZfbHv2f6ZGYApVcBRdcOgooIFlAXRdHFihXFhj9X7KKuK+pace1rBQTsBQsiiILYVlFAlC5FQZo0adPb+f3xTXYyyc0wJclNOZ/nuc9Mbm7ynpvcnPu+p4qqwjAMw0geUtwWwDAMw4gupvgNwzCSDFP8hmEYSYYpfsMwjCTDFL9hGEaSYYrfMAwjyTDFbxhhRESeF5G73JbDMGrCFL8Rd4jIKhE5wYVxx4nIvwL2dRQRFZE0AFDVq1X1vlq8lyvnYBiAKX7DiDt8NxnDqC+m+I2EQUQyReQJEVnv3Z4QkUzvc81EZLKIbBeRP0XkaxFJ8T53m4isE5FdIvKLiPRrgAz/WxWEGlNEXgHQAcBHIpIvIrd6jx8oIou8x38hIvv7ve8qr5zzARSIyC0iMjFg7KdF5In6ym4kDzZzMBKJOwH0BNAVgAL4EMA/ANwF4CYAawE09x7bE4CKyH4ArgVwuKquF5GOAFLDJI/jmKp6kYj0AXC5qk4HABHZF8AbAM4A8AWAG8AbwwGqWup9/WAAAwBsAdAEwEgRaaKq272rgHMBnBwm2Y0Exmb8RiJxAYB7VXWTqm4GcA+Ai7zPlQFoDWAvVS1T1a+VhaoqAGQCOEBE0lV1laqurGGMm70z8u0ish3A/BqODTWmE+cC+FhVP1PVMgCPAsgG0MvvmKdUdY2qFqnqBgBfATjb+1x/AFtUdW4N8hgGAFP8RmLRBsBqv8ervfsAYBSAFQA+FZFfRWQEAKjqCgDXAxgJYJOIvCkibRCaR1W1iW8DcEgNxzqOWRvZVbUSwBoAbf2OWRPwmvEALvT+fyGAV2p4f8P4H6b4jURiPYC9/B538O6Dqu5S1ZtUtTOA0wDc6LPlq+rrqtrb+1oF8HA4hKlpTO84IWUXEQHQHsA6/7cMeM0HAA4RkYMAnArgtXDIbSQ+pviNeCVdRLL8tjTQRv4PEWkuIs0A/BPAqwAgIqeKyD5ehboTNPFUiMh+ItLX6wQuBlDkfa7BhBrT+/RGAJ39Dn8bwAAR6Sci6aB/oATAt6HeX1WLAbwL4HUAP6jq7+GQ20h8TPEb8coUUEn7tpEA/gVgDmh3XwDgR+8+AOgCYDqAfADfAXhWVb8A7fsPgQ7TPwC0AHBHmGQMNSYAPAjepLaLyM2q+gtornnaK8tpAE7zc+yGYjyAg2FmHqMOiDViMYz4RUQ6AFgKoJWq7nRbHiM+sBm/YcQp3jyEGwG8aUrfqAsWx28YcYiI5IB+gtVgKKdh1Boz9RiGYSQZZuoxDMNIMuLC1NOsWTPt2LGj22IYhmHEFXPnzt2iqs0D98eF4u/YsSPmzJnjthiGYRhxhYisdtpvph7DMIwkwxS/YRhGkmGK3zAMI8kwxW8YhpFkmOI3jASjoAD45htg8WK3JTFiFVP8hpFAvPAC0KIFMGAAcPjhwCGHAGsCq/gbSY8pfsNIEL75BrjxRqCwENi5k38XLwZOPhmwBH3DH1P8hpEgPPUUUFRUfV9FBbBqFTC/pgaRRtJhit8wEoQ//nCe2aemAlu3Rl8eI3YxxW8YCcJppwHZ2cH7y8qA7t2jL48Ru5jiN4wE4aqrgDZtgKysqn0eD/CvfwGNG7snlxF7xEWtHsMwdk+jRsDcucCzzwIffgg0bw5cfz3Qr99uX2okGXFRj79Hjx5qRdoMwzDqhojMVdUegfvN1GMYhpFkmOKvJ4sWASedRBtq69bAAw8wdM4wGsqWLcCjjwJXXgm8/DLj8Q0jnJippx6sXg0cfDCQn18VPufxAOedB4wZ465sRnwzfz7Qpw8jcYqKgJwcoFkzYPZs2uwNoy6YqSeMPPooUFxcPWa6sBB47TXGUhtGfbnkEmbd+hKxCgqA9euBf/zDXbmMxMIUfz2YPZszskCysoClS6Mvj5EY7NhBE2IgZWXAe+9FXx4jcTHFXw8OPJDZkIGUlACdO0dfHiMxcLqmfGRkRE8OI/ExxV8PbrmlepIMwIzJ/v2BDh3ckakmNm4ErrsO6NQJOOwwYPx4K9oVi+TmAscfD6QFZNdkZQFDh1bfN2sWfQF5eUCXLsCECdGT00gAVDXmt+7du2us8fXXqgcdpJqSopqdrTpsmGpRkdtSBfPnn6qtW6ump6tS3avm5Khef73bkhlOrF+vus8+qnl5qh4Pv6u+fatfW7Nn8znf9wnw8b//7Z7cRmwCYI466NSIRfWIyFgApwLYpKoHefe9BWA/7yFNAGxX1a67e69Yi+rxp7iYy/CUGF07PfggcN99wVUbMzNZtbFVK1fEajD5+cDUqUBpKfDXvzLyJVGorARmzAB++w3o1o119f3p3x+YNi34dXl5DAU1s1D08QV7ONVKchM3onrGAejvv0NVz1XVrl5lPxFA3LussrJiV+kDVCCBSh+g4v/xx+jLEw4++YQ3rKFDgauvBtq3B1580W2pwkdKCnDiiYzjD1T6APDTT86vq6igWc+IHr//zpIYeXksmXH88bxhxzoRU1mq+hWAP52eExEBcA6ANyI1vkE6dXJ2GlZUAO3aRV+ehrJjB3DmmQxz3LWLM//iYtakSZaIqr33dt6vmlgrn1inpATo2RP48kugvJzbV18BRx3lPNmKJdyaq/YBsFFVl4c6QESuFJE5IjJn8+bNURQtsRg+nLN7f9LTgb/8hW35akNpKfDxx8Abb7ifpzBpkvMKq6yMeRTJwMiRTBj0x+MBhg2LPVNDIvPBB5x4+GfsV1ZyUjJxomti1Qq3FP9g7Ga2r6ovqmoPVe3R3FIW681BBwFvvw20bEnlkJkJ9O5N+3ht+PFHlvo9/3yW/e3UCbj//sjKXBNFRfxxBVJRwR9cMnDiicC4cUDbtowAys3lDf6RR9yWLDkoLQWefx649VauOgPJzwdWroy+XHUhoiUbRKQjgMk+5653XxqAdQC6q+ra2rxPLDt3d4cqsGQJIMJZtog7clRWAr/+Sjtkixa1e015OZV+4ILL4+GN45hjwi/n7vj9d2C//Wje8ScnB5gyxR2Z3EKVSsbjqTkHwAgfFRW06c+eHbqGUm4u8MorwBlnRFU0R2KpZMMJAJbWVunHMz/8AOy1F3DEEXTSde7snkM1JQXYZ5/aK30A+Ppr2jEDKSpyz5naoQPLF3g8VSafnBza/fv0cUcmtxChU9GUfvSYOpU9D0Ip/YwM+s5OPTW6ctWViDViEZE3ABwHoJmIrAVwt6qOAXAeksCpu20bcMIJ1ZeCBQVA377AmjX8wcY6oUwnqqwn4xZ33snKqBMm8MZ0zjmchbm1mjKSh88+4yrLCY8HuPhiVuoNTMKLNSImnqoODrF/SKTGjCXeesu5THNFBR0/Q4ZEXaQ6c8wxzjWJcnKAc8+Nvjz+HH64c6ijYUSSVq3oJwtcCeflAaNHcxISD8RwBHp8s3Gjc0hXcbH7kTG1pVEj4KmnGCniMyfk5FDhxssFbhjh5OKLnU1raWlsdh8vxPiCJH7p3ZtKMnBZ6IuqiRcuv5w+itGjga1bgb/9jU6r+ixld+1inaAvvwT23ZdRQrFY28gwQtG2LfD++8DgwVwNqwJNmjDMOJ5Caa0RS4RQpd35+++rHEEeD80nU6Yknz160yage3fgzz/5eWRkMJ9g2jTg6KPdls4w6kZ5OZ28GRlA166x+3sOFdVjM/4IIcLSAi+8wPZ5IiwxcMUVsXuRRJK776b5y+czKC3lNmQIsGxZcn4mRvySlgYceaTbUtQfm/EbUaFNG2DDhuD98V4szjBimViK4zeSkMASAz5Ug3sbGIYRWUzxG1HhmmuClX9aGnDssXSOGfFDfj5LRtxzD/1VTmHLRmxjNn4jKlx3HR3dH31Eha/KrOZXXnFbMqMuLF3KqLSSEt4AcnMZofXVV4xiM+IDm/EbUSEtjUltP/1Eh/e0acCCBSweZ8QPF1zAyCxfmHJ+PrB4MRv+GPGDOXcNw6gVmzezDk1pafBz7duzgJ4RW5hz1zCMiGHhuPGFKX7DMGpF8+bAwQcHK/msLJYyMOIHU/yGYdSa119ne8fcXJbFzs1lJ7fbb3dbMqMuWFSPUY2iIkbchIq7N5KbffcFVq9mhdnVq1mw74QTnNthGrGLfV0GAPYIOOEEVuRs3Jg1hWK9fZzhDtnZwIUXVvVFiFWlrwo8+yyzxlNT2blt8mS3pYoNYvQrM6JJaSnQqxfwxRcsPlVeDvz3v8BRRyVPH1sj8Xj8ceCWW1gqpLKSNaHOOQf49FO3JXMfU/wGPvoI2LGjegZmZSXNPm+/7Z5chlFfKiqA++4LbpFYVMSVSrKTFDb+5ctZT37jRuDkk4FBg1gS2CArVzo3jcnPN3OPEZ/s2BG6L+6yZdGVJRZJeMX//vvMNiwvZ0ngiROBxx5jMxArDka6duVnEdg0Ji+PzxlGvNG4MQMUnJLN9t03+vLEGglt6vHVey8qqqoDn58PLFwIjBnjqmgxxQknAF26sESyj4wMoHVr4PTT3ZPLMOpLairwj38E1w/Kzgbuv98dmWKJhFb8oao8FBYyHtkgKSlcAV11FWO099wTuPRS4LvvzCTWUAoLgZtuApo2Zcz7OecAa9e6LZUzlZWMgjnwQBbQGz4c2LLFbanqz403Ao88wglMSgpn+m+9xUikZCeha/XMm8ewxEATBgCceKJ5943Ic/zxwKxZQHExH6em8ua6bBlDZ2OJIUOAd96pso1nZLBBzsKFNPsZ8UdS1urp2pU/skBycoBhw6IujpFkzJkDzJ5dpfQBRpvs2gVMmOCeXE789htnw/4O0dJSzvjHjQv9urlzGSyx//7ARRexbLMR+yS04hdhwkaLFpyx5ObSiXn55cAZZ7gtXWywZg3w3HPASy+xIboRPhYudN5fWAj88EN0Zdkdc+Y4m/UKC4HPP3d+zfTpXFF/8AEV/htvAD16cKVtxDYJH9Vz4IG0qX72GWcvxxwDdOzotlSxwRNPsMaKCLfrrqPT+/zz3ZYsMdhnH+eqldnZLHYWS7Rrx0zXQNLTeR5OXHNN9RVCRQUT/m66KfTNwogNEtrGb4Rm6VLgsMOC4/ezsliDpUULd+RKJFT5GS9eXBVWKELb/ooVzmZIt1DlJGn5coY++8jJAebPBzp3rn58URFX0U5tF7OzQ8fQG9El6jZ+ERkrIptEZGHA/r+LyC8iskhEHonU+InGzp3sXHXjjcBrr7H1XUN4882qEFd/UlK4dDcajggwYwbNiunpdOz26gV8+21sKX2gStajj2ZYb3Y2m6tMmhSs9AE6fv3Df/1p2jSystaGn39mP+ANG9yWJDaJpKlnHIBnAPzPjSUixwM4HcAhqloiIjavrAXLllFhFBdzKZ2bC9x1F+3E9VUg5eUM3wtEtfqMz2gYe+5Jp6nv887IcFui0LRuzXpNmzfzOttrr9ANVlJTGf77/PPVV40eD009brF5M9C/P1e06en8zVx5JfDkk9Ysxp+IzfhV9SsAfwbsHgbgIVUt8R5j7sRaMHQo+5z6Cqbl59NvMWJE/d9z0CDnzGVV4LTT6v++hjNpabGt9P1p3px+sN0pyocfBs49l9dRo0b8O2wY4//dYvBgmqYKC1m2oaQEGDsWGD/ePZlikWhH9ewLoI+IfC8iX4rI4aEOFJErRWSOiMzZvHlzFEWMLYqKGAce6IrxlZ+oL4cdRuecx0PzTloal/cPPMAlvmHsjvR04OWXOQmZORP44w/g0Ufdm1lv3gx8803wirWggIEMRhXRjupJA7AHgJ4ADgfwtoh0VgcPs6q+COBFgM7dqEoZQ/gibpxIa+C3N2oUZ0jvvssf8XnnMR7bMOpC06axYdffuZMmKCe2b4+qKDFPtBX/WgDveRX9DyJSCaAZgOSd0u+GrCygXz/GTPvPZDIz2QyjoRx2GDfDiHc6dWKkUWBEUXo6MHCgOzLFKtE29XwAoC8AiMi+ADIAxHE1kOgwZgzNL3l5VPi+Pqf33ee2ZImFKp2bjz/OyCanqCcjdklJoT3f46ma+WdnMwDCavBXJ2IzfhF5A8BxAJqJyFoAdwMYC2CsN8SzFMAlTmYeozpt2jCy55NPWB//0EOBY4+1KIVwUlDAldWiRYy5z8wEmjRhJzLzecQPp5zCaLcnnwR+/ZWVZ6+6CthjD7cliy0sgcswANx2G/DUU9Xr6qSmMtPbslCNeCUpi7QZRm2ZMKG60geYlfrNN87VXQ0jnjHFbzjy9dfAJZcAZ5/NqB+n1PxEoqbzc0p0M+pPYSF7PaxY4bYkyYspfiOIe+5h9uMrr1DpDxnCqIhEVoBnnx2cYCXCiKdYq5sfzzz7LBPE+vdngMIRRzD+34gupviNaqxdCzz0EGdlPvdPQQE7dE2d6q5skeRf/2KJgtxcPs7JoUOwplr0Rt2YORO45RZeWzt3Mjlx3jwLtXSDhC/LbNSNGTOck2AKChjiOGBA1EWKCnvswfr577/P2vT77MPkNpvth4/HHguOsS8v5+e+fDn7PhvRwRS/UY28PMZDB5KWxvDGRCYjg7Vnzj3XbUkSk1AmnfR0llswxR89zNTjx65dwJIlVcXQkpGTT3ZW/OnpbMBuGPXllFOcSzmXlzM3xYgepvjBiI5rr2XzkSOPpPPpjjucOxIlOtnZrGO+xx40czRqxH3PPAMccIDb0hnxzPDh/G35K3+Phz6lnBz35EpGzNQDYORIVhksLq6K5X7ySaBly+iVmF2/nmVku3RpePG1htKrF5flM2fy8zjuOKBxY3dlMuKfPfdkg5QnnuDkomVLNhbq1y86469bxwnMvHnsDXzNNcyKT0aSPnNXlUpt167g59q2ZZRLJNm0iaGEP/xAhZ+ZyU5bZ54Z2XENI5rs2sVyGK1bM3oq3GzcCLz6Kicsxx/PcFF/k+WCBewuVlJSVZIjK4vd0BJ5JRsqczfpFX9ZGS8Cp48hMzM4mzPcdO/Oi9K/IJjHw4zRbt0iO7ZhRIMHHmC4bHo6lW6vXuwlEa5ggS++AE49lSbb4mKG5B52GPDZZ1W5Gcccw6REf0SAvn1Z+TZRsZINIUhPDx1NEGnFu2ABW8QFVoEsLqapyTDinffeo+IvKmLsfnExJzUXXBCe96+oYBRWQUHVJC0/nyG5L73Ex6ostheIKvNTkpGkV/wA8PTTnGX7EOHjxx6L7LgbNvDGE0hlJbBqVWTHNoxoMGpUcJRcaSnzRcLRWO/nn4NzAwDum+Dt9i3i3GYUqP67TyZM8QM46SReiCefzF6jp5/OGcJRR0V23G7dnE1JWVnAiSdGdmzDiAYbNzrvT08Htm5t+PunpYWOvvOfVF16abDyz8piP+tkxBS/l549GWnw22/M3uzaNfJjNm8O3HBD9VC2jAxGP1xzTeTHN4xI89e/OkeppaczO7qhHHwwG60EkpMDXHFF1eNHHmEPi+zsqhDlfv1ohkpGkt656zaqwNtvs+vT1q1cbdx6K3MKDCPeWbeOk6idO2niEaHSfeGF8LQOBYCffmIkT0UFx0hNBU47DXj99eBkxKVLgV9+YW/pffcNz/ixjEX1GIbhChs2AP/+N82pe+3FQm1HH92w9ywv5yz+P/9hqOhxxzFCR4QRPBYRR0zxG4aRMFxwAYsG+hy7KSnMx1myhIlhBrFwznqyeTNw991cSl59NZeKhlFfFi8Gbr4ZuOwy+pISvcFNJFi9mmGi/tE8lZV8/Mwz7skVT1jJhhpYs4aJILt2MePv66/ZnGTSpOilmRuJw4QJnDyUldFU8c47bEQybZr7ZTriiYULnZMrS0qAWbPckSnesBl/Ddx5J7BtGy8ogLOzwkJGC8SBhcyIIfLzgWHDmMhUXl617/vvgbfecle2eKNzZzpxA0lPT+zyC+HEFH8NTJvmvBRfvz50fLJhOPH1186z+oIC4I03oi9PPLP//qyiG1jiOSMDuO46d2SKN0zx10Co7kuqVkbWqBvZ2aFXib52j7FMeTnzXMaOZTik20yaVNUnOS0NOOgg1ubZe2935Vq5krkB//wnMHeuu7LUiKrG/Na9e3d1g2eeUfV4VPmT5ZaRofq3v7kijhHHlJWpNm9e/VoCVHNyVGfMcFu6mlm+XLVNG9W8PMqbna168cWqFRVuS6ZaWqq6a5fbUpCXXuJnk56umpJC3XHdde7KBGCOOuhUm/HXwLBhwEUXMbW7cWPW9TjiCM56YoWNG4G77mIM8//9H3uXGrFHWlpVg5u8PM7ys7KYud23r9vS1cwZZzAWf9cumqaKioB33wXGj3dbMtr1Y2HFtGkT8Pe/87MpK6uKMhozBvjuO7elC8bi+GvB+vUsBrXXXrHlPPr1V+Dww/ljLCmpquf/ySdA795uS2c4UVJC39GOHQwRbtfObYlqZuVKlkUoKgp+rkcPYPbs6MsUi4wbR8Wfn199vwj9Dk884YZUoeP4LYisFrRpE5udem67Ddi+nbMLgHbY8nJGHS1Z4qpoRggyM4GBA92WovYUF7MEghNON4NkJdRnJBKboboRM/WIyFgR2SQiC/32jRSRdSLyk3c7JVLjJwOffVal9P1ZuZIzSsNoKPvv7xzIkJUFDB4cfXliFV8jmEAyM4Hzzw/9uooK/o5Hj2ZLyGgRSRv/OAD9HfY/rqpdvduUCI6f8ISKOqqp/rhh1IWUFOC116j8fd2scnLYvOj6610VLabYYw8m6GVn0xeYlcXtttuYBOrEunUsFHfmmezt3bs3MGCAc45CuImY4lfVrwD8Gan3j3WKi4M7a4Wba68NbiSRmQmcdVZwjLMR/3z0EWfg6en0N40bF51x+/Wj6fD221nX/sUX2eHKQpqrc9ZZbKD0738DDz3EDOO77w59/IUXsvzErl10BBcWAjNnAo8+GgVhnUJ9wrUB6Ahgod/jkQBWAZgPYCyAPWp47ZUA5gCY06FDhwgFO4WfxYtVe/VSTU1lWNcZZ6hu2hSZscrLVS+5RDUrS7VxY4aSHX+86s6dkRnPcI+PP+b36x8K6vGoPv983d+rslJ10iTVM89UHTSI/1dWhl9mIzTbtjE0PDC8F1Dt2DF84yBEOGdEo3pEpCOAyap6kPdxSwBbACiA+wC0VtXLdvc+bkf11JY//2Rzie3bq5J1fA0nFi4Mrg0eLtas4ft36gT85S+RGcNHQQHw4YcsXnfcccChh0Z2PIMceigwf37w/ubNGdIrUvv3uuwy9oDwtUTMyeFsNVorCIPhnx06VJWD8ad1a0YShoOYqM6pqhtVtUJVKwG8BOCIaI4faSZM4Bfpfy8tK6Ni/uKLyI3bvj3bRkZa6c+dC7RtC1x1FW2XvXqxPK6Tg9kILytWOO/fts2552wo5s5lbSD/PrgFBSwYFwdzq4ShRQvWHAokI4M2/0gTVcUvIq39Hv4NwMJQx8YjixY5/wgrK0P/cOOFykp2B9uxg7HKJSU81w8/tFoz0aBTJ+f9vsTC2vLpp87Ow5ISPpdMLFhAx/WsWe4UXXzlFSbz+QIxcnI4sRo5MvJjRzKc8w0A3wHYT0TWishQAI+IyAIRmQ/geAA3RGp8Nzj8cGeHlwhwyCHRlyec/PSTc4hoQQHw0ktRFyfpuP/+YAXv8bAmTF3MPI0aVW9C7iMjI3SUWKJRUsIVcs+eLJN9wglMRtu2rfpxGzaw93XHjozMeeWV8NwgioqAN99k4b633uJ3eOmlwNNPc/LYtGnDx9gtTob/WNvcqtVTV/LzVdu2VU1Lq3LUZGWp9u4d/86z779nrRYnZ9TRR7stXXLw9tt0/AGqLVuq/uc/db+uNm0Krj/lcxRv3BgZuWONO+4IdpRnZKiedVbVMVu28DNOT69eV+mmmxo29sKFqk2b8reUmcn3PPVU1nKKBAjh3K1tdM5wAI0ACIAxAH4EcFJtXhuOLV4Uv6rq+vWqF1zAL7ZpU14oBQVuS9Vwysp4Pk5FxuoTWWLUn4YWR5s6lddno0bc8vJUp0wJj2zxQIsWzhOY9HTVkhIec889nLQFHpOZWf8bZGWl6n77qYoE33SfeSZ85+dPKMVfW1PPZaq6E8BJAJoDuBTAQ+FefSQCrVsDr74K7NwJbNnCmNy62GDnzweuvJJL0aefDq794RZpaVyW+pJTABbHOvJIRokY0aOh0WH9+zOq5O23uW3axOstWQjs3OWjsrKqSc6MGc7HZWaybld9+PVXBnoEmosKC6NvLq1tFQmfFfEUAC+r6s8idbEsGrXhnXeAIUNog6yoAL76CnjySUZbNGnitnRM5Fm5kje2jRv5+KSTIhemakSOrCzgr391Wwp3OOUU/tYCSyx07Vo1SevcGfjmm+CItfJyOmDrQ3l5aH+M74YTLWr7k50rIp+Cin+aiOQBsCC+MFJWxpl+YWHVBVlYCKxdS+UfK7RqxWbho0Zx5mhK34g3Ro2iA9Wn5LOyGF0zZkzVMddfH1z2JD2dlUrrW6F3332dHbfZ2cDFF9fvPetLbX+2QwGMAHC4qhYCSAfNPUaYWLjQuchTSQnw3nvRl8eIL+bNo2nwnXdCmzIM0q4du4j961/AOecAd9wBLFtWPRnx0EMZptyiBW8QmZkso/3xx/UfV4Tm0txcKnuA/x9yCEs6R5PamnqOAvCTqhaIyIUADgMQQ/PQ+KdRo9DLvVgw8zixaBHw1FOsT3LCCVyxNG7stlS7p7CQCnL5ci7vTz/dOcQxHqiooPL65BOaJdLTqaS++AI48MDqx65fD0ydymNOO42FxZKVJk3YBKcmBg5k1c3ffuN13axZw8ft2ZPv99prLNLWpw9NT6HKOkcMJ49v4AbW1hEAh3r/Hw7gy9q8NhxbPEX1NIRu3VjjJzBq5t133ZYsmI8+YjSCT97sbNV27SJXlyhc/Porw/Rycih3bq5qly4M34tHXnjBOTyzS5fqoZ6PP84olZwcnnN2tuoHH7gmthEl0MConnLvm5wO4ElVfRJAXvhvQ8nNhx+yrk9uLlcAWVlcAg4a5LZk1amoYCSPvz+iqIjRIQ8/7K5su2PoUNYZ8pUsyM/nimXECFfFqjcvvuicLb5uXVUbzoULac4oLuZ55+fz+xo8ODhpyUgOaqv4d4nI7QAuAvCxiKSCdn4jjLRvz/K3M2YwS3DVKuDBB+uWmRkNVq50VjalpcAHH0RdnFpTUsJIqcBIjbIymn7cZsMG2urrUnsnVOlvkarnXn/duUxDaipLPRvJR20V/7kASsB4/j8AtAUwKmJSJTEibOg+cCDQsqXb0jiTlxd//ggfoW6ibkYn7drFBhydO7PiaYsWrOleGy66qMpR6E/jxqzdD/CG51RIr7LSuTqkkfjU6nL3KvvXADQWkVMBFKvqhIhKZsQsrVvz5hTYSzQnJ7a7MmVmMvcg0JGWkeFuG8GLLqpKGNq5k+aYf/6zdqun//s/RoXk5vJxVha/hzffrLqZDRrkfHOorKRj0Ug+aqX4ReQcAD8AOBvAOQC+F5GzIimYEdu8/TbjmXNyOLvMzGST9wsucFuymhk9GmjThquWtDQqzP32Ax54wB15tm5lRE7gzLuwsHb+kuxs4L//ZZTIDTcwRPHXXxkt4qNXL3Z7ysnhiic1la+7//76JyPVRLSTkYy6U6tGLCLyM4ATVXWT93FzANNVNSptOOKlEUuyocqqnevWsbphq1ZuS1Q7yspo216+nPHabmUfL17MG86bbzrncHTsyNC/cKDKG8TEibxJX3ABk5HCyfjxdCJv2MAGMffcw+qXhnuEasRS2zj+FJ/S97IVUa7lb8QeIkC3btzc5PffmWzjs5X37FmzQzw93f1IqXffZbZmKPt7airQt2/4xhNhM+/evcP3nv68/jpLGPsc05s2ATfdxHGvuioyYxr1p7Yz/lEADgHga7lxLoD5qnpbBGX7HzbjN0Lx1lusZV5RwZm8x8MORuPGxV40lI/SUs6Id+50fj49nSaoefPYVD0e2HtvmpgCadWKKwDDHRrUelFVbwHwIqj8DwXwYrSUvmGEYtcu5hMUFVGZqtIxOnEiMG2a29KFZt680M9lZdFX8vPP8aP0Aa66nPjjD35Pu6O0lLVy+vVjVvHHH7vTFStZqK2pB6o6EcDECMpiGHVi+vTgyCKAyv+111hELhbJzQ3tAD36aOA//4muPOFg771Z/yYQEYYlDx0KPP648/dVXs6SHz/+WJVYN3MmMGwYC6olAt99x1pKGzfyxnb55VWRWG5Q44xfRHaJyE6HbZeIhFioGkZ0qKm+iZOCiRUOOIDJeoGmqJwc4Npr3ZGpoTz8sHPIqCpXZGPHArfe6vzaSZO4CgpsAP/MM0xijHdefJE3tjffBD7/nA7wHj3c7bVRo+JX1TxVbeSw5alqknToNGKVE05wjobJyYl+mdu6IAJMnswqkXl5VQ23hw1jwbh45PTT6WD/y1+cny8sBF54wTlh7OOPnZVgWhqLzcUzBQUMsy0srDJdFRXRNPbCC+7JZZE5Rtzi8bDUgsdDZZ+ZSQU6aBBXA/4zyGhRWekcpRPIPvtwNjtpEm3bK1bQrBGrDunacPrpLDkSqupnRYWzQ7tZM+fqqCLAnnuGV8ZoM2eO87kVFdEX5Ram+I245uST2c7uiSeA227jLHriRNpRW7QAnn+exy1YQEfwMccwK3bz5vDKsXo1ZcnI4A1o0CDac2siJYUlGs4+OzKJVG7RIyiGhDRqFNyIpLiYxzuZ7dLTY9dPU1v22CO0P6dFi+jKUg2nkp2xtiVSWeYdO1T//NNtKRKPykrVAw4ILmvt8aiOGlW9hHRmpmrz5qpr1oRn7IIC1Vatqo+dlqbauXNV8+5kYu5cft7+TcU9HtUJE6of9+qrVU3fMzJUU1JYMjovT7VNG9V584Lfu7JSdf581Vmz4uOzraxU3X9/nlvgdTljRuTHR4iyzK4r9dpsiaD4f/9d9dhjVdPTeZF366a6YEHNr1mzRvWuu1TPP5911wsKoiJqXDJvXlWN/cAtOzt4X1qa6tCh4Rn75ZdDj52SonrKKfz+44nSUtXbb1dt0oSfVZ8+qj/9VPvXz5unOmAAex8ceaTqlCnBzwf2ERChwv/2W9WKiuD3XLJEdZ99+Fk3akTZPvywIWcZHX77TXXffavkzsriZCQamOJ3kbIy1Q4dgmejTZqobtvm/JpvvuGFkpGh/2vI0qmT6tatURU9bpg+XbVx49DK12l/mzbhGfuWW5zf33/8Vq1UCwvrd169eqk2bUrl++WX4ZF5d5x3XvANMzeXSiwcDB3q/L3k5qp+913w8WVl/Az9VxG+mfPy5eGRKZJUVqrOmaM6bVro33wkCKX4zcYfBaZOZcOLwAiU0lLg1VeDj1dlxcaCgqo66gUFrIlz3321H3fHDoaPLVxYf9njhR49nGvOZ2WFdpiGq/XgoYfWHJNdWcmolbrW/J88meW5v/2Wxdy+/pp+hOnTGybv7li7lpVBi4qq7y8pqX256N2xfr2zEzwlxdn/Mn06fwMakNRVVsZwyVhHBOjenXWhYqF0uSn+KLBqlXPDjMJCRnMEsnYtMx4DKS2tfSTAQw8xXX7QIODII9lbNpFT5xs35k3R46nal51NZ++JJ9Lp6k84S0ifeSadljXlDuTnsyhbXfCFAfpTWMgaOJHkl1/ooA6krIxJVuFgwIDq35WP0lLWWgpk40bnTN6yssS+riNFxBS/iIwVkU0iEjTfFJGbRURFJAzti2Ofww5zjlrIzaVSDiQ7O3RIoNOPJZApU1iet7iYs/7CQs76oxUjvmwZG6/37Ml68eGqMLk7brqJ4ZEDB3Lsu+9mON2rr7J/gMfDG0RWFiN8hg5t+Ji//spSz8OH8/MNvMH4yM2tWzXMykrnSQFQ9xtIXenSxTnePi2NE4hwMGQIk9iysqr25eQwyat5cyrz0aMZrTVgAL8rp1j/nByugow64mT/CccG4BgAhwFYGLC/PYBpAFYDaFab94p3G39lpeoxx9Cp47NNZmSwIXZxsfNr+vRxjlB58sndj3fiic625uxs1RUrwntugcyaRX+ET/b0dEZp/PxzZMcNpKyMzsm8PMpx8MGq48erfvqp6h9/hGeMu+/md+prYu7x0Nl4wAFVvhmfI7lDB9Wiorq9f9Omzt9j27bhkb8mzjzT2cYfzutn507VBx9U7dGD1+ykSdz/3HP8TLOzg236gdfzYYfFR3SPW8AN5y6Ajg6K/12w0NuqZFH8qvzR33UXf7QtW6r+/e81h3WuXcsIhrw8/uCys1XPOUe1vHz3Y3Xt6vxDadRI9fvvw3dOTnTr5jz2ccdFdtxArrgiOGrE46lbZEpNzJoV/P4+J/zq1apDhvD/7GzVc89V3bCh7mP4wlADz+HZZ8NzDjVRXKx64408BxHVI45QnT078uOuWOEchRXoLO/USfXxx+vnME8mYkLxAxgI4Env/zUqfgBXApgDYE6HDh0i+uE0lJUrVQcO5I+yWTPVO+4IzyykokJ15kzGPy9ZUvvX3XUXY9UDfzB5eXWfddaF8vLQM7SMjMiNG8jWrdVXV/4K4+yzwzPGNdc4n2tenurbb4dnjMpK1Xvuqbrx5+WpPvQQ90eTaI53//1cJdak+AHVm2+OnkzxTCjFH7VSViLiAXAngJNqc7yqvgiWgkaPHj0c3Dr148svgUceoQO1b1/aFFu3rv/7bd4MHH44sH077bKFhaxCuHAh8OGHDZPVl9lZV66/HpgwgQ6x4mJGFGRnA08+Wd2mGm5SUjhOoEMSYNZmtFi1irb24uLq+ysrwxfhVFbm7GwEwtd6UIRZxiNGMKonVGmDhrJtGzuSlZbSXh6YRRzNMhJlZc71l/zJzQ2fryFpcbobhGuD34wfwMEANoEz/VUAygH8DqDV7t4nXKael1+uvnTOyOAMfe3a+r/nvfc6zy6zs1WXLg2L2PVi2zbOno4+miaib7+NzrjDhwcv1T0e1ZEjozO+Ks891Iz//PPDM8b06c5JW1lZsZNrUVGhOnWq6rBhqrfdprp4cfAxH37I7ys3l+eTlaX62GPRl9WHU2KX/1Zff0myglgw9QQ8twpRtPGXlDgn+KSlcdleX0491fkCbdRI9d13Gyx23FFcrHrWWVQgjRvz78UX09kaTa691tk+vnBheN6/slL1ssuqShOkp1OBjh0bnvdvKBUVqqefToXuu86zs1XHjKk6Zts2ZyWbnc2yCG5x882UKyWFW2oqTZc5OaqDB4fPOZ8MRF3xg20aNwAoA7AWwNCA56Oq+BctqvoRBG57712791i3jjPaAw9U7d9f9fPPVUeMqB7B4a9koh3JEkusWUP/xPr17oxfXq76wAOqLVpQKffsGX7HdmWl6n//y9n0PffEVgbp++87r0iys6syRydMcP5NpKbynNzkhx94AxgxInwO+WQklOKPmI1fVQfv5vmOkRrbiaZNnZOogNrZ+NetY4bmzp18n0WLgK++AkaOZLKLf9ZoZiZj9w85JCyixyXt2nFzi9RU4PbbuUUKEaBXL26xxltvOZelTktjNvegQVXtKgOprHSO448mhx/OzYgMSZO527IlcPzxwQk2Hg9wyy27f/0DDzAZyv/mUVjIRKkZM3iRpqRQ6Z97LpOoDMMtPB5np6xIlYP/5JOdHam+hvVG4pI0ih9gh6BjjuGF36gRL/B77mGm5+747DPnaA1VRrL88ANvBAUFwPjx7KpkGG5x2WXOrRBF2NAcANq0AR58kMelpvK5nBzg/PPZ+9cIprIydDRXPJFUir9JEyrwZctY9GnTJuDmm2v32lDmoNJSppgDnO3X1AfWMKLF0UczVDkri8rc1+Jx0qTqdXiuvx6YPZu/g+HDgWnT2BIwnjuBRYIlSxhanZ7OCePllwO7drktVf0RjYPbV48ePXTOnDlRH1e16gfw8cfAOedUj1HPyGAuwNSpURct5pgyBbj3XsbQ9+hBE5jFWrvPmjWc7OTlhS6MZtTMpk3AvvvSv+dTl5mZvM6/+cZd2XaHiMxV1aCeaAk546+sBP7zHzZ+btcOuPrq3bfB8+edd4DOnTl7b9eOPVEHDKAyy8mhmSgrCzj2WJqPkp0JE9g+8Pvv+TlPmcIZZ7gqORr1p317mn3OPtuUfm0pK2OF0i1b+Pill+js9p8jl5QA8+bF8TXuFOoTa1tdwzkvvbR6fHJ6Optu1KYBwvvvO8d/P/88ny8oYEOFcLXti3cqKpgE5xQme+KJbktnGHVj3Dg2SMrNZe7AwIHcnK7vvDzV1193W+KaQbI0Ylm9mrNwf5NMWRnT0seM2f3rb7/duQb63Xfz6/Z42FDBzVDFWGLLltC2zrlzoyuLYTSEL74ArrmG5Vfy8zmrnzYNWLrU2VFeUQEceGC0pQwPCaf45851roleVATMnFl935o1wJ13MnTtySdpwwtVO37zZucOTw2hvNz9eOmG0rhxaId2YM0Xw4hlHnkkeNJXUsLJZGYmw7V9ZGWx50O85uoknOLv0ME5Njk9nQ0mfMyaBRxwAPDoo8B77wF33AHsvz9f70Tz5qGbbNSV7dsZMufxcDvySGD+/PC8d7TJzGTTlUD7sccD3HWXOzIZRn1Yvdp5f2YmMG4c0L8/dUCjRsAVV7CwXbwSteqc0aJ7dyr4RYuqJ1ulp7MbFECTzZAh1Tv6FBZyRn/88czS9b/zezyMWAlHiJsq+27+/HOVfD/8APTpQ4dSq1YNHyPajBrFm+3o0fyMMjLoCD/7bLclM4za07cvsHx5cIZ/eTnbd0arg100SLgZvwjw6adU4JmZXJLttRcbV++zD4/ZssXZpFNeToU8fjyw995c2rVvDzzzDGe14WD2bLbOCzQblZYyeiAeSUsDnnqKn+vSpQx/891kDSNeuO02hr369072JXkmWkRUws34AZplpk2jQ7eggLZm/9l6TTXpPR7grLO4RYIVK6rbCn0UFwMLFkRmzGjhM10ZRjzSrh1DNO+9l2VYWrXizeCMM9yWLPwkpOL3scce3ALJy2Pa+vTp1Zd12dn06keSgw8OXR/liCMiO7ZhGDXToQNNlolOwpl6asv48Uzwys3ljSAri0laN9wQ2XEPPhjo3bv6qiMlhYp/6NDIjm0YRjAFBcBzz7G44j/+wWi/RCepSzaoMrpn9WqgWzdgv/3CPoQjxcUs5zx6NP/v3x/497/pi6gtf/xBs9E++8SnQ9gwYoEtW1hZd/Nm3gAyMhgI8sknnKC5ye+/0x/YpQt9jvUhVMmGpFb88UhZGQtEvfUWVw0lJfRHjB0bmX6sblJWBrz2GresLDrYTz3VCogZ4WP4cOD554ODLTp1AlaudOdaKysDLrqIPbt9vT769mUpGadEspoIpfgT2safiNxzDy+AkpKq5K+JE+mYevBBd2WrC2VlvLBnzqTsQ4ZUr4BaUcF68bNmVTUUmTkTuPRS4OmnXRHZSEDee885MXPDBoZ1u5Ghf++9rKJaXMwNoLP5ppuAZ58Nzxg2448z9tyT0UqBNGrERjHxQGEh8xaWLWMuRVYWs3+nTGG/BIDht4MHV8+1AHjsggVVobkN5ZtvmGi2eDFNfffey/K7RnLwl78wfyaQjAxg/Xp27os2zZoBW7cG78/O5iSoLquQpKrOmcjs3Om8Pz8/fhpEPPEE65v7lHpxMS/owYNZWRVgqetApQ/QEf755+GRY8YMJtN98QVzD77+mg5+K7OdPAwbFhyCnJoKHHWUO0ofcL7uAf5OnCIC64Mp/jgjVB/S7t3jx/b9+uusnRTIjh1MAAM463EqkZGaylVPOLjxxmA5CgvZnMRIDq69lh34srMZ4ZebS0eqm+XW+/Rx/i137149uawhmOKPM55+mj0BfIXRUlP5+Jln3JWrLvh3gPKnsrLquSFDnIu/paZyVh4OFi1y3r9sWdXKw0hsUlOp5OfNo5P34485+QjVcS8aPPUUQ8x9E5/0dN6QwmXfB0zxxx09erD5w5AhnAFccgkrksZT8tdVVwUvr0UYSeELW2vVqqp3caNG/NuyJbtJ1TWyIRQtWjjvb9bMObvaSFz22w+44AL6mNxeOe+/Pycl111Hea6+mkUcQ63264M5d42oU1HB6qSTJ9MvkZZGZf7VV7T1X345L/TUVKbLX3gh7a1HHhnensZPPw2MGBFckG/kSJqBpkwBvvuOkR2DBztngRtGLGNx/EbMMX8+8O23XFaffDIdrAccUL2xS0YGcNhhVMDhRhV44AHgoYdo2hFhyNyttzKyZ+lSOto8Ht5w3nsP6NXL6hEZ8YMpfiPmufNOZjAHNqfJyWHETbdukRm3tJQ3nebN6WO47z7eEHwx1D58JafPPpv24JycyMhjGOHCwjmNmGfRIueOZKmpLE8RKTIyaM7xOZZfeSVY6QNcIZSUAO++S9OPYcQrpviNmKFnT2fHbVlZdFvc7c6PUFxMJ/PatdGRxzDCTcQUv4iMFZFNIrLQb999IjJfRH4SkU9FpE2kxjfijyuuoPnEP6ImO5vdj6JVQA8ALrts95FDmZnJUcXRSEwiOeMfB6B/wL5RqnqIqnYFMBnAPyM4vhFnNG0KzJkDDBrE8M0WLYCbb2ZtomgyfDhw9NG8CYUK7SspYbq/YcQjESvSpqpfiUjHgH3+BQdyAMS+Z9mIKnvtFX1FH0hGBtt3/ve/LM/7+OM07/iSujwetpa08E4jXom6jV9E7heRNQAuQA0zfhG5UkTmiMiczZs3R09AwwBn+r17s2n8Tz8Bf/sbVyT77staQw8/7LaEhlF/IhrO6Z3xT1bVgxyeux1Alqrevbv3sXBOwzCMuhOL4ZyvAzjTxfENwzCSkqgqfhHp4vdwIICl0RzfMAzDiKBzV0TeAHAcgGYishbA3QBOEZH9AFQCWA3g6kiNbxiGYTgTyagep9zGMZEaz0hstm4FbrmFWbMAcM45wCOPhK82v2GEm+3bgfffZ/Okv/41tsJ/rVaPEfOUlQEHHgisWsX/AYZcduoELFwYvuYUhhEupk9nZVkAKC9nUuKVVzI0OJpln2PRuWsYteKjj9j82qf0ARZWW7eOpZMNI5YoLmYSYkEBt5ISdnobPZrtPmMBU/xGzLNwIX9AgRQWsvG6YcQSn3/uPKsvKABefrnm1/7yC7uA/fZbZGTzYYtkI+bp0oXlEwKbUOfk8DnDiCVqaoheXu68v6CASYLffEMzZkkJcNppwGuvsfViuLEZvxHz/O1vbL/oXzUzNRVo3LjKjmoYscLxxzsr+JwcdpNz4vrr2XOiqAjYsYPmosmTmTkeCUzxGzFPVhYwaxardKalcTvpJHbl8jWkNoxYITeX/aKzs3l9ilDpDxwIDBgQfHxlpXMPiKIi4LnnIiOjmXqMuKB9e2Dq1KqZlEXyGLHMWWcBRxwBvP46Z/ADBrDiq5Ptv7y8euCCP4HmzXBhP58EoqKC1SRnzaKiPO88mkgSCVP4RrzQoQMwYsTuj8vIALp2BX78sfp+EZqNIoH9jBKEwkI2CF+ypKpB+K23Al9+CRx6qNvSGYZREy+8QCVfUsLZf2YmTUWPPx6Z8UzxJwiPPsrQRp+dsLCQfwcPBhYvdk8uwzB2T48e/P0+9RQwfz7NRH//O9C6dWTGM8WfIIRqEP7bb2wR2L591b4//wRmzuSqoF8/c5DWlfx8YPZsoEkTLtGjmYlpJC4dOwKPPRadsUzxJwg1KR//HrbPPQfceGOVsk9NZfZrz56RlS9ReOklht6lpdGn0qYNnc577+22ZIZReyycM0G49NLgBuEi7BjVti0f//wze9gWF7Nw1M6dwLZtwMkn07Zo1MwPP1DpFxbysysoAFasYJhpHJS8Moz/YYo/QbjxRtoFc3I4G83NZavAt96qOmbMGGdzUEUFMG1a9GSNV555hrHV/qgCmzcD33/vjkyGUR/M1JMgZGbSbv/VV1RC7dox49V/FbBjR1XD8EAiFS+cSGzc6DyzT0lh2WjDiBdM8ScQIsCxx3JzYtAg4L33gpV8WRmdvEbNnHEGa6n4IqZ8lJYCRx3likiGUS/M1JNEnHoq0Ls3zUEAbxQeDzByJNCypauixQWXXMIeAP6rKN/nZw1hjHjCZvxJRGoqCz998AHwzjv0A1x+uUX01BaPh2a00aOBiRPpQ7n2WlstGfGHdeAyIk55OW3ge+4ZmRKzhmE4Yx24DFd46imgeXMmp+y5J80ioRzMhmFEBzP1GBFj3Djg9turO0NHjeKs/847XRPLMJIem/EbEeO++4IjYAoLqfzjwMJoGAmLKX4jYqxf77w/P98yhQ3DTUzxGxHjoIOc97duzYQzwzDcwRS/ETFGjWIIpD8eD0tIW0VLw3APU/xGxDjuONYA6tMH2GMP1hyfOBE491y3JTOM5CZiUT0iMhbAqQA2qepB3n2jAJwGoBTASgCXqur2SMlguE/v3qwfZBhG7BDJGf84AP0D9n0G4CBVPQTAMgC3R3B8wzAMw4GIKX5V/QrAnwH7PlXVcu/DWQDaRWp8wzAMwxk3bfyXAZga6kkRuVJE5ojInM2bN0dRLMMwjMTGlcxdEbkTQDmA10Ido6ovAngRYK2eKIlmuEBFBYvHTZvG8g6XXsoSD4ZhRIaoK34RuQR0+vbTeKgQZ0SU0lK2LvzxRyZ2ZWQwDPTNN4GBA92WzjASk6iaekSkP4DbAAxU1cLdHW8kPhMmAHPmVDWHKS1le8OLLuL/hmGEn0iGc74B4DgAzURkLYC7wSieTACfCTN4Zqnq1bt7r1+2/oLjxh0XKVENF/lpIVB4TvD+glTgyOeAxo2jL5NhJDoRU/yqOthh95hIjWfEJympzvsV7GVrGEb4sUYshqu8/z7NOgUF1fe3aQOsWWPK3zAagjViMWKSM84ALr4YyMpiHZ+8PJZ3mDzZlL5hRAprxGK4igjw7LPADTcAX3zBPrannMIbgWEYkcEUvxETdOnCzTCMyGOLacMwjCTDFL9hGEaSYYrfMAwjyTDFbxiGkWSY4jcMw0gy4iKBS0Q2A1hdz5c3A7AljOLEC8l43sl4zkBynncynjNQ9/PeS1WbB+6MC8XfEERkjlPmWqKTjOedjOcMJOd5J+M5A+E7bzP1GIZhJBmm+A3DMJKMZFD8L7otgEsk43kn4zkDyXneyXjOQJjOO+Ft/IZhGEZ1kmHGbxiGYfhhit8wDCPJSGjFLyL9ReQXEVkhIiPclicSiEh7EZkpIktEZJGIDPfu31NEPhOR5d6/e7gta7gRkVQRmScik72Pk+Gcm4jIuyKy1PudH5Xo5y0iN3iv7YUi8oaIZCXiOYvIWBHZJCIL/faFPE8Rud2r234Rkb/WZayEVfwikgrgPwBOBnAAgMEicoC7UkWEcgA3qer+AHoC+D/veY4AMENVuwCY4X2caAwHsMTvcTKc85MAPlHVvwA4FDz/hD1vEWkL4DoAPVT1IACpAM5DYp7zOAD9A/Y5nqf3N34egAO9r3nWq/NqRcIqfgBHAFihqr+qaimANwGc7rJMYUdVN6jqj97/d4GKoC14ruO9h40HcIYrAkYIEWkHYACA0X67E/2cGwE4Bt7e1apaqqrbkeDnDfYNyRaRNAAeAOuRgOesql8B+DNgd6jzPB3Am6paoqq/AVgB6rxakciKvy2ANX6P13r3JSwi0hFANwDfA2ipqhsA3hwAtHBRtEjwBIBbAVT67Uv0c+4MYDOAl70mrtEikoMEPm9VXQfgUQC/A9gAYIeqfooEPucAQp1ng/RbIit+cdiXsLGrIpILYCKA61V1p9vyRBIRORXAJlWd67YsUSYNwGEAnlPVbgAKkBgmjpB4bdqnA+gEoA2AHBG50F2pYoIG6bdEVvxrAbT3e9wOXCImHCKSDir911T1Pe/ujSLS2vt8awCb3JIvAhwNYKCIrAJNeH1F5FUk9jkDvKbXqur33sfvgjeCRD7vEwD8pqqbVbUMwHsAeiGxz9mfUOfZIP2WyIp/NoAuItJJRDJAR8gkl2UKOyIioM13iao+5vfUJACXeP+/BMCH0ZYtUqjq7araTlU7gt/r56p6IRL4nAFAVf8AsEZE9vPu6gdgMRL7vH8H0FNEPN5rvR/ox0rkc/Yn1HlOAnCeiGSKSCcAXQD8UOt3VdWE3QCcAmAZgJUA7nRbngidY29wiTcfwE/e7RQATcEogOXev3u6LWuEzv84AJO9/yf8OQPoCmCO9/v+AMAeiX7eAO4BsBTAQgCvAMhMxHMG8AboxygDZ/RDazpPAHd6ddsvAE6uy1hWssEwDCPJSGRTj2EYhuGAKX7DMIwkwxS/YRhGkmGK3zAMI8kwxW8YhpFkmOI3jAC8FTCv8f7fRkTedVsmwwgnFs5pGAF4ax5NVlaDNIyEI81tAQwjBnkIwN4i8hOYOLO/qh4kIkPA6oipAA4C8G8AGQAuAlAC4BRV/VNE9gZLgjcHUAjgClVdGu2TMIxQmKnHMIIZAWClqnYFcEvAcwcBOB8sgXs/gEJlwbTvAFzsPeZFAH9X1e4AbgbwbDSENozaYjN+w6gbM5V9D3aJyA4AH3n3LwBwiLdKai8A77C0DACWGDCMmMEUv2HUjRK//yv9HleCv6cUANu9qwXDiEnM1GMYwewCkFefFyp7IfwmImcDrJ4qIoeGUzjDaCim+A0jAFXdCuC/3qbXo+rxFhcAGCoiPwNYhARs+WnENxbOaRiGkWTYjN8wDCPJMMVvGIaRZJjiNwzDSDJM8RuGYSQZpvgNwzCSDFP8hmEYSYYpfsMwjCTj/wG7vwIMtzACnQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from hyperopt import plotting \n",
    "\n",
    "plotting.main_plot_history(trials)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "episode: 10\n",
      "episode: 20\n",
      "episode: 30\n",
      "episode: 40\n",
      "episode: 50\n",
      "episode: 60\n",
      "episode: 70\n",
      "episode: 80\n",
      "episode: 90\n"
     ]
    }
   ],
   "source": [
    "opt_agent = run(final_params, return_agent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plt.figure()\n",
    "plt.plot(range(len(opt_agent.rewards)), opt_agent.rewards)\n",
    "plt.title(\"Reward vs Iteration\")\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visualization script. has about 50/50 chance of crashing the notebook, so run at your own risk!\n",
    "test_agent(basic_agent, params['env_name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_agent(opt_agent, final_params['env_name'])"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "name": "pytorch-gpu.1-6.m59",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/pytorch-gpu.1-6:m59"
  },
  "kernelspec": {
   "display_name": "Python [conda env:root] *",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}