a2c_meta-bandits.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow.keras.layers as kl\n",
    "import tensorflow.keras.losses as kls\n",
    "import tensorflow.keras.optimizers as ko\n",
    "from pathlib import Path\n",
    "import ruamel.yaml as yaml\n",
    "from tqdm.notebook import tqdm\n",
    "%matplotlib inline\n",
    "\n",
    "print(\"TensorFlow Ver: \", tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 1234\n",
    "tf.random.set_seed(seed)\n",
    "np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Eager by default!\n",
    "print(\"Eager Execution:\", tf.executing_eagerly())\n",
    "print(\"1 + 2 + 3 + 4 + 5 =\", tf.reduce_sum([1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class dependent_bandit():\n",
    "    def __init__(self, difficulty):\n",
    "        self.num_actions = 2\n",
    "        self.n_timesteps = 100\n",
    "        self.difficulty = difficulty\n",
    "        self.reset()\n",
    "        \n",
    "    def set_restless_prob(self):\n",
    "        self.bandit = np.array([self.restless_list[self.timestep],1 - self.restless_list[self.timestep]])\n",
    "        \n",
    "    def reset(self):\n",
    "        self.timestep = 0\n",
    "        if self.difficulty == 'restless': \n",
    "            variance = np.random.uniform(0,.5)\n",
    "            self.restless_list = np.cumsum(np.random.uniform(-variance,variance,(150,1)))\n",
    "            self.restless_list = (self.restless_list - np.min(self.restless_list)) / (np.max(self.restless_list - np.min(self.restless_list))) \n",
    "            self.set_restless_prob()\n",
    "        if self.difficulty == 'easy': \n",
    "            bandit_prob = np.random.choice([0.9,0.1])\n",
    "        if self.difficulty == 'trivial': \n",
    "            bandit_prob = np.random.choice([1.0,0.0])\n",
    "        if self.difficulty == 'medium': \n",
    "            bandit_prob = np.random.choice([0.75,0.25])\n",
    "        if self.difficulty == 'hard':  \n",
    "            bandit_prob = np.random.choice([0.6,0.4])\n",
    "        if self.difficulty == 'uniform': \n",
    "            bandit_prob = np.random.uniform()\n",
    "        if self.difficulty != 'independent' and self.difficulty != 'restless':\n",
    "            self.bandit = np.array([bandit_prob,1 - bandit_prob])\n",
    "        else:\n",
    "            self.bandit = np.random.uniform(size=2)\n",
    "        \n",
    "    def step(self,action):\n",
    "        #Get a random number.\n",
    "        if self.difficulty == 'restless': \n",
    "            self.set_restless_prob()\n",
    "        self.timestep += 1\n",
    "        bandit = self.bandit[int(action)]\n",
    "        result = np.random.uniform()\n",
    "        if result < bandit:\n",
    "            #return a positive reward.\n",
    "            reward = 1\n",
    "        else:\n",
    "            #return a negative reward.\n",
    "            reward = 0\n",
    "        if self.timestep > self.n_timesteps - 1: \n",
    "            done = True\n",
    "        else: \n",
    "            done = False\n",
    "        return reward, done, self.timestep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "bandit = dependent_bandit('uniform')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "bandit.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, False, 15)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bandit.step(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(tf.keras.Model):\n",
    "    def __init__(self, num_actions, batch_size=1, n_timesteps=None, n_features=4, name='meta_policy'):\n",
    "        super().__init__(name)\n",
    "#         Having a stateful LSTM means that you will need to reset the hidden state \n",
    "#         in between batches yourself if you do want independent batches. \n",
    "#         The default initial hidden state in Tensorflow is all zeros.\n",
    "        self.lstm = kl.LSTM(\n",
    "            48, name='hidden', \n",
    "            stateful=True, \n",
    "            time_major=True, # ['time', 'batch', 'features']\n",
    "            return_sequences=True, \n",
    "            recurrent_initializer='zeros'\n",
    "        )\n",
    "        self.lstm.build((n_timesteps, batch_size, n_features)) # set batch size, must be done with stateful lstm\n",
    "        self.policy = kl.Dense(\n",
    "            num_actions, name='policy'\n",
    "        )\n",
    "        self.value = kl.Dense(\n",
    "            1, name='value'\n",
    "        )\n",
    "\n",
    "    def call(self, inputs, **kwargs):\n",
    "        inputs = tf.cast(inputs, dtype=tf.float32)\n",
    "#         print(inputs)\n",
    "        output = self.lstm(inputs)\n",
    "        value = self.value(output)\n",
    "        policy = self.policy(output)\n",
    "        return tf.squeeze(policy, 1), tf.squeeze(value, (1, 2))\n",
    "\n",
    "    def predict_action_value(self, obs):\n",
    "        # Executes `call()` under the hood.\n",
    "        policy, value = self.predict_on_batch(obs)\n",
    "        actions = tf.squeeze(tf.random.categorical(policy, 1), 1)\n",
    "        return actions, value "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = dependent_bandit('uniform')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([0 1], shape=(2,), dtype=int64) tf.Tensor([0.0655949  0.11440822], shape=(2,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Verify everything works by sampling two actions.\n",
    "\n",
    "model = Model(env.num_actions)\n",
    "\n",
    "action = 0\n",
    "reward, timestep = 0, 0\n",
    "# reward, done, timestep = env.step(action)\n",
    "action = tf.one_hot(action, 2)\n",
    "observation = tf.concat([\n",
    "        [[reward],[reward]], \n",
    "        [action, action],\n",
    "        [[timestep], [timestep]]], 1)\n",
    "observation = tf.expand_dims(observation, [1])\n",
    "# print(observation)\n",
    "action, value = model.predict_action_value(observation)\n",
    "print(action, value)\n",
    "# print(action.shape, value.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<tf.Variable 'Variable:0' shape=(1, 48) dtype=float32, numpy=\n",
      "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],\n",
      "      dtype=float32)>, <tf.Variable 'Variable:0' shape=(1, 48) dtype=float32, numpy=\n",
      "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],\n",
      "      dtype=float32)>]\n",
      "tf.Tensor([0], shape=(1,), dtype=int64) tf.Tensor([-0.07547456], shape=(1,), dtype=float32)\n",
      "[<tf.Variable 'Variable:0' shape=(1, 48) dtype=float32, numpy=\n",
      "array([[-0.00159882,  0.03399213, -0.02740747, -0.0020262 ,  0.03342454,\n",
      "        -0.00533516,  0.03278727,  0.04857245,  0.07296358, -0.00032561,\n",
      "        -0.03299318, -0.00362633, -0.02939189,  0.04791987,  0.03643053,\n",
      "         0.01858252, -0.06217662,  0.04763798,  0.00632009,  0.04168138,\n",
      "         0.01634462,  0.01474927,  0.02735287,  0.02924447, -0.05206422,\n",
      "         0.09380703,  0.01016161, -0.05095945, -0.01069589,  0.03887622,\n",
      "        -0.02648488,  0.05778573,  0.03428278, -0.0543198 ,  0.06985292,\n",
      "         0.00983854, -0.00919302,  0.03387121,  0.00224946,  0.08177292,\n",
      "         0.01285525,  0.070329  , -0.04299409,  0.05004763, -0.08233696,\n",
      "        -0.02509946, -0.02245436, -0.0175198 ]], dtype=float32)>, <tf.Variable 'Variable:0' shape=(1, 48) dtype=float32, numpy=\n",
      "array([[-0.00269418,  0.07320723, -0.05145141, -0.00341433,  0.07372796,\n",
      "        -0.00921325,  0.05800694,  0.10190619,  0.13317174, -0.00060681,\n",
      "        -0.06572777, -0.00668358, -0.05334778,  0.09796429,  0.08457458,\n",
      "         0.04081972, -0.13193266,  0.08716682,  0.01195809,  0.08556528,\n",
      "         0.03427926,  0.03304701,  0.05238006,  0.05748235, -0.11259554,\n",
      "         0.22089079,  0.01956265, -0.10576647, -0.02086213,  0.07374801,\n",
      "        -0.05981818,  0.1172708 ,  0.07041437, -0.10287382,  0.13654758,\n",
      "         0.01939314, -0.01755606,  0.06698693,  0.00465923,  0.14757657,\n",
      "         0.03203439,  0.16183098, -0.07852142,  0.11031303, -0.15478547,\n",
      "        -0.05006826, -0.04646337, -0.03826706]], dtype=float32)>]\n",
      "tf.Tensor([0], shape=(1,), dtype=int64) tf.Tensor([-0.13606016], shape=(1,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Verify everything works by sampling two actions with state reset.\n",
    "env = dependent_bandit('uniform')\n",
    "model = Model(env.num_actions)\n",
    "\n",
    "action = 0\n",
    "for _ in range(2):\n",
    "    print(model.lstm.states)\n",
    "    reward, done, timestep = env.step(action)\n",
    "    action = tf.one_hot(action, 2)\n",
    "    observation = tf.concat([\n",
    "        [[reward]], \n",
    "        [action],\n",
    "        [[timestep]]], 1)\n",
    "    observation = tf.expand_dims(observation, [1])\n",
    "\n",
    "    action, value = model.predict_action_value(observation)\n",
    "    print(action, value)\n",
    "#     model.lstm.reset_states()\n",
    "    action = np.squeeze(action)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, model, env_name, learning_rate=1e-3, gamma=0.8, value_coefficient=0.2, entropy_coefficient=.002, name=None, data_path=None):\n",
    "        # `gamma` is the discount factor; coefficients are used for the loss terms.\n",
    "        self.gamma = gamma\n",
    "        self.value_coefficient = value_coefficient\n",
    "        self.learning_rate = learning_rate\n",
    "        self.entropy_coefficient = entropy_coefficient\n",
    "        self.env = dependent_bandit(env_name)\n",
    "        self.name = name or 'a2c_agent_env_' + env_name\n",
    "        self.model = model(env.num_actions, batch_size=1, name=self.name)\n",
    "        # Define separate losses for policy logits and value estimate.\n",
    "        self.data_path = data_path or Path().cwd() / self.name\n",
    "        self.parameters = {\n",
    "            'learning_rate': learning_rate,\n",
    "            'value_coefficient': value_coefficient,\n",
    "            'entropy_coefficient': entropy_coefficient,\n",
    "            'gamma': gamma \n",
    "        }\n",
    "        self._compile()\n",
    "    \n",
    "    def save_agent(self):\n",
    "        self.data_path.mkdir(parents=True, exist_ok=True)\n",
    "        logging.info(f\"Saving parameters, training_history and weights to {self.data_path}.\")\n",
    "        with open(str(self.data_path / self.name) + '.yaml', 'w') as f:\n",
    "            yaml.dump(self.parameters, f)\n",
    "        np.save(str(self.data_path / self.name) + '.npy', self.training_history)\n",
    "        self.model.save_weights(str(self.data_path / self.name))\n",
    "        \n",
    "    def load_agent(self):\n",
    "        logging.warning(\"Updating parameters, training_history, weights and recompiling model.\")\n",
    "        with open(str(self.data_path / self.name) + '.yaml', 'r') as f:\n",
    "            self.parameters = yaml.load(f, Loader=yaml.Loader)\n",
    "        self.training_history = np.load(str(self.data_path / self.name) + '.npy')\n",
    "        self.model.load_weights(str(self.data_path / self.name))\n",
    "        self.__dict__.update(self.parameters)\n",
    "        self._compile()\n",
    "        \n",
    "    def _compile(self):\n",
    "        self.model.compile(\n",
    "            optimizer=ko.Adam(lr=self.learning_rate), \n",
    "            loss=[self._policy_loss, self._value_loss])\n",
    "    \n",
    "    def _predict(self, action, reward, timestep):\n",
    "        action = np.squeeze(action)\n",
    "        action_onehot = tf.one_hot(action, self.env.num_actions)\n",
    "        observation = tf.concat([\n",
    "            [[reward]], \n",
    "            [action_onehot],\n",
    "            [[timestep]]], 1)\n",
    "        observation = tf.expand_dims(observation, [1])\n",
    "        new_action, value = self.model.predict_action_value(observation)\n",
    "        return new_action, value, observation\n",
    "\n",
    "    def train(self, episodes=250):\n",
    "        # Training loop: collect samples, send to optimizer, repeat episodes times.\n",
    "        self.training_history = []\n",
    "        for episode in tqdm(range(episodes)):\n",
    "            actions, rewards, values, observations = self.run_episode()\n",
    "            self.training_history.append(np.sum(rewards))\n",
    "\n",
    "            logging.info(f\"Episode: {len(self.training_history) - 1:3d}, Reward: {int(self.training_history[-1]):3d}\")\n",
    "            \n",
    "            # `next_value` is the bootstrap value estimate of the future state (critic).\n",
    "            _, next_value, _ = self._predict(actions[-1], rewards[-1], observations[-1,0,3] + 1)\n",
    "\n",
    "            self.model.reset_states()\n",
    "            \n",
    "            returns, advantages = self._returns_advantages(rewards, values, next_value)\n",
    "            # A trick to input actions and advantages through same API.\n",
    "            actions_advantages = np.concatenate([actions[:, None], advantages[:, None]], axis=1)\n",
    "            \n",
    "            losses = self.model.train_on_batch(observations, [actions_advantages, returns])\n",
    "            \n",
    "            logging.debug(f\"[{episode + 1:d}/{episodes:d}] Losses: {losses}\")\n",
    "        return self.training_history\n",
    "\n",
    "    def run_episode(self, env=None):\n",
    "        env = env or self.env\n",
    "\n",
    "        env.reset()\n",
    "        # Storage helpers for a single batch of data.\n",
    "        actions = np.empty((env.n_timesteps,), dtype=np.int32)\n",
    "        rewards, values = np.empty((2, env.n_timesteps))\n",
    "        observations = np.empty((env.n_timesteps, 1, 4))\n",
    "        \n",
    "        self.model.reset_states()\n",
    "        action, reward, timestep, done, step = 0, 0, 0, 0, 0\n",
    "        while not done:\n",
    "            # action and reward at t - 1 and timestep at t\n",
    "            action, value, observations[step] = self._predict(action, reward, timestep + 1)\n",
    "            reward, done, timestep = env.step(action)\n",
    "            # rewards, values and actions at t\n",
    "            rewards[step] = reward\n",
    "            actions[step] = action\n",
    "            values[step] = value\n",
    "            step += 1\n",
    "        return actions, rewards, values, observations\n",
    "    \n",
    "    def _returns_advantages(self, rewards, values, next_value):\n",
    "        # `next_value` is the bootstrap value estimate of the future state (critic).\n",
    "        returns = np.append(np.zeros_like(rewards), next_value, axis=-1)\n",
    "        # Returns are calculated as discounted sum of future rewards.\n",
    "        for t in reversed(range(rewards.shape[0])):\n",
    "            returns[t] = rewards[t] + self.gamma * returns[t + 1]\n",
    "        returns = returns[:-1]\n",
    "        # Advantages are equal to returns - baseline (value estimates in our case).\n",
    "        advantages = returns - values\n",
    "        return returns, advantages\n",
    "\n",
    "    def _value_loss(self, returns, value):\n",
    "        # Value loss is typically MSE between value estimates and returns.\n",
    "        loss = self.value_coefficient * kls.mean_squared_error(returns, value)\n",
    "#         tf.keras.backend.print_tensor(loss)\n",
    "        return loss\n",
    "\n",
    "    def _policy_loss(self, actions_and_advantages, logits):\n",
    "        # A trick to input actions and advantages through the same API.\n",
    "        actions, advantages = tf.split(actions_and_advantages, 2, axis=-1)\n",
    "        # Sparse categorical CE loss obj that supports sample_weight arg on `call()`.\n",
    "        # `from_logits` argument ensures transformation into normalized probabilities.\n",
    "        weighted_sparse_ce = kls.SparseCategoricalCrossentropy(from_logits=True)\n",
    "        # Policy loss is defined by policy gradients, weighted by advantages.\n",
    "        # Note: we only calculate the loss on the actions we've actually taken.\n",
    "        actions = tf.cast(actions, tf.int32)\n",
    "        policy_loss = weighted_sparse_ce(actions, logits, sample_weight=advantages)\n",
    "        # Entropy loss can be calculated as cross-entropy over itself.\n",
    "        probs = tf.nn.softmax(logits)\n",
    "        entropy_loss = tf.reduce_sum(kls.categorical_crossentropy(probs, probs))\n",
    "        # We want to minimize policy and maximize entropy losses.\n",
    "        # Here signs are flipped because the optimizer minimizes.\n",
    "#         tf.keras.backend.print_tensor(policy_loss)\n",
    "#         tf.keras.backend.print_tensor(entropy_loss)\n",
    "        loss = policy_loss - self.entropy_coefficient * entropy_loss\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60.0\n"
     ]
    }
   ],
   "source": [
    "# logging.getLogger().setLevel(logging.INFO)\n",
    "# logging.getLogger().setLevel(logging.DEBUG)\n",
    "logging.getLogger().setLevel(logging.WARNING)\n",
    "\n",
    "\n",
    "agent = Agent(Model, env_name='uniform')\n",
    "\n",
    "_, rewards, _, _ = agent.run_episode()\n",
    "print(sum(rewards))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac79367aaa6748b2afe13bcd2b55b28d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=100000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:38: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:38: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Finished training! Testing...\n",
      "Total Episode Reward: 55 out of 100\n"
     ]
    }
   ],
   "source": [
    "training_history = agent.train(100000)\n",
    "\n",
    "print(\"Finished training! Testing...\")\n",
    "print(\"Total Episode Reward: %d out of 100\" % agent.run_episode()[1].sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# or load weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.save_agent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Updating parameters, training_history, weights and recompiling model.\n"
     ]
    }
   ],
   "source": [
    "agent.load_agent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Total Reward')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn')\n",
    "plt.plot(np.arange(0, len(agent.training_history), 5), agent.training_history[::5])\n",
    "# plt.plot(np.arange(len(training_history)), training_history)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# analyze model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Benchmark:\n",
    "    def __init__(self, agent, env_name=None, n_episodes=300):\n",
    "        self.agent = agent\n",
    "        self.env_name = env_name or agent.env_name\n",
    "        self.env = dependent_bandit(self.env_name)\n",
    "        self.n_episodes = n_episodes\n",
    "    \n",
    "    def evaluate(self):\n",
    "        rewards = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        actions = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        values = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        bandits = np.empty((self.n_episodes, 2))\n",
    "        for episode in tqdm(range(self.n_episodes)):\n",
    "            actions[episode], rewards[episode], values[episode], _ = agent.run_episode(self.env)\n",
    "            bandits[episode] = self.env.bandit\n",
    "        self.episodes = {\n",
    "            'rewards': rewards,\n",
    "            'actions': actions,\n",
    "            'values': values,\n",
    "            'bandits': bandits\n",
    "        }\n",
    "            \n",
    "    def hist(self):\n",
    "        if not hasattr(self, 'episodes'):\n",
    "            self.evaluate()\n",
    "        plt.hist(self.episodes['rewards'].sum(1) / (self.env.bandit.max() * 100))\n",
    "        \n",
    "    def plot_cumulative_regret(self):\n",
    "        if not hasattr(self, 'episodes'):\n",
    "            self.evaluate()\n",
    "        if self.env.difficulty == 'uniform':\n",
    "            raise NotImplementedError\n",
    "        regret = self.env.bandit.max() - self.episodes['rewards'].mean(0)\n",
    "        plt.plot(np.cumsum(regret))\n",
    "        \n",
    "    def plot_rewards(self):\n",
    "        import matplotlib.patches as mpatches\n",
    "        if not hasattr(self, 'episodes'):\n",
    "            self.evaluate()\n",
    "\n",
    "        im = plt.imshow(self.episodes['rewards'], cmap='binary', origin='lower', interpolation='nearest')\n",
    "        \n",
    "#         patches = [mpatches.Patch(color=im.cmap(im.norm(0)), label=\"Sub-optimal choice\")]\n",
    "#         plt.legend(handles=patches, )\n",
    "        \n",
    "        plt.gca().set_aspect('auto')\n",
    "        plt.grid(False)\n",
    "    \n",
    "    def plot_actions(self):\n",
    "        import matplotlib.patches as mpatches\n",
    "        if not hasattr(self, 'episodes'):\n",
    "            self.evaluate()\n",
    "        actions_optimal = np.empty_like(self.episodes['actions'])\n",
    "        _itr = zip(self.episodes['actions'], np.argmax(self.episodes['bandits'], 1))\n",
    "        \n",
    "        for i, (actions_episode, optimal_choice) in enumerate(_itr):\n",
    "            actions_optimal[i] = actions_episode == optimal_choice\n",
    "\n",
    "        im = plt.imshow(actions_optimal, cmap='Greens_r', origin='lower', interpolation='nearest')\n",
    "        \n",
    "        patches = [mpatches.Patch(color=im.cmap(im.norm(0)), label=\"Sub-optimal choice\")]\n",
    "        plt.legend(handles=patches, )\n",
    "        \n",
    "        plt.gca().set_aspect('auto')\n",
    "        plt.grid(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66c28d0fec9b450ca153f4f3107cec5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=300.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "b = Benchmark(agent, 'easy')\n",
    "b.evaluate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b.plot_actions()\n",
    "# plt.xlim(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeYAAAFKCAYAAADITfxaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dfYidxfXHv5uE8JNGDYnZuyQNQjSCWBP9Q9pALXTTbDTJkm2rFRFpt5ZWKYaYYmkMSEmb1IqVoH8lhLYKthT6sgEjrWatSWhtU6s22EaIlGAiu3dhSTa+5s3n94d0r/v43L1z587L98ycD1xo13vn5cyZc2bOnJl0FUVRQFEURVEUCmbEboCiKIqiKA3UMSuKoigKEeqYFUVRFIUIdcyKoiiKQoQ6ZkVRFEUhQh2zoiiKohAxK3YDXNLV1RWsrvIts5B1s2Fy486VfFKQO1MfqsZOokxdYTM2TOMpETYd9Nke09vJXYz3mGM62CpsJqfp73yhxqI5rsYq5Jiz6ZcvQhpFNvmxt88EV30wKSfkhsAXzfqQvWM2IWdjYUIKfTAhl376QuLiwteYm8jC1Xds2xOqXFd1SaSZfChC2SbK1uo3UpHWD5/rOJtVckj55ayn0nDlsHyNn0m5PnXH1Y60FWxzWApJ7ZhzHXCJO5GYSAxB6xh3Tij7kPNYsdlg9vY0g2LHXIZwrWBFKKWIrWxKfrAZPBNCtVGCLEIRMhxfBVvynmnUjXLHXIUqu8KGhJ2RC6OTSsieaTGhZ6/ukain4h1zmZBnF2yJGiawn9cqcQipFxINZSts53Cq81Fim5mgdsy+ztxCnu9J2D2FIkWDbIvqReewG3/29pmgeto5Lu7AT/5WqmOWQMxkkzIhowc+YTeC7O1T2sOVsWWKnvmsy4SQd53ZUcfcBLY7yqlOohSxNcAmMMk5dmZ5CjoY85jNZ3tSGJuQiHr5SwezgY2xl3BexdYeJtgWY65IccxTHStXpDjmPqHeMZeJ7WhUuTiIeVatBrhBqrKw6ZcEWaj9koP4l798vbokcaKVYWuvKySeXcdcQFbhov6QmdsxX3ID+J2aSfvY2qy0D8WOOaZjVuIgYUGkhMfn1cRWvwmJz3N7m3LZ52Ps8QyZIwCQOuac8TVhJWSTMp2dS8x0dxWaNSEFubMTO+lOaRDSngKkjtnn5Mx14qcyOV1MELbwcuzFTihS0MEUdutVpDA2EqF2zDZI2AEqiitiPqiTynxgX9SZwNaeMuzti01y16V0wBvEvB+dy+7OFbEXfjFlKnHn6ILYY86EymJ6qHfMKQwUuwKyt08CuTgaNmeegkxNCJlj4aoupsV07M2Hq2MsgMQxm5DL5HQF04QB+NqTKzGjLYpsVA/cI/4es9IeuRwP6CMk7WHTPrY+SZR7SHwtvkx2zK3KsK07Nyh3zLFDOOywhxp1oslG4hyR2GZ22GXqagFShqEcih1zGZ+GnU25UoRNxuwGhg32hRbhXiJJQo2xrX6xRQVdlk2xY5Z4DzDkSzDSrrywGXJXqINvjoQx1/HrDFcP2LDJnc1WAoIcc8hzaL3+w0HISR1yoVUmhXM49vYpsklVv6hD2TZONuTrTbZ1sYf72BU7hQVSzrkQZWwX0yn0nR22F82kRSRty2kG5Y65ihQNVU7keieSjZgGL1WZKs3Jecw7ca0UO+YysQczpINgckY+cZXM4YLY+hWTmDsaV9EDl2W3qkviVTsmm5LCMY1LRD0wojtm90i8XiZtjGM6DFdlSzSKIXfnbIlB7AuFXOTlCmrHXIbNmEk8r/X1yEDI5+pskDg52ZGo/0oDHT9eRDnmKlRxGrDtLG3Oj6uI3Q8m2HYeZdjHim2BxjZnlebEjlQAJI5Z4j3mMq52kmz9ioka1+Z1m6L61B65zEdp/WSzBSZ04lopHHMZdoGHRtokkojEM3kXsC2CpVxnYa3bJ6n2KyaidsypkKux90krWajxmErMLOMyEvU/5hyWoMutxp0tt0WK/Cgcswmuwt1sj5n4gk0h2XZmSnhin91J0y/tQ3tlS7iTb+p/knbMrupSOodtocCEGmD3sLXHF7n0UwKuoiKAIMdsArtCphqOiYnKZnpSeDDDF2x3w1PQ5RT64BNRO+ZcBi9mKC8VGbvoVwoJRkoYUj0bDkXsRQq7HRS/Y85lxcmOGp32yFleNvfb9WU5XiTmibCPuSjH7PIQ3UVdCg/sE61MqglP6lAVV4RMEKuCLRcCIHHMOtHcw3TFxLT+XAywr/BozrtzxT25zMeYUDvmMnqOM5VQdwVt2yJtdevqql0u+pZqP12RqrxS7Beb3xDlmKtIQSkUxRb2kFwVKRp2RXFJs3lN+e8xp3JepYbJPSrTBi4iHj7ll+LxRcj3E9h2dzakcgQTOpFRd8xkSFBShQO9o6wo7omdsAkAM1r9cGRkBHfeeSfWrFmDtWvX4oknngAAPP7447jxxhuxfv16rF+/Hvv375/8zc6dO7Fq1SqsXr0aBw8edNSFqRRF0fKjTI/KSzZdXV1TPr7mQLkedcp+8DUfbfVCmn1w1U8KfS9aUK/Xi9dee60oiqJ4++23i76+vuLo0aPFY489VuzevfsT3z969GjR399fnDlzpnjzzTeLlStXFufPn29VTUsA6IfgE3JsXNXFrkuq7yqv0LJgkp+E8fTVvma0PGPu7u5Gd3c3AGDOnDlYsmQJ6vV60+8PDw9j7dq1mD17NhYvXozLL78chw8fxvXXX9/0N7oCb1CQhw1t/2EQm3MlV/2OeVXMpO6Yj+8z6ZYpEttsQkjdYbrf7vNVL1f6HlrnWoayP86JEydw5MgRLF++HADw1FNPob+/H5s3b8bExAQAoF6vo6enZ/I3tVptWkcOQFzIxCcUYZSPYTM2Jn1g66cJ7HpqI/dUYB8bk/aFHBtf8grZB3ZdLsu4HTkbO+Z3330XGzZswAMPPIA5c+bg9ttvx3PPPYc9e/agu7sbDz30kFXjAXcCrhJEK8GY/Mb246quVuXYysYEk7FhnyCu8CWLTiZwLEzaG7JPJnKPKWO2OcLWHl/46qfvOWt0XercuXPYsGED+vv70dfXBwC47LLLJv/7rbfeirvvvhvARzvk0dHRyf9Wr9dRq9XaapRNaLTZ32zK8UXM0Kzv9H7FnpChbFeEDNG7ImZ7dK41h/34rgrf+t9yx1wUBbZs2YIlS5ZgcHBw8u9jY2OT/3vfvn1YunQpAKC3txd79+7F2bNncfz4cRw7dgzLli2zbuD/YFvhMe1wbHbdAJ9Mlc6oCmXbRHFiYtse2zkQCl9RQZvfxJZFGVfHWuz9bIeWO+Z//vOf2LNnD6666iqsX78eALBp0yY8/fTTeP311wEAixYtwtatWwEAS5cuxc0334w1a9Zg5syZePDBBzFz5sxp67BZTZqssnyuxJgcGVNbOsHXrsI2AsOOibxa9ctn4o0NsZNzXPQrpN0xqYtdt13Nz9j9dDknKB4YCSnQFEJK7H1wpVJs/Spja4BDLkB8yZBdB31huyFo9Zuq30mUKVsf2NpTpmk0k8Exl3G1ivdZlwmhlCKmQfZZl6LkTOyooC98RUglkoVjdkXMVVaqCqj4hz1kHzvCwC6fmEi0OylGnibrS8kxs4ctUkDiBE4BlbscdKwapLrrd4Uox1wF29ldmZCrNV2ANEfCJDcZP6aoDZv8ckGCLkuDTaaiHLMqn2JKzEWTRnYasBk8V7haRGk4vjmp6k4Vpu6W8t9jriJFY6Z0jk1GrKu6JBBq3kiUjQkhr4HZjBV78mrs61xsfsPUXumOWQAushglhvVN6lddaWCz83C1W2Hb9cTU09jJQ0xyZ4sqxZaXqbsV45jVIHPAZnQkXr1IUZdjy1SRQ8zQP5tO6o65DUIOJrvisKPyy4+Q165UvzpDF2zTQ+2Y2ZJzFPeECi3q9YzpkRhhKMPWnjKxj3tSIAU9NYHaMZdhF6YpulAIj8TJWYVel5KLzx29jk2DFMLdyTlm3RmFQY2Ff2x3WOxyZ29fzoS6vhXbybFFdkyhcMzqUGXD7rx9hRZdTR023VaH6p9UbVzIXSy7ntpuHgESx2wCm9CV9sj13E0jO+7JRV5s/Yx5IyPF8QXIHXMK9yZzgV3u6gh5CJnAk4shd4XKi4PkHLPSOale4lcUNlxFjHKNPPkkph0U5Zh9NolNaUM9e+cKiS9FSbyXrjsa94QywCbnoVWwjTFTXgibbGwR9fJXTMOuuzseYhrOXEhVFqn2Kybs85H9BTHxO2Ybctr1uFKKMmq8FBNiL17V6fKS63WpTpyuCWIcs07G9kjBmMV2CIoc2PVdF8pKFc30guKffXS1AwxVbuz6bbKMXa3wQt4nZLu7yGZcme56hsyGl7hgY2+fRNhsgcv6KXbMudzNU5QqfOog+06SDV+hWV8bC9u6c9UDtuuU1GfMIXd3NrANZpmcJ546ns7Qe8M8qEybk6qNE++YbcoxIdUBz4WQdxDLSEhAdIGEOcIkr1SRoAetkLChA0gcswnSFABQY9EpEg1BrmMee6yYztLZ6mKPirBFSH2S/D3mnGBKcmBPsPB57MDudF1NZYmyYLviqMjB1x1l099VQeGYy6Tyco40Yu96QqHJVgrgb+Hnqj3si2ClczSU3YRUFVIXMs3JacxjPnPKpoNModmQ5bCTSz+roHbMqZ4n5IK0+7Sx0V21e5h0UJketmOHkAmkySV/ldFJ1TkhDZUaxfzQMW+gc02pgvrlLxPYdljsys/WPqbrPrFlYYOESIDCSc66I3XuU+6YUwlDSWyzDTFDQQoHOlYNUk0Qi0lsmYZ+L4Fix2zSSXYFTOEunq3ys4+NL9hfhKvCl4HJRQdij2cuci7j8wqTTf2+9YByx1yFNCeXE7mORa79riL2jiZFYi8CyvjKNnfldNnkZYKo5K9UQtlKg1AZlBImZwq6nEIfXJFzYpeN+3C1yWKTRRnxWdkprgJtywkJ2xUT3YE2CHWmlYs8XSFxnqcKm/2ygfqMWeKKk62cmLiaIC6y4VMxnL7azC6LVMYvF2Lar5TzXyh3zBInp88zkJjOKNddrEZSGsR+GrJM7EQgJtiTTjX3YHqoQ9k25JwwUEZiHyS2WemMVMeczUEwtSeVMfcVNs/SMZtg232JK8xWdcWeMKHak4qxUNrDhX6p7qRPTBs8WV8rxzwyMoLvf//7GB8fR1dXF772ta/h61//Ok6dOoX77rsPb731FhYtWoQdO3bg0ksvRVEU2LZtG/bv34//+7//w0MPPYRrrrlm2sapYrdHyNVbimOTSj9zcTTsOShsC1wbfB2zuWqPRJma0NT9Fi2o1+vFa6+9VhRFUbz99ttFX19fcfTo0eKnP/1psXPnzqIoimLnzp3Fww8/XBRFUbzwwgvFXXfdVXz44YfFK6+8Utxyyy2tqvgEAPTzsY8L+ZjI2ZbY8mm3n7E/7O3L5SNNtxk/LuSVs9ybMQMt6O7untzxzpkzB0uWLEG9Xsfw8DAGBgYAAAMDA9i3bx8ATP69q6sL1113HU6fPo2xsbFp6+jq6pryKYqi5acKk++wYdLmsnxsKJfRLCva5uMKF+Pns32uCCU/KXMgFtJ026TcqrJ96oWNvMptkTBnQ9PWdakTJ07gyJEjWL58OcbHx9Hd3Q0AWLBgAcbHxwEA9XodPT09k7/p6elBvV6f/G4VJooSMkRi8p1WvzH9nYvwo8/7eyHLCTUhbcfKV/2xxyZU3SHneUh86baJnrqyMbHnRCvY2+caY8f87rvvYsOGDXjggQcwZ86cKf+NZZXjSklt+uLTOZrUZfMdV3WFLKcVtsYsppOzxdeizhfqINorm21sYtblM9k35oK2GUaO+dy5c9iwYQP6+/vR19cHAJg/fz7GxsbQ3d2NsbExzJs3DwBQq9UwOjo6+dvR0VHUarVpyy8LJmQIzudApZqMEwobWYQ0/jGjJKblxFwc+io35BwJ6SzVXnSGqwiDT0x9Xcsz5qIosGXLFixZsgSDg4OTf+/t7cXQ0BAAYGhoCCtXrpzy96Io8Oqrr+Liiy+eNozdrPGtzhxsz6Ft6nKFSRtt2uPqDMmVTF3ha2xclWtbTkg9TeHsjj2/JOa8sbWVKcJmyzuh5XWpl156CXfccQeuuuoqzJjxkR/ftGkTli1bho0bN2JkZAQLFy7Ejh07MHfuXBRFga1bt+LgwYO46KKLsH37dlx77bXTNyKBlSJbeyTi4gwy9s7S1w7L1y4/to6GlFeZFOxOFSHH2MYhsckrJs3kJ+aBkZhhO4WHUGPMZoDZ2mOD9iEOEtucAiZyV8esKCSkmp3MTsjbDL5gax9be8qwtc/46EqKYy7DliTiilQTW5Tm2K6smfRCFxvt4WrMJdq4nBHlmF1lZUtUyJjnqooiQXeYFpAS5GVDqv1ihzqUzXYPkMkQsOErCcm2HKUB+67aplyXZdsQM/ydwlzzWbfExDNRO+YyEs5+2NqjpI3EsCZbdnDMPJVU7UWq/QpFM71t60nOmLANOFt7pMHmRGJiIgsT2UhY0LbC5wLExdm5q/P2VEjhyp4JvqKxzaDYMccMz8R2EBKVNAdi34dW3JNrghqbLuscaUB9xlwmZMgrphMOXT8TbEaS3Vik+sBImRQW3CHPVdnGr0xsm8du76kdM3tWdmwnIm3lyjZ+OdNqLCReO2RrT0jYE81s6spl7KoQ5ZgVBcjbANvALq+Yxr8KJtnkDLvemuIyH4HCMZvAnoFqAvuqVKJMfeHTsOuOoUEKssjlmmYu9oFhAUnhmJkSEUK3x0U5qUwYdsPkihQXTbpDbQ+2s3S2HIaY98dDQu2Yy8QWMPuAs7cvVdgWh77KsanL1eKCfQHCRqoLolxsHLVj9nVP0aZuhQc10hzEDu2FXKTk4hBMYJJFbL3wBbVjLiNxMqR6PYMNaRnqintc7RLZdpspHnHY4iqUzT6vRTnmKtgEqii5YOvA2ByfC1J1hKmijtkhria5nmmFQZrys50Nu6y/FRph8E9svbDBV5slyiIk1I45hYFKcXdgihrp5qhhao9cFtMSzkxdhNbZFsFsukPtmMtIm2QKN7pwaE5sQ+VrQRu7X61IJTmNrT0uCLkIyMIxuwp3u2qPNHwqpItybYm5ipe40pdobEPdn2V3+KkgUQdtoHbMvlaKOokaxF4FSstQT1V3cjF4iiIBasdcRo1F58Q0wOxOjb19pqTgZFPoQ6ro2LjH1N1SOuYq2EOE7LtEtvCyLXqPmQNd+OWHjZ3xOS4h7zGHPA4DBDtmE1KdwL6ujqVKLk7XleGU6HRTGOMU+hCSmE7Xdz4OpWMOmfxlSy6TKJd+lsl5IWMDe+6BK9j6wNYeX8Tup68FrSjHXEWKyqbEIfYkV5rjanHta0fDFj1QXe4ctlsbAIljZj8PjXlVpQq2laKLcl2Wrcgh14hMFSqLOLAtvgASx1zG98F6qPpzQQ0KB2zJOSawtSdFcj63Z6eZj5oVuB1G+Azh2OzOFcUU9ixQNa7T08oesCXLmWDbHqZ+5PIOw2R9ue2YNbvbP+xXxxRFcQP7oiQmyZ0x26JK4p4UZMp+RYgdn4sdlXvasOXMsEHtmMuYGE7T3ykcqAHOD/bEQZtyNCIzFaZ5Hfss3dX7EgCpYzYhlcnApNiKEht1fA1UFukjKvkrp3+gQmKbyzBdN+jkUn+75Siy8aUHrmwTW4TBFWybkZjPiDaDYsfsypi6KjfkHeXYSpkjbEmBbHrh6kxe4gIolJGWKBs2UpAhdSibMV1diQ/7vVxXZ1pVaHJVWrDpaZmc9ULPmDsg5OtguRgzNmORqpxzQMezPVResgh57AGQOGb23UHOk0hX24oJqVypkrYoT9U2ucodYZcFtWM2Qc993cMeUmULZadaly/Y+uCiPTnbC1+ksqgzIfnkr9gCDglTyFmi3FPog9I5qgcc6IM/DXTHrFjBPolc7frZDYHt835s/VDkIG1OSIxgNbNfM1r9cPPmzVixYgXWrVs3+bfHH38cN954I9avX4/169dj//79k/9t586dWLVqFVavXo2DBw8aNa6rq2vKxydFUUz5hKRct5A1UUtCjl+ruqs+vnA1niblVPUrRV2KTQoytelDlQ7GnNcm+GqfyXz0bsuLFhw6dKh47bXXirVr107+7bHHHit27979ie8ePXq06O/vL86cOVO8+eabxcqVK4vz58+3qqIAoJ8IHx0H/djORzbdYWsP09ikMsYp6kUzWr78dcMNN+DEiROtvgYAGB4extq1azF79mwsXrwYl19+OQ4fPozrr79+2t8VFquNVLP0bDDpZy6yqKLcd4m646s9tkcTbLrD1h4X2PbJlSykydTEj4Sc153U1TKU3YynnnoK/f392Lx5MyYmJgAA9XodPT09k9+p1Wqo1+sty/IVjgwZ1jSh8BT+MOknmyxMcCUvm36zhY5Djl+rflf13Zduu4S9fUpnmPiRmPOonbqsHPPtt9+O5557Dnv27EF3dzceeughm2ImqZrUKU4iic4xJjHlVaWDNg7LVf22bXaBhIWfSb+lzb1U7WCZXPrZDlb/iMVll102+b9vvfVW3H333QA+2iGPjo5O/rd6vY5ardayPJtJwhZqVNqDffxM2uJ7tf1xTOTFJL/QuOq7zbGHL3z1yWXZNqRwtOQbqx3z2NjY5P/et28fli5dCgDo7e3F3r17cfbsWRw/fhzHjh3DsmXLWpZns1qKvUKXhu2q1NdKNtXxy0Veqe5wmGRsgqt57StqaRJ5MoFN/03oRIYtd8ybNm3CoUOHcPLkSXzhC1/Avffei0OHDuH1118HACxatAhbt24FACxduhQ333wz1qxZg5kzZ+LBBx/EzJkzrTrUiqqBYVrt2uJrZdjJOf3HyW3l2im5yMt2zpqUwyQvV+1zVY6reV2FiwUX09iFppO+i3lgxISclYCdVBdNZdj65ULuEvutuCfmoim2DrqyX6bu1uqM2TeuVnMuk19Cls2EiUKafIepn7YGxkYvmfptSwo7XcDfIiWmXpi0x9V3fEUpQ+qOq7nvU+4AyY6ZbQLHRIKBk47KuD0kyou9zbHb52sH6OroK5cEMWrHXMbn+XHIHU3MNsfcuUmcIOyw7dRa1eOzrlRJMdriCon61YlrFeOYU4XJgarzTo9QIVQdu86xOUfVedQ5bHYQIHHMTCv/qrqq8BWyManLpAxN8mmQghPxpV+pyKKMxNBnCnqqtId4x8yOq2QAk7JTkJcv2IwtG2y7A2nJQhLlxY5P2xkSV+fiAKljjj0IrjKRY5KCQfFVjs+z/hT0gr0ProhtZ9hhiuZJwKVjprwuFRLbdYme1TXHVR/YdlOurlSVsTWAvnSHTQdT7Gfs6JlNOSEfQJF43u6yPZQ7ZhN8DkLMO4ch2+OKXLPPbZHYZl9IuyUR2/i7ImZSYMyrUK42Yr7bQ+GYy9gOphq8/AiZsJbL3UqlM3TMp0ftdANqxyxxYCTeq3YB2/lxqHJt609hARkyOmUCu7xskaYXJvhcOKcgL2rHbIPuVtLHJlszZhjdtv4U9DRmprTPukLWnULCZi5kGcqugu2g34QUVnRKfkhMvDEhZO5ImRSctytS6IMtpu6WwjHnNDBM5DxBWiFhN6zjp6RKCrptez8bIHHMZSQOgjI9TBNNwu7OFUxydwVbKLsMm4xjPuCRylwLHW2hdMxVsA1migYvNnqdhQPV7fZgl1cKcyJ2H7J0zCHPq9gmEVt7lM5w+fpPu+XEJLbhNIFprkmQl9IgtGOmfPnLZ0Ysm/KnkE2aCyEdqLSxkXBLwsUGIHYfbJCQL+ELtkVvcslfrjJFbeo2Iaddfg5INEIm2NyzroL9VTY2g2xDbB1ktzsS78An55hTwNZYuAiP5iJjEyQuomIbaeUjJIyDrzv5bEl3KRwTUZ8xl0nhtSQlfSQYaV+wnaWnaB9cOaMUZGGChPkoesfMdiYSe8BTnGgSV9/sdYVEok5KbDM7KtPmZHGPWRWgPXztTlJ1NEr6qA3xj0QZxwx3UztmCYOncCBx4sek1fRmy6YOGeViW2TaJOalqv8hkxRt8KmnAIljNkGiArJPNPZJzmY4c0WCk2PX5ZBIk4UE/fIFtWPWhIb2YMv81bFpkIIsUuiDLS76zp4JzIbEiIwrxDtmE0IaFF9XElzBtltnMvZsk9Mnvq7aseu/Mj2uxjjUvNbrUqRoWMw9rvrJrvwmsI05W3vYCbWY8OkMfM1H1R1eqB1zCorDvhuIfY6TgrFgO0KIWXcK42lCLv1kgy2aF3LuA6RvZVfBPkHY2mND7HC3DSHb56vsmDK1rZvNefsKrevCVDYmcjcZi9BXSyl2zGVSUVqmyai74c7Rc1X35KI7NuSiOznbJg1lNyEX5U8VfUilQQr3OkNi02aJ/VR4oXbMJqSg/CkkSZkQ8pEIGyQaV4nn0Aovoc9MQ9QlUSdFOWYNEaZHKEPg6oUg1S9ZxNQvJT/05a8mpDpB1CEoPsnZ0bDfufVVf05jHBOXV+soHHPICWKC7p4UpT1SOaZhd2rs7SvDZjsltAcguS7lS9nYymEjxSzj2Pe12XAxt2zlJVGm7G1max/7QiHmoy3ir0uZGM5Wv8kJaZMByNs5hkKzjGUj8QEbJlskUZezDGWnQkzl95VclQKpGjwbkyBhfJmciAmu5pW+7hYH2w0KQOqYXZ0NsyFxRWdDLv20hWlnlPNY5dz3XGEbc+oz5lxI4clLE1z102bFySa/KpjayNSWZoTMQYl5Jq/4R8o4zGj1hc2bN2PFihVYt27d5N9OnTqFwcFB9PX1YXBwEBMTEwA+Usgf//jHWLVqFfr7+/Hvf//bWUO7urqmfKooimLKxxXlcqs+qVKWu8nHpBzbum3KjTlWtrpi8pvyd0zHQhoh+1SuK6RNSREJ/WRsX0vH/JWvfAW7d++e8rddu3ZhxYoVePbZZ7FixQrs2rULAHDgwAEcO3YMzz77LH70ox/hhz/8oVEjbARja4Rc1eXKIUhzLDa/Mf34IqazqtIVV3rhQv8lGM6YhFpQprKIKuOqnz711NU4uGxfS8d8ww034NJLL53yt+HhYQwMDAAABgYGsG/fvil/7+rqwnXXXYfTp939bh4AABS5SURBVE9jbGys7UbZDqaNMZMw4KEWICZ1m8jLZpdd1S+bsfE5nr5kalO3bT9tF5k27YtJyPYw9bsKE1mEXLCZlFv+TsiNmC0uF1pWZ8zj4+Po7u4GACxYsADj4+MAgHq9jp6ensnv9fT0oF6vT363GSadKAu1EwPiohx2fPXLp7zYxyZme2zmiMnvTH5j8h3b9rUq1xZfY2UjY5/lmGBSri/98tkem7p8yt2l/eo4+cvF6iCkQWYz9uzOKCQuFmix5RdzPKUZydDYLAx8jWdsWdjA1mabsWHrQzOsHPP8+fMxNjaG7u5ujI2NYd68eQCAWq2G0dHRye+Njo6iVqu1XX7I1WTIuqrwFS0IuTsJSag22+qFRJnaYKKTrvQ2pjNMdTxD2Qe28azC1eLLpa60PGOuore3F0NDQwCAoaEhrFy5csrfi6LAq6++iosvvrhlGBvwd+5lgoQzNpv2xZSpT5jO82zH3OaMjQ0TXXKlt65gl6kJvvIcfMk9FbtjQyc+oeUDI5s2bcKhQ4dw8uRJzJ8/H/feey++9KUvYePGjRgZGcHChQuxY8cOzJ07F0VRYOvWrTh48CAuuugibN++Hddee23HHaxsuMABjhkJiH02rCH7BjFloeOgmKJ66p9m7pfy5S8TYoegY5KL0rIjMRHIhJgLLVfJaL4ImTxURcwjPTY9ZcdWpgCpY1YFkEVIg9KqLgm7dbb2lGGLtqRIqjkgvrD1Cez6Jd4xuyi3Cp8DzqQUbAl1ElfoTOMZmxRk4Uu/2PSWjRR0x4TkdsxK50hU/lBtVsMpG7bxkzjXYsKWrc92hACQOGYbYp9p+WoPO2xGUVFcok6WA7ZxCJlTAZD861IxhW5St0Sl0MVEc3JaXLAZOHZayUfCEYy0MZewNwwtQ4odM7viKGFwYVDUKE4Pe/vYCJlLwhbidUHIpK3YeTQ2dScXyjYhtoLaiDZ2m0Mh8U63OrW0CJn85aOeTmCaE+yLC5+Id8xsAyVh8imcMBnFnFB5NZAmi1SdN7Vj9nWQLnHgUlVAV8RcobPf72XXnZCZtUxZ2gC/nrLrTqpQO2Yb2O8NmxKzzbnKKycjFPMKWplUZZwLNvOGLVmOTU+Tc8xVsGVHuoLJgUqcREzycwmbkWmFz/ZKe/AnJDEjFRKiUyExdbcUjjkVoZcJZSxSWYCkQAphRPaQvU25tmVrPoDiE1E7ZhMHFrIcZXpcPbfZ6jdVv/P1GEwqemIjn5jlxq5LURigcMx6rqpIIOTuKebZsM6J9mAaz9CEinj4jDzFPBIStWOuIoXz45AKkEJI1YRUDV4ZttAsO66SjlII66dAbNsU8sgFEOyYQxJbKWxgn+QSZeoLTZCZHvZzaF/ETrRkkoVPmG7GTLZBHbMyHbkYf1fkKq+cDbvSHDa98HnH3KZcascc8hxAQ1P5wT4OMXdGbLKQiESZSmyzDTbn/1XoGTP4D+xzhm3FaVKu6oFiiq97uS7qlliOzsfpoXbMKSR2sePzCpPin5zHhukM0DbjWneocWBrTxlRjtkEdd6yiblQUN1JD3YDzAaTvCTOR9+RQwrHXMZ3KnqoutiVywbtZ1pI6GeuWdlVMDnU2KQQqaB2zGyhKXZyCWtKNJxlcrkKlcJYpQJT6L+KVPXC1dsRAIljtkHirjomajjbg01erh7M8FW3BJgWO7HtDpMscobaMatSNEjFCNrgQhV9hrNSCJ3ZkLNOmpDimANcz22mCrVjNoFtdRv6Xlu7dbOFs0JdqVInMpWY138kok6jgcqiQcg8B4DEMadqLKRdtUhF7kzkLNMUDDvT/AyNizPTFO5i29LJzZNZXlrUIbEV29Uhvqt++DonVBSfxJ7HLkh102CCi+uLsR9kiTk2ndRN6ZhjK39I5QqVnCPBeKS682DCZoEmYRxC7WwlyMIXvuRlu2lgv83Tid+gCGWXyVn5XcHm5NhW20raqO5MD1uItwy70/VV9/+g3DGbkMrEY3KgIe/cuvqO0iBmkqKrM8Aqct3ZskfqTGBzwoz1V0GxY9ZkpvyQMGFtYFpoVZFzMpML1Kakh+6YDSFYK3hBJ3UDE4fgi9g7kZjOMdXjglDGlW0hI3H82BZ+seuvgtIxV8EovFYwZXdL2KHGrt8HtuPp6t53LiFLqdm3kuu2hf0dhipCt0dMKDukYGIbmTJMSurrAZSq39l8J/bVNl+6w7Yzstn1VxHb4LZCQ/8NUhhPNkSFstnwabRTSILylZzjSzYhd26u1r1sOhBSb2M6Pja5l4l9TzhFGBbBlDtmBsEoMkjhhSAlDhLtjLRdq0QZh4T6Sc4yOYeLcibmE4CuYGtPCjA5I3U0iimdPMkpxjGXyXmCuDpXLZPLgii27jA5mirYzu0VJTYhc0cAUsdcBZOhAuSF39mdgRIHdr1VFFMk2mlqx2yTMKPGQwHCnjH7ykRmMxapIs2udBIKne43Pol5e4Zp7EzxkpXd29uLT33qU5gxYwZmzpyJ3//+9zh16hTuu+8+vPXWW1i0aBF27NiBSy+9tJNqAMgUOhMSjb9Jm0M+DBIySzwFo+MKV7JwEWqUMA4pOGK2BUdoOtox9/b24re//S3mzZs3+beHH34Yc+fOxbe//W3s2rULExMTuP/++6dvRMRVoESHFZNc5JVLP0PiSqa5jE3Mt89t65K4kIlJM183w3VFw8PDGBgYAAAMDAxg3759bZfR1dX1iY8vQtYVk6IoPvGxwVZeJnVXtdFFm22o6mestsQmtu7YlBNTd1yRi23yiSsdsCmnEx3s+IGRu+66C11dXbjttttw2223YXx8HN3d3QCABQsWYHx8vNMqKsll1eyK2BEGX2HgkGfMMR9uiLl7khhqZ2tPSHIPA3+ckEddLuvuyDH/+te/Rq1Ww/j4OAYHB7FkyZJPNMzVXVQNeTWImWAU+1qRrzPmkISUu40DZZdpzo7Hl62M6cBsYV8cVmG6a+7IMddqNQDA/PnzsWrVKhw+fBjz58/H2NgYuru7MTY2NuX8OTSxB8qX4rA7VFeE3KHaLGQkXM/wVVdMfZKoy7niU/8l6oFpPpX1GfN7772Hd955Z/J//+Uvf8HSpUvR29uLoaEhAMDQ0BBWrlxp1NgUz1FanVHannlIPzsLjY1+mZzvufqOT3LVlRTOmFPANlcj1bEz7Zd1Vvbx48fx3e9+FwBw4cIFrFu3Dvfccw9OnjyJjRs3YmRkBAsXLsSOHTswd+7cactKyRm3i4tddexdmaIoDXxmn7sot6psV+WYEDKqxB7ubiY/igdGyrAJr4qQ9/ckyEOJj0TdyeW8mD3hT4kDtWP2tYJiU2xf7WHrZ874MsASzrMVRZkeU3crxjH7Ksf2Kgh7iETxj60jlKZfqTh8dpmWSXVXzTQOsaHeMZuQ8+ApChsuzhZjYxOFCOksYztddaD+oXbMOuDuSeHsLqZhSsW4tsJniFwNe3PY9aIKXwuZnBHlmCUqrdI5TBnqMV/a8lmXkj7sztFXRjhbP02gdsxlfA5UCoOZM63UNZXseFe6LE3f2RdEGj1QAP9X4igcs6ukLVfoJFJMiO282Yk5j3RspofJxqUyVq7yEQASx1ymkw61Ww4bKfQrlYkmDb2O5x4mByaRVCMMumNu8p3YSHtgRIJMXcAeCvVZf4rjqchCdbI9mrnfjv/ZRyZCKoWvsnN5is4XIfsZW6bSMtSVBhJlKrHNUqHYMZuQ6hlIKAfq87GVkDCdW8aWhTTUsCsuYZuPyZ8xV8F+5SUmqVwRClV3qvh6TUrCgi0mKovOyMVOV0HtmENmZcd8yce2PaHOs3OZDBKQNjaxjWvInI8yOja8sNl7k7oAEsdsQi6KlCq+DFzIhQ27swx5L9cV0pIoQ5JCH5TpEeWYXT2mYFp2iuTijFIg1SslNsR2Rq1kKvHYKFVS0H9qxyzxupQNDCGSTutmN0xs7UtVl3MhBeMfEjZ5sbWnDLVjLpPKk5whk3FSgG38coBtt27SHp9tVv3qDJVfe1A75lx2zOz4NIopkKLRkTieMSNPIZOHXM1HiWOcC6Icc0hih5d1giiuYHdYEupqhc7h9GB6G2GyDQyOuUxswbi6vhXz8ZBcjAWT0bZFkxY7h10P2NtXhcQ2l2HvQ5aOOWeH5Qp2xU6BmI6ZbY6wtUdxj6/jgdjvTbT6TdXvms19ireyfQlYJ3T6sN+DNSnH9upfisSeszZy1zPd9pBoy0O3mWLHHFvoZXLdJUrM0HXxG9v2SNSLFPqQC7EdfKh5HXsxrWfMhug1Btn43G22Kje2MTMhhcQpNuPqChchy9hXx1r9pup3MR8gij3mNvi2cRSOmd1YhMTXgLMZ/5BnRjGvvNiSgi7bEFvuNuQ6VqkS0zZNlsXgmMvEVmxXOzUTYvc1B1LY3cWuK1Td7MQeh1zlnirUjjkXZfNl8NjOVUMmTrHBLi/23V0uY67wEnvxBQhyzC6yJXOGzXm7gumsjJEU+6XOO05dEuVehs0OUjvmMhLOAJUGKRp/pT10PiqxiZl0WvU78Y45pPBMyknxgQW2fipKFaqnvKRwVMKGKMeskzNPTCZ1ChM/1z6kkHugtmkqKeiyDVlmZVeRy4Czo4aJh1B3SGMnw6SgX7k6sFTJ0jHnpLQpTlh2Yx/7ZZ8UnVrsu58pzJtc0OS0Bs3cL+Vb2a5gcxBVhGoPWzZiTBmHJGQ4ni30n+Ki0ye5HOXYYGK/fCZkhfYblDtmE3JRSEUB4i8gFUVxD/WO2YRUjZCLV8bYZMMWUi0TW17sEQalM1I5vnCx27TdxbLZuNBtFrNjjj0wKeLryhnbmZFEQ8COyqs9Qi4YUxybVCNGmvzVBikqds7oeLaHyqs9VF6dkUqEwQbqUHbIzEyTScSWIKMJPOaEDO1VoVnGzUm1nyn0ISYh78D7tK/JhbJjhksVXiQacg1Z+sfWZOUiH6U5bDaFOpRtkore6jed/E7hwEYV2a6/5UKui4IqVBZpETu0DgAzvNQG4MCBA1i9ejVWrVqFXbt2TfvdoiimfLq6ulp+yr+p+l1syu1Tpsdk3FuNscl3bJE4nr7azDbXYmIiC4m6ExM2eYVuj5cd84ULF7B69Wr84he/QK1Wwy233IJHH30UV155pbM62IyBzzNvX3X7KseWkNndrWDTL4WXmGeUsedsGaZ8GNP6XVxZNa3LtG4vyV+HDx/G5ZdfjsWLFwMA1q5di+Hh4aaOOedwpIt+uZKNT0Ngk3TnM+HDBRL01Ndd1FyQmCwak5jtsa2byab8Dy+OuV6vo6enZ/L/12o1HD58uOn3bXY0bEaR7e6uSbk29fhUfqbVtitZmIxnqrqcAiFl4XP+lWF/wyAFOpnXFNelTDBRJIazCB+E6heb/GK2x2fdMXWZbYwVXlxtmJQGpvLxkvxVq9UwOjo6+f/r9TpqtZqPqhRFURQlKbw45muvvRbHjh3D8ePHcfbsWezduxe9vb0+qlIURVGUpPASyp41axYefPBBfOtb38KFCxfw1a9+FUuXLvVRlaIoiqIkBcUDI4qiKIqifIS3B0YURVEURWkfdcyKoiiKQgSNY27nCU/FjJGREdx5551Ys2YN1q5diyeeeAIAcOrUKQwODqKvrw+Dg4OYmJiI3FL5XLhwAQMDA/jOd74DADh+/DhuvfVWrFq1Chs3bsTZs2cjt1A+p0+fxoYNG3DTTTfh5ptvxiuvvKK67Jhf/vKXWLt2LdatW4dNmzbhzJkzqssRoHDMFy5cwNatW7F7927s3bsXTz/9NN54443YzRLPzJkz8YMf/ADPPPMMfvOb3+BXv/oV3njjDezatQsrVqzAs88+ixUrVuhCyAFPPvkkrrjiisn//8gjj+Ab3/gGnnvuOVxyySX47W9/G7F1abBt2zbceOON+OMf/4g9e/bgiiuuUF12SL1ex5NPPonf/e53ePrpp3HhwgXs3btXdTkCFI754094zp49e/IJT6Uzuru7cc011wAA5syZgyVLlqBer2N4eBgDAwMAgIGBAezbty9mM8UzOjqKF154AbfccguAjx4R+Nvf/obVq1cDAL785S+rPnfI22+/jX/84x+TMp49ezYuueQS1WXHXLhwAR988AHOnz+PDz74AAsWLFBdjgCFY656wrNer0dsUXqcOHECR44cwfLlyzE+Po7u7m4AwIIFCzA+Ph65dbLZvn077r//fsyY8dF0OnnyJC655BLMmvXRbcSenh7V5w45ceIE5s2bh82bN2NgYABbtmzBe++9p7rskFqthm9+85v44he/iM9//vOYM2cOrrnmGtXlCFA4ZsUv7777LjZs2IAHHngAc+bMmfLf9J/t64w///nPmDdvHj7zmc/EbkrSnD9/Hv/5z39w++23Y2hoCBdddNEnwtaqy50xMTGB4eFhDA8P4+DBg3j//fdx8ODB2M3KEoq3svUJT3+cO3cOGzZsQH9/P/r6+gAA8+fPx9jYGLq7uzE2NoZ58+ZFbqVcXn75ZTz//PM4cOAAzpw5g3feeQfbtm3D6dOncf78ecyaNQujo6Oqzx3S09ODnp4eLF++HABw0003YdeuXarLDvnrX/+KT3/605My7Ovrw8svv6y6HAGKHbM+4emHoiiwZcsWLFmyBIODg5N/7+3txdDQEABgaGgIK1eujNVE8Xzve9/DgQMH8Pzzz+PRRx/F5z73OfzsZz/DZz/7WfzpT38CAPzhD39Qfe6QBQsWoKenB//9738BAC+++CKuuOIK1WWHLFy4EP/617/w/vvvoygKvPjii7jyyitVlyNA8/LX/v37sX379sknPO+5557YTRLPSy+9hDvuuANXXXXV5Pnnpk2bsGzZMmzcuBEjIyNYuHAhduzYgblz50ZurXz+/ve/4+c//zl27tyJ48eP47777sPExASuvvpqPPLII5g9e3bsJormyJEj2LJlC86dO4fFixfjJz/5CT788EPVZYc89thjeOaZZzBr1ixcffXV2LZtG+r1uupyYGgcs6IoiqIoJKFsRVEURVE+Qh2zoiiKohChjllRFEVRiFDHrCiKoihEqGNWFEVRFCLUMSuKoigKEeqYFUVRFIUIdcyKoiiKQsT/Ax4sAQUO4IIpAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b.plot_rewards()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b.plot_cumulative_regret()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ManualBenchmark:\n",
    "    def __init__(self, agent):\n",
    "        self.agent = agent\n",
    "    \n",
    "    def play(self):\n",
    "        agent.model.reset_states()\n",
    "        action, reward, timestep, done = 0, 0, 1, 0\n",
    "#         actions, rewards, values = [] * 3\n",
    "        while reward >= 0:\n",
    "            # action and reward at t - 1 and timestep at t\n",
    "            action, value, _ = agent._predict(action, reward, timestep)\n",
    "            reward = input(f\"LSTM chose {action}, give me a reward 0 or 1 (-1 ends the game)\")\n",
    "            reward = int(reward)\n",
    "            # rewards, values and actions at t\n",
    "#             rewards.append(reward)\n",
    "#             actions.append(action)\n",
    "#             values.append(value)\n",
    "            timestep += 1\n",
    "        return actions, rewards, values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "mb = ManualBenchmark(agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 0\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [0], give me a reward 0 or 1 (-1 ends the game) 1\n",
      "LSTM chose [1], give me a reward 0 or 1 (-1 ends the game) 0\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "Interrupted by user",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-60-d4a277ee9966>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplay\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[0m",
      "\u001b[0;32m<ipython-input-58-0d13af7fd5a5>\u001b[0m in \u001b[0;36mplay\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     10\u001b[0m             \u001b[0;31m# action and reward at t - 1 and timestep at t\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m             \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_predict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimestep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m             \u001b[0mreward\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"LSTM chose {action}, give me a reward 0 or 1 (-1 ends the game)\"\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     13\u001b[0m             \u001b[0mreward\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreward\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m             \u001b[0;31m# rewards, values and actions at t\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    861\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    862\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 863\u001b[0;31m             \u001b[0mpassword\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\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    864\u001b[0m         )\n\u001b[1;32m    865\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    891\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    892\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 893\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    894\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    895\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
     ]
    }
   ],
   "source": [
    "mb.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}