a2c_meta-alex.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",
    "import scipy.stats as stats\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": 3,
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eager Execution: True\n",
      "1 + 2 + 3 + 4 + 5 = tf.Tensor(15, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "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": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "\n",
    "class dist_env():\n",
    "\n",
    "    def __init__(self, n_timesteps=1000, keep_record=True):\n",
    "        self.keep_record = keep_record\n",
    "        self.n_timesteps = n_timesteps\n",
    "        self.n_states = 4\n",
    "        self.stay_prob = 1. - 1./20.\n",
    "        self.M_weighting_off_diagonal = 0.1\n",
    "        self.wait_reward = -0.1\n",
    "        self.wrong_reward = -1.\n",
    "        self.right_reward = +1.\n",
    "        self.observation_sigma = 1.\n",
    "        self.reset()\n",
    "\n",
    "\n",
    "    def reset(self, ):\n",
    "        self.reset_M()\n",
    "        self.reset_M_random()\n",
    "        self.done = False\n",
    "        self.t = 0\n",
    "        reward = self.wait_reward\n",
    "        observation = 0\n",
    "        self.state = np.random.randint(0, self.n_states)\n",
    "        \n",
    "        self._s_hist = np.array([self.state])\n",
    "        self._r_hist = np.array([])\n",
    "        self._o_hist = np.array([])\n",
    "        \n",
    "        return observation, reward, self.done, self.t        \n",
    "\n",
    "\n",
    "    def reset_M(self, ):\n",
    "        self.trans_prob = (1.-self.stay_prob) / (self.n_states-1)\n",
    "        self.M = np.eye(self.n_states) * self.stay_prob\n",
    "        self.M[np.logical_not(np.eye(self.M.shape[0], dtype=bool))] = self.trans_prob\n",
    "\n",
    "\n",
    "    def reset_M_random(self, ):\n",
    "        M = np.identity(self.n_states)\n",
    "        M += self.M_weighting_off_diagonal*np.random.lognormal(size=M.shape)\n",
    "        M /=np.sum(M, axis=1, keepdims=True)\n",
    "        self.M = M\n",
    "\n",
    "\n",
    "    def step(self, action):\n",
    "        assert not self.done\n",
    "        state = self.state\n",
    "        reward = self.comp_reward(action, state)\n",
    "        new_state = self.comp_transition(action, state)\n",
    "        observation = self.compute_observation(new_state)\n",
    "        \n",
    "        self.t += 1\n",
    "        if self.t >= self.n_timesteps:\n",
    "            self.done = True\n",
    "        self.state = new_state\n",
    "        \n",
    "        if self.keep_record:\n",
    "            self._r_hist = np.append(self._r_hist, reward)\n",
    "            self._s_hist = np.append(self._s_hist, new_state)\n",
    "            self._o_hist = np.append(self._o_hist, observation)\n",
    "            \n",
    "        return observation, reward, self.done, self.t\n",
    "\n",
    "\n",
    "    def comp_reward(self, action, state):\n",
    "        if action == self.n_states:\n",
    "            reward = self.wait_reward\n",
    "        elif action == state:\n",
    "            reward = self.right_reward\n",
    "        else:\n",
    "            reward = self.wrong_reward\n",
    "                    \n",
    "        return reward\n",
    "\n",
    "\n",
    "    def comp_transition(self, action, state):\n",
    "        new_state = np.random.choice(self.n_states, p=self.M[state,:])\n",
    "        if action != self.n_states:\n",
    "            while new_state == state:\n",
    "                new_state = np.random.choice(self.n_states, p=self.M[state,:])\n",
    "        return new_state\n",
    "\n",
    "\n",
    "    def compute_observation(self, state):\n",
    "        observation = stats.norm.rvs(loc=state, scale=self.observation_sigma)\n",
    "        return observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fd77c7b39e8>]"
      ]
     },
     "execution_count": 120,
     "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": [
    "env = dist_env()\n",
    "\n",
    "\n",
    "for i in range(1000):\n",
    "    env.step(0)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(env._s_hist)\n",
    "plt.plot(env._r_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False]),\n",
       " array([1, 3, 1, 3, 0, 2, 1, 2, 1, 0, 1, 2, 1, 0, 1]))"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.diff(env._s_hist) == 0)[:15], env._s_hist[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([], dtype=int64), array([], dtype=int64))"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(env._s_hist[:-1][(np.diff(env._s_hist) == 0)], return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, -0.1, False, 0)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.614174463309825, -1.0, False, 1)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.step(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(tf.keras.Model):\n",
    "    def __init__(self, num_actions, batch_size=1, n_timesteps=None, n_features=8, 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.noise = kl.GaussianNoise(0.1)\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",
    "        output = self.lstm(inputs)\n",
    "        value = self.value(output)\n",
    "        policy = self.policy(output)\n",
    "#         noise = self.noise(output, training=True)\n",
    "#         policy = self.policy(noise)\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": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([3 3], shape=(2,), dtype=int64) tf.Tensor([-0.03366502 -0.05733382], shape=(2,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Verify everything works by sampling two actions.\n",
    "state_observation, reward, done, timestep = env.reset()\n",
    "model = Model(env.n_states + 1, n_features=8)\n",
    "action = 0\n",
    "action = tf.one_hot(action, env.n_states + 1)\n",
    "observation = np.concatenate([\n",
    "        [[state_observation], [state_observation]],\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 [0.01206078] -0.42064278189354076 -1.0\n",
      "1 [0.0359822] 2.0441342356947856 -1.0\n"
     ]
    }
   ],
   "source": [
    "# Verify everything works by sampling two actions with state reset.\n",
    "state_observation, reward, done, timestep = env.reset()\n",
    "model = Model(env.n_states + 1, n_features=8)\n",
    "\n",
    "action = 0\n",
    "for _ in range(2):\n",
    "    action = tf.one_hot(action, env.n_states + 1)\n",
    "    single_input = np.concatenate([\n",
    "        [[state_observation]],\n",
    "        [[reward]],\n",
    "        [action],\n",
    "        [[timestep]]], 1)\n",
    "    single_input = tf.cast(single_input, dtype=tf.float32)\n",
    "    single_input = tf.expand_dims(single_input, [1])\n",
    "\n",
    "    action, value = model.predict_action_value(single_input)\n",
    "    action = np.squeeze(action)\n",
    "    state_observation, reward, done, timestep = env.step(action)\n",
    "    print(action, value.numpy(), state_observation, reward)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, model, env, learning_rate=1e-3, gamma=0.8, value_coefficient=0.2, entropy_coefficient=.002, name='a2c_agent_alex', 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 =  env\n",
    "        self.name = name\n",
    "        self.model = model(env.n_states + 1, 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, state_observation, reward, timestep):\n",
    "        action = np.squeeze(action)\n",
    "        action = tf.one_hot(action, self.env.n_states + 1)\n",
    "        single_input = np.concatenate([\n",
    "            [[state_observation]],\n",
    "            [[reward]],\n",
    "            [action],\n",
    "            [[timestep]]], 1)\n",
    "        single_input = tf.cast(single_input, dtype=tf.float32)\n",
    "        single_input = tf.expand_dims(single_input, [1])\n",
    "        new_action, value = self.model.predict_action_value(single_input)\n",
    "        return new_action, value, single_input\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, observations, rewards, values, inputs = 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], observations[-1], rewards[-1], inputs[-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(inputs, [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):\n",
    "        state_observation, reward, done, timestep = self.env.reset()\n",
    "\n",
    "        action = 4 # I don't know\n",
    "        # Storage helpers for a single batch of data.\n",
    "        actions = np.empty(self.env.n_timesteps, dtype=np.int32)\n",
    "        rewards, values, observations = np.empty((3, self.env.n_timesteps))\n",
    "        inputs = np.empty((self.env.n_timesteps, 1, 8))\n",
    "        \n",
    "        self.model.reset_states()\n",
    "        step = 0\n",
    "        while not done:\n",
    "            # action and reward at t - 1 and timestep at t\n",
    "            action, value, inputs[step] = self._predict(action, state_observation, reward, timestep + 1)\n",
    "            state_observation, reward, done, timestep = self.env.step(action)\n",
    "            # rewards, values and actions at t\n",
    "            observations[step] = state_observation\n",
    "            rewards[step] = reward\n",
    "            actions[step] = action\n",
    "            values[step] = value\n",
    "            step += 1\n",
    "        return actions, observations, rewards, values, inputs\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": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-30.800000000000026\n"
     ]
    }
   ],
   "source": [
    "# logging.getLogger().setLevel(logging.INFO)\n",
    "# logging.getLogger().setLevel(logging.DEBUG)\n",
    "logging.getLogger().setLevel(logging.WARNING)\n",
    "\n",
    "env = dist_env(n_timesteps=100)\n",
    "agent = Agent(Model, env)\n",
    "\n",
    "actions, observations, rewards, values, inputs = agent.run_episode()\n",
    "print(sum(rewards))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([50.,  0.,  0.,  0., 28.,  0.,  0.,  0.,  0., 22.]),\n",
       " array([-1. , -0.8, -0.6, -0.4, -0.2,  0. ,  0.2,  0.4,  0.6,  0.8,  1. ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 130,
     "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.hist(rewards)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c608fdf6781476489ad423fb9193ba6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Finished training! Testing...\n",
      "Total Episode Reward: 34 out of 100\n"
     ]
    }
   ],
   "source": [
    "training_history = agent.train(20000)\n",
    "\n",
    "print(\"Finished training! Testing...\")\n",
    "print(\"Total Episode Reward: %d out of 100\" % agent.run_episode()[2].sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# or load weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.save_agent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Total Reward')"
      ]
     },
     "execution_count": 133,
     "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": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Benchmark:\n",
    "    def __init__(self, agent, env, n_episodes=300):\n",
    "        assert env.keep_record\n",
    "        self.agent = agent\n",
    "        self.env = env\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",
    "        observations = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        values = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        states = np.empty((self.n_episodes, env.n_timesteps))\n",
    "        for episode in tqdm(range(self.n_episodes)):\n",
    "            actions[episode], observations[episode], rewards[episode], values[episode], _ = agent.run_episode()\n",
    "            states[episode] = self.env._s_hist[:-1]\n",
    "        self.episodes = {\n",
    "            'rewards': rewards,\n",
    "            'observations': observations,\n",
    "            'actions': actions,\n",
    "            'values': values,\n",
    "            'states': states\n",
    "        }\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'], self.episodes['states'])\n",
    "        \n",
    "        for i, (actions_episode, states_episode) in enumerate(_itr):\n",
    "            for j, (action, state) in enumerate(zip(actions_episode, states_episode)):\n",
    "                actions_optimal[i, j] = action == state\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": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d65c3c07a9948628d75634ad446f601",
       "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, env)\n",
    "b.evaluate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "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": 137,
   "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_rewards()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1. , -0.1,  1. ])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(b.episodes['rewards'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "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",
    "        state_observation, reward, done, timestep = 0,0,0,0\n",
    "        action = 4\n",
    "        while reward > -10:\n",
    "            # action and reward at t - 1 and timestep at t\n",
    "            action, value, inputs = agent._predict(action, state_observation, reward, timestep + 1)\n",
    "            state_observation, reward = input(f\"LSTM chose {action}, give me observation and reward\").split()\n",
    "            state_observation = float(state_observation)\n",
    "            reward = float(reward)\n",
    "            # rewards, values and actions at t\n",
    "#             rewards.append(reward)\n",
    "#             actions.append(action)\n",
    "#             values.append(value)\n",
    "            timestep += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "mb = ManualBenchmark(agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "LSTM chose [0], give me observation and reward 2.5 1\n",
      "LSTM chose [3], give me observation and reward .5 -1\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-62-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-60-76634d6051cd>\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[0minputs\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[0mstate_observation\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;36m1\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[0mstate_observation\u001b[0m\u001b[0;34m,\u001b[0m \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 observation and reward\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\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[1;32m     13\u001b[0m             \u001b[0mstate_observation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_observation\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[0mreward\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\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[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
}