simple-halite-deep-qlearning-experience-replay.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Turtle runs - RL with deep Q-learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import math\n",
    "import random\n",
    "import numpy as np\n",
    "from collections import namedtuple\n",
    "from time import time\n",
    "\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "import keras.layers as L\n",
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "keras.backend.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "actions = ['N', 'E', 'S', 'W', 'O']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Turtle():\n",
    "    def __init__(self, position, halite):\n",
    "        self.position = position\n",
    "        self.halite = halite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GameState():\n",
    "    def __init__(self, game_map, position, halite, turn):\n",
    "        self.game_map = game_map\n",
    "        self.position = position\n",
    "        self.halite = halite\n",
    "        self.turn = turn\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        return (self.game_map == other.game_map).all() and self.position == other.position and self.halite == other.halite and self.turn == other.turn\n",
    "\n",
    "    def get_nn_repr(self):\n",
    "        hal_std_scaled = (self.game_map.reshape(-1,) - 500) / 1000\n",
    "        pos_indicator = [0] * 25\n",
    "        pos_indicator[self.position[0] * 5 + self.position[1]] = 1\n",
    "        return np.array(list(hal_std_scaled) + pos_indicator + [self.halite / 1000, self.turn / 50])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleHalite():\n",
    "    def __init__(self, height, width, start_pos):\n",
    "        np.random.seed(42)\n",
    "        self.game_map = np.random.randint(1, 1000, size=(height, width))\n",
    "        self.game_map[start_pos] = 0\n",
    "        self.orig_map = self.game_map.copy()\n",
    "        self.turtle = Turtle(start_pos, 0)\n",
    "        self.turn = 1\n",
    "        self.max_turns = 50\n",
    "        self.halite = 0\n",
    "        self.base = start_pos\n",
    "        self.height = height\n",
    "        self.width = width\n",
    "        self.actions = ['N', 'E', 'S', 'W', 'O']\n",
    "    \n",
    "    def get_state(self):\n",
    "        game_state = GameState(self.game_map.copy(), self.turtle.position, self.turtle.halite, self.turn)\n",
    "        return game_state.get_nn_repr()\n",
    "    \n",
    "    def get_possible_actions(self):\n",
    "        return self.actions\n",
    "    \n",
    "    def reset(self):\n",
    "        self.game_map = self.orig_map.copy()\n",
    "        self.turtle = Turtle(self.base, 0)\n",
    "        self.turn = 1\n",
    "        self.halite = 0\n",
    "        return self.get_state()\n",
    "        \n",
    "    def step(self, action):\n",
    "        action = actions[action]\n",
    "        reward = 0\n",
    "        if action == 'O':\n",
    "            mined_halite = min(1000 - self.turtle.halite, \n",
    "                               math.ceil(self.game_map[self.turtle.position] / 4))\n",
    "            self.game_map[self.turtle.position] -= mined_halite\n",
    "            self.turtle.halite += mined_halite\n",
    "        else:\n",
    "            if action == 'N':\n",
    "                cost_halite = self.game_map[self.turtle.position] // 10\n",
    "                new_pos = tuple([sum(x) for x in zip(self.turtle.position, (-1, 0))])\n",
    "            elif action == 'E':\n",
    "                cost_halite = self.game_map[self.turtle.position] // 10\n",
    "                new_pos = tuple([sum(x) for x in zip(self.turtle.position, (0, 1))])\n",
    "            elif action == 'S':\n",
    "                cost_halite = self.game_map[self.turtle.position] // 10\n",
    "                new_pos = tuple([sum(x) for x in zip(self.turtle.position, (1, 0))])\n",
    "            elif action == 'W':\n",
    "                cost_halite = self.game_map[self.turtle.position] // 10\n",
    "                new_pos = tuple([sum(x) for x in zip(self.turtle.position, (0, -1))])\n",
    "            #print(cost_halite, self.turtle.halite)\n",
    "            if cost_halite <= self.turtle.halite:\n",
    "                #print(\"moving turtle to {}\".format(new_pos))\n",
    "                self.turtle = Turtle(new_pos, self.turtle.halite - cost_halite)\n",
    "            else:\n",
    "                mined_halite = min(1000 - self.turtle.halite, \n",
    "                                   math.ceil(self.game_map[self.turtle.position] / 4))\n",
    "                self.game_map[self.turtle.position] -= mined_halite\n",
    "                self.turtle.halite += mined_halite\n",
    "        self.turtle.position = (self.turtle.position[0] % self.width, \n",
    "                                self.turtle.position[1] % self.height)\n",
    "        if self.turtle.position == self.base:\n",
    "            self.halite += self.turtle.halite\n",
    "            reward = self.turtle.halite\n",
    "            self.turtle.halite = 0\n",
    "        self.turn += 1\n",
    "        #print(\"turn increment to {}\".format(self.turn))\n",
    "        return self.get_state(), reward, self.turn == self.max_turns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Needs to be a tuple rather than a list as start_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "game = SimpleHalite(5, 5, (2, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.397, -0.064,  0.361, -0.229, -0.393, -0.428,  0.201, -0.479,\n",
       "        0.115, -0.378, -0.033, -0.285, -0.5  , -0.041, -0.412, -0.127,\n",
       "       -0.4  ,  0.372,  0.164, -0.369,  0.162, -0.191,  0.27 , -0.156,\n",
       "       -0.008,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,\n",
       "        0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  1.   ,  0.   ,  0.   ,\n",
       "        0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,\n",
       "        0.   ,  0.   ,  0.   ,  0.02 ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q Learning "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer(object):\n",
    "    def __init__(self, size):\n",
    "        \"\"\"Create Replay buffer.\n",
    "        Parameters\n",
    "        ----------\n",
    "        size: int\n",
    "            Max number of transitions to store in the buffer. When the buffer\n",
    "            overflows the old memories are dropped.\n",
    "        \"\"\"\n",
    "        self._storage = []\n",
    "        self._maxsize = size\n",
    "        self._next_idx = 0\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._storage)\n",
    "\n",
    "    def add(self, obs_t, action, reward, obs_tp1, done):\n",
    "        data = (obs_t, action, reward, obs_tp1, done)\n",
    "\n",
    "        if self._next_idx >= len(self._storage):\n",
    "            self._storage.append(data)\n",
    "        else:\n",
    "            self._storage[self._next_idx] = data\n",
    "        self._next_idx = (self._next_idx + 1) % self._maxsize\n",
    "\n",
    "    def _encode_sample(self, idxes):\n",
    "        obses_t, actions, rewards, obses_tp1, dones = [], [], [], [], []\n",
    "        for i in idxes:\n",
    "            data = self._storage[i]\n",
    "            obs_t, action, reward, obs_tp1, done = data\n",
    "            obses_t.append(np.array(obs_t, copy=False))\n",
    "            actions.append(np.array(action, copy=False))\n",
    "            rewards.append(reward)\n",
    "            obses_tp1.append(np.array(obs_tp1, copy=False))\n",
    "            dones.append(done)\n",
    "        return np.array(obses_t), np.array(actions), np.array(rewards), np.array(obses_tp1), np.array(dones)\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        \"\"\"Sample a batch of experiences.\n",
    "        Parameters\n",
    "        ----------\n",
    "        batch_size: int\n",
    "            How many transitions to sample.\n",
    "        Returns\n",
    "        -------\n",
    "        obs_batch: np.array\n",
    "            batch of observations\n",
    "        act_batch: np.array\n",
    "            batch of actions executed given obs_batch\n",
    "        rew_batch: np.array\n",
    "            rewards received as results of executing act_batch\n",
    "        next_obs_batch: np.array\n",
    "            next set of observations seen after executing act_batch\n",
    "        done_mask: np.array\n",
    "            done_mask[i] = 1 if executing act_batch[i] resulted in\n",
    "            the end of an episode and 0 otherwise.\n",
    "        \"\"\"\n",
    "        idxes = [random.randint(0, len(self._storage) - 1) for _ in range(batch_size)]\n",
    "        return self._encode_sample(idxes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent():\n",
    "    def __init__(self, name, state_shape, n_actions, epsilon=0, reuse=False):\n",
    "        \"\"\"A simple DQN agent\"\"\"\n",
    "        with tf.variable_scope(name, reuse=reuse):\n",
    "            self.network = keras.models.Sequential()\n",
    "            self.network.add(L.InputLayer(input_shape=state_shape))\n",
    "            self.network.add(L.Dense(256, activation='relu'))\n",
    "            self.network.add(L.Dense(256, activation='relu'))\n",
    "            self.network.add(L.Dense(len(game.get_possible_actions())))\n",
    "\n",
    "            # prepare a graph for agent step\n",
    "            self.state_t = tf.placeholder('float32', [None,] + list(state_shape))\n",
    "            self.qvalues_t = self.get_symbolic_qvalues(self.state_t)\n",
    "\n",
    "            self.weights = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=name)\n",
    "            self.epsilon = epsilon\n",
    "\n",
    "    def get_symbolic_qvalues(self, state_t):\n",
    "        \"\"\"takes agent's observation, returns qvalues. Both are tf Tensors\"\"\"\n",
    "        qvalues = self.network(state_t)\n",
    "\n",
    "        assert tf.is_numeric_tensor(qvalues) and qvalues.shape.ndims == 2, \\\n",
    "            \"please return 2d tf tensor of qvalues [you got %s]\" % repr(qvalues)\n",
    "        assert int(qvalues.shape[1]) == n_actions\n",
    "        \n",
    "        return qvalues\n",
    "    \n",
    "    def get_qvalues(self, state_t):\n",
    "        \"\"\"Same as symbolic step except it operates on numpy arrays\"\"\"\n",
    "        sess = tf.get_default_session()\n",
    "        return sess.run(self.qvalues_t, {self.state_t: state_t})\n",
    "    \n",
    "    def sample_actions(self, qvalues):\n",
    "        \"\"\"pick actions given qvalues. Uses epsilon-greedy exploration strategy. \"\"\"\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice([0, 1], batch_size, p = [1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(agent, game, exp_replay, n_steps=1):\n",
    "    \"\"\"\n",
    "    Play the game for exactly n steps, record every (s,a,r,s', done) to replay buffer. \n",
    "    Whenever game ends, add record with done=True and reset the game.\n",
    "    :returns: return sum of rewards over time\n",
    "    \n",
    "    Note: please do not env.reset() unless env is done.\n",
    "    It is guaranteed that env has done=False when passed to this function.\n",
    "    \"\"\"\n",
    "    # State at the beginning of rollout\n",
    "    s = game.get_state()\n",
    "    \n",
    "    # Play the game for n_steps as per instructions above\n",
    "    reward = 0.0\n",
    "    for t in range(n_steps):\n",
    "        # get agent to pick action given state s\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        action = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, done = game.step(action)\n",
    "        \n",
    "        # add to replay buffer\n",
    "        exp_replay.add(s, action, r, next_s, done)\n",
    "        reward += r\n",
    "        if done:\n",
    "            s = game.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "    return reward    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_weigths_into_target_network(agent, target_network):\n",
    "    \"\"\" assign target_network.weights variables to their respective agent.weights values. \"\"\"\n",
    "    assigns = []\n",
    "    for w_agent, w_target in zip(agent.weights, target_network.weights):\n",
    "        assigns.append(tf.assign(w_target, w_agent, validate_shape=True))\n",
    "    tf.get_default_session().run(assigns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_actions = len(game.get_possible_actions())\n",
    "state_dim = (len(game.reset()),)\n",
    "agent = DQNAgent(\"dqn_agent\", state_dim, n_actions, epsilon=0.5)\n",
    "target_network = DQNAgent(\"target_network\", state_dim, n_actions)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_ph = tf.placeholder(tf.float32, shape=(None,) + state_dim)\n",
    "actions_ph = tf.placeholder(tf.int32, shape=[None])\n",
    "rewards_ph = tf.placeholder(tf.float32, shape=[None])\n",
    "next_obs_ph = tf.placeholder(tf.float32, shape=(None,) + state_dim)\n",
    "is_done_ph = tf.placeholder(tf.float32, shape=[None])\n",
    "\n",
    "is_not_done = 1 - is_done_ph\n",
    "gamma = 0.99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_qvalues = agent.get_symbolic_qvalues(obs_ph)\n",
    "current_action_qvalues = tf.reduce_sum(tf.one_hot(actions_ph, n_actions) * current_qvalues, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute q-values for NEXT states with target network\n",
    "next_qvalues_target = target_network.get_symbolic_qvalues(next_obs_ph) \n",
    "\n",
    "# compute state values by taking max over next_qvalues_target for all actions\n",
    "next_state_values_target = tf.reduce_max(next_qvalues_target, axis=-1)\n",
    "\n",
    "# compute Q_reference(s,a) as per formula above.\n",
    "reference_qvalues = rewards_ph + gamma * next_state_values_target * is_not_done\n",
    "\n",
    "# Define loss function for sgd.\n",
    "td_loss = (current_action_qvalues - reference_qvalues) ** 2\n",
    "td_loss = tf.reduce_mean(td_loss)\n",
    "\n",
    "train_step = tf.train.AdamOptimizer(1e-3).minimize(td_loss, var_list=agent.weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "%matplotlib inline\n",
    "mean_rw_history = []\n",
    "td_loss_history = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_batch(exp_replay, batch_size):\n",
    "    obs_batch, act_batch, reward_batch, next_obs_batch, is_done_batch = exp_replay.sample(batch_size)\n",
    "    return {\n",
    "        obs_ph:obs_batch, actions_ph:act_batch, rewards_ph:reward_batch, \n",
    "        next_obs_ph:next_obs_batch, is_done_ph:is_done_batch\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(game, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    \"\"\" Plays n_games full games. If greedy, picks actions as argmax(qvalues). Returns mean reward. \"\"\"\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = game.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            \n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done = game.step(action)\n",
    "            reward += r\n",
    "            if done: break\n",
    "                \n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64979.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_replay = ReplayBuffer(5*10**5)\n",
    "play_and_record(agent, game, exp_replay, n_steps=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 500000, epsilon = 0.40895\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1728x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1728x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 10000/10000 [14:43<00:00, 11.32it/s]\n"
     ]
    }
   ],
   "source": [
    "for i in trange(10**4):\n",
    "    # play\n",
    "    play_and_record(agent, game, exp_replay, 100)\n",
    "    \n",
    "    # train\n",
    "    _, loss_t = sess.run([train_step, td_loss], sample_batch(exp_replay, batch_size=128))\n",
    "    td_loss_history.append(loss_t)\n",
    "    \n",
    "    # adjust agent parameters\n",
    "    if i % 500 == 0:\n",
    "        load_weigths_into_target_network(agent, target_network)\n",
    "        agent.epsilon = max(agent.epsilon * 0.99, 0.01)\n",
    "        mean_rw_history.append(evaluate(SimpleHalite(5, 5, (2, 2)), agent, n_games=3))\n",
    "    \n",
    "    if i % 100 == 0:\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" % (len(exp_replay), agent.epsilon))\n",
    "        #print(\"Current mean reward: {}\".format(mean_rw_history[-1]))\n",
    "        plt.figure(figsize=[24, 4])\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.title(\"mean reward per game\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(loss_t)\n",
    "        plt.figure(figsize=[24, 4])\n",
    "        plt.subplot(1,2,2)\n",
    "        plt.title(\"TD loss history (moving average)\")\n",
    "        plt.plot(DataFrame(td_loss_history).ewm(span=100, min_periods=100).mean())\n",
    "        #plt.plot(pd.ewma(np.array(td_loss_history), span=100, min_periods=100))\n",
    "        plt.grid()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.network.save_weights('./turtle_5x5_dqn.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1720.9"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(SimpleHalite(5, 5, (2, 2)), agent, n_games=10, greedy=False)"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}