TicTacToe/TicTacToe using SARSA - part 3 - Agent vs. Dummy Agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FaceOff - SARSA agent vs. a dummy agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How well will my SARSA agents (Exact and NN) do against a dummy agent (an agent that randomly selects a free square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from BaseAgent import BaseAgent\n",
    "from BaseEnvironment import BaseEnvironment\n",
    "from RLGlue import RLGlue\n",
    "from Softmax import softmax\n",
    "from SimpleNN import SimpleKerasNN\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeEvnironment(BaseEnvironment):\n",
    "    def env_init(self, env_info={}):\n",
    "        pass\n",
    "    \n",
    "    def env_start(self):\n",
    "        self.terminal = False\n",
    "        self.board = np.zeros((3, 3))\n",
    "        self.reward_obs_term = (0, self.board, False)\n",
    "        return self.board.copy().reshape(9), self.get_mask()\n",
    "    \n",
    "    def env_step(self, agent_num, index):\n",
    "        if self.terminal:\n",
    "            print(\"Environment in terminal state, please restart.\")\n",
    "        \n",
    "        row, col = self.transform_index(index)\n",
    "        self.board[row, col] = agent_num\n",
    "        \n",
    "        if self.check_won(agent_num):\n",
    "            reward = 10\n",
    "            self.terminal = True\n",
    "        elif self.check_tie():\n",
    "            reward = 0\n",
    "            self.terminal = True\n",
    "        else:\n",
    "            reward = -1\n",
    "            \n",
    "        self.reward_obs_term_mask = (reward, self.board.copy().reshape(9), self.terminal, self.get_mask())\n",
    "        return self.reward_obs_term_mask\n",
    "    \n",
    "    def check_tie(self):\n",
    "        return (self.board == 0).sum() == 0\n",
    "    \n",
    "    def check_won(self, agent_num):\n",
    "        for row in self.board:\n",
    "            if np.array_equal(row, agent_num * np.ones((3,))):\n",
    "                return True\n",
    "        for col in self.board.T:\n",
    "            if np.array_equal(col, agent_num * np.ones((3,))):\n",
    "                return True\n",
    "        diag = np.diag(self.board)\n",
    "        if np.array_equal(diag, agent_num * np.ones((3,))):\n",
    "            return True\n",
    "        diag = np.diag(np.fliplr(self.board))\n",
    "        if np.array_equal(diag, agent_num * np.ones((3,))):\n",
    "            return True\n",
    "        return False\n",
    "    \n",
    "    def env_cleanup(self):\n",
    "        pass\n",
    "    \n",
    "    def env_message(self, message):\n",
    "        if message == 0:  # return available indices mask\n",
    "            return self.get_mask()\n",
    "            \n",
    "    def get_mask(self):\n",
    "        rows, cols = np.where(self.board == 0)\n",
    "        indices = rows * 3 + cols\n",
    "        mask = np.zeros((9,))\n",
    "        mask[indices] = 1\n",
    "        return mask.astype(int)\n",
    "    \n",
    "    def transform_index(self, index):\n",
    "        return index // 3, index % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DummyAgent(BaseAgent): \n",
    "    def agent_init(self, agent_init_info):\n",
    "        self.num_actions = agent_init_info[\"num_actions\"]\n",
    "        self.rand_generator = np.random.RandomState(agent_init_info[\"seed\"])\n",
    "        \n",
    "        self.last_state = None\n",
    "        self.last_action = None\n",
    "\n",
    "    def policy(self, state, mask):\n",
    "        probs = mask / mask.sum()\n",
    "        action = self.rand_generator.choice(self.num_actions, p=probs.squeeze())\n",
    "        return action\n",
    "\n",
    "    def agent_start(self, state, mask):\n",
    "        return self.policy(state, mask)\n",
    "\n",
    "    def agent_step(self, reward, state, mask):\n",
    "        return self.policy(state, mask)\n",
    "    \n",
    "    def agent_end(self, reward):\n",
    "        pass\n",
    "        \n",
    "    def agent_message(self, message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NN Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeAgent(BaseAgent):\n",
    "    def agent_init(self, agent_init_info):\n",
    "        self.discount = agent_init_info[\"discount\"]        \n",
    "        self.network = agent_init_info[\"network\"]\n",
    "        self.tau = agent_init_info[\"tau\"]\n",
    "        self.num_actions = agent_init_info[\"num_actions\"]\n",
    "        \n",
    "        self.rand_generator = np.random.RandomState(agent_init_info[\"seed\"])\n",
    "        \n",
    "        self.last_state = None\n",
    "        self.last_action = None\n",
    "\n",
    "    def policy(self, state, mask):\n",
    "        action_values = self.network.predict(state)\n",
    "        probs = softmax(action_values, self.tau) \n",
    "        probs *= mask\n",
    "        probs /= probs.sum()\n",
    "        action = self.rand_generator.choice(self.num_actions, p=probs.squeeze())\n",
    "        return action\n",
    "\n",
    "    def agent_start(self, state, mask):\n",
    "        self.last_state = state.reshape(1, -1)\n",
    "        self.last_action = self.policy(self.last_state, mask)\n",
    "        return self.last_action        \n",
    "\n",
    "    def agent_step(self, reward, state, mask):\n",
    "        # SARSA\n",
    "        state = state.reshape(1, -1)\n",
    "        action = self.policy(state, mask)\n",
    "        target = self.network.predict(self.last_state)[0]\n",
    "        correct = reward + self.discount * self.network.predict(state)[0][action]\n",
    "        target[self.last_action] = correct\n",
    "        self.network.train(self.last_state, target.reshape(1,-1))\n",
    "        \n",
    "        self.last_state = state\n",
    "        self.last_action = action\n",
    "        return action\n",
    "    \n",
    "    def agent_end(self, reward):\n",
    "        # SARSA\n",
    "        target = self.network.predict(self.last_state)[0]\n",
    "        target[self.last_action] = reward\n",
    "        self.network.train(self.last_state, target.reshape(1, -1))\n",
    "        \n",
    "    def agent_message(self, message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function approximator - a Feed-Forward NN \n",
    "layers = [9, 36, 36, 9]\n",
    "nn = SimpleKerasNN(layers)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "nn.model.load_weights(\"agent-5-nn-9x36x36x9.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "rlglue = RLGlue(TicTacToeEvnironment, TicTacToeAgent, DummyAgent)\n",
    "agent1_info = {\"discount\": 1, \"network\": nn, \"tau\": 1, \"num_actions\": 9, \"seed\": 176}\n",
    "agent2_info = {\"num_actions\": 9, \"seed\": 241}\n",
    "env_info = {}\n",
    "rlglue.rl_init(agent1_info, agent2_info, env_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(rlglue, runs):\n",
    "    rewards = np.zeros((runs, 2))\n",
    "    starts = np.zeros((runs, 1))\n",
    "    final_states = np.zeros((runs, 9))\n",
    "    for i in tqdm(range(runs)):\n",
    "        rlglue.rl_episode(10)\n",
    "        rewards[i, :], starts[i, :], final_states[i, :] =  rlglue.rl_return()\n",
    "    return rlglue, rewards, starts, final_states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 10000/10000 [00:54<00:00, 182.59it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(rlglue, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8696, 815)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SARSA agent wins, Dummy agent wins\n",
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.669938650306749"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ratio between SARSA agent and Dummy agent\n",
    "(rew[:,0] > 0).sum() / (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SARSA agent seems to outpreform dummy agent by a x10 factor!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,5))\n",
    "plt.plot(rew[-100:,])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exact Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeExactAgent(BaseAgent):\n",
    "    def agent_init(self, agent_init_info):    \n",
    "        self.learning_step = agent_init_info[\"learning_step\"]\n",
    "        self.num_actions = agent_init_info[\"num_actions\"]\n",
    "        self.rand_generator = np.random.RandomState(agent_init_info[\"seed\"])\n",
    "        self.states = {}\n",
    "        self.last_state = None\n",
    "        self.last_action = None\n",
    "\n",
    "    def policy(self, q, mask):\n",
    "        # greedy policy, breaks ties randomly\n",
    "        pos = np.exp(q - np.max(q)) * mask\n",
    "        return self.argmax(pos)\n",
    "\n",
    "    def argmax(self, array):\n",
    "        m = np.max(array)\n",
    "        ind = np.where(array == m)[0]\n",
    "        return self.rand_generator.choice(ind)\n",
    "    \n",
    "    def get_q(self, state, mask):\n",
    "        if str(state) in self.states:\n",
    "            q = self.states[str(state)]\n",
    "        else:\n",
    "            q = np.zeros_like(state)\n",
    "            q[mask == 1] = 1\n",
    "        return q\n",
    "    \n",
    "    def agent_start(self, state, mask):\n",
    "        self.last_state = state\n",
    "        q = self.get_q(state, mask)\n",
    "        self.states[str(self.last_state)] = q\n",
    "        self.last_action = self.policy(q, mask)\n",
    "        return self.last_action        \n",
    "\n",
    "    def agent_step(self, reward, state, mask):\n",
    "        # SARSA\n",
    "        q = self.get_q(state, mask)\n",
    "        action = self.policy(q, mask)\n",
    "        q_s_ = q[action]\n",
    "        q_s = self.states[str(self.last_state)][self.last_action]\n",
    "        self.states[str(self.last_state)][self.last_action] += self.learning_step * (reward + q_s_ - q_s)\n",
    "\n",
    "        self.last_state = state\n",
    "        self.states[str(self.last_state)] = q\n",
    "        self.last_action = action\n",
    "        return action\n",
    "    \n",
    "    def agent_end(self, reward):\n",
    "        # SARSA\n",
    "        q_s = self.states[str(self.last_state)][self.last_action]\n",
    "        self.states[str(self.last_state)][self.last_action] += self.learning_step * (reward - q_s)\n",
    "        \n",
    "    def agent_message(self, message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "rlglue = RLGlue(TicTacToeEvnironment, TicTacToeExactAgent, DummyAgent)\n",
    "agent1_info = {\"learning_step\": 1, \"num_actions\": 9, \"seed\": 12}\n",
    "agent2_info = {\"num_actions\": 9, \"seed\": 241}\n",
    "env_info = {}\n",
    "rlglue.rl_init(agent1_info, agent2_info, env_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reload states into our exact agent\n",
    "fr = open('agent-exact-states','rb')\n",
    "rlglue.agents[-1][\"agent\"].states = pickle.load(fr)\n",
    "fr.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 10000/10000 [00:27<00:00, 360.79it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(rlglue, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9187, 0)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SARSA agent wins, Dummy agent wins\n",
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see here that the dummy agent never won a game against the exact agent, and that the exact agent won 9187 times out of 10k. This clearly shows the superiority of the exact agent both against the dummy agent, and against the NN agent."
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}