TicTacToe/TicTacToe using SARSA - part 2.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TicTacToe using SARSA - part 2.5 - Smaller NN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In part 2 I used a 9x36x36x9 NN architecture to create a pretty good TicTacToe AI agent. Here I will try to create use an even smaller network. In order to speed learning, I will try to give my NN agent the best teacher he can play against - the exact agent from part 1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No changes for modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Environment has to support both exact agent, and NN agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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\n",
    "    \n",
    "    def transform_index(self, index):\n",
    "        return index // 3, index % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeNNAgent(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": 6,
   "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": "markdown",
   "metadata": {},
   "source": [
    "Let's try now using a 9x12x12x9 network. This has a bit less than 400 parameters. \n",
    "\n",
    "![nn](nn12x12.svg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function approximator - a Feed-Forward NN \n",
    "layers = [9, 12, 12, 9]\n",
    "nn = SimpleKerasNN(layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "rlglue = RLGlue(TicTacToeEvnironment, TicTacToeExactAgent, TicTacToeNNAgent)\n",
    "agent1_info = {\"learning_step\": 1, \"num_actions\": 9, \"seed\": 12}\n",
    "agent2_info = {\"discount\": 1, \"network\": nn, \"tau\": 1, \"num_actions\": 9, \"seed\": 176}\n",
    "env_info = {}\n",
    "rlglue.rl_init(agent1_info, agent2_info, env_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "fr = open('agent-exact-states','rb')\n",
    "rlglue.agents[-1][\"agent\"].states = pickle.load(fr)\n",
    "fr.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "runs = 20000  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 20000/20000 [02:37<00:00, 127.13it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(rlglue, runs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1.]), array([ 1.,  1., -1., -1., -1.,  1.,  1.,  1., -1.]))"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "starts[-1], states[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15545, 0)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So after the first 20k games, the Exact agent totally p@wn3d the NN agent. The best the NN agent could hope for was for a tie, which he got 25% of the times. Not bad."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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": [
    "Let's let it run for more games."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 20000/20000 [03:24<00:00, 97.94it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(rlglue, runs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11251, 0)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I let it run for another 80k, and it seems we're down to losing only half the time. Which is guess is the best that this agent can do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9622, 1629)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[np.where(starts==-1), 0] > 0).sum(), (rew[np.where(starts==1), 0] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that Exact agent had it easier when he started. He only won 1629 games from 20k where the NN agent started."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's play a game:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "ai = rlg.agents[1][\"agent\"] # our agent is now the 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = TicTacToeEvnironment()\n",
    "env.env_init()\n",
    "ret = env.env_start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_start(ret[0], ret[1])\n",
    "action # ai chooses..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(1, action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Human (aka - me) will play 4\n",
    "ret = env.env_step(-1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action # ai chooses..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(1, action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Human (aka - me) will block: 1\n",
    "ret = env.env_step(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action # ai chooses..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(1, action) # not a bad block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I choose 5\n",
    "ret = env.env_step(-1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action # ai chooses..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(1, action) # again, a good block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I choose 8\n",
    "ret = env.env_step(-1, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action # ai chooses..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,\n",
       " array([ 1., -1.,  1.,  1., -1., -1.,  1.,  1., -1.]),\n",
       " True,\n",
       " array([0., 0., 0., 0., 0., 0., 0., 0., 0.]))"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.env_step(1, action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So I kind of let the agent win. It really felt like the agent wasn't really trying to win, but more block me... Maybe that's the bad thing about playing against a too strong of an opponent. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try again, this time the NN agent against itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\david\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\david\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\david\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\david\\Anaconda3\\lib\\site-packages\\keras\\optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# define the function approximator - a Feed-Forward NN \n",
    "layers1 = [9, 12, 12, 9]\n",
    "layers2 = [9, 12, 12, 9]\n",
    "nn1 = SimpleKerasNN(layers1)\n",
    "nn2 = SimpleKerasNN(layers2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(runs, nns):\n",
    "    rlglue = RLGlue(TicTacToeEvnironment, TicTacToeNNAgent, TicTacToeNNAgent)\n",
    "    rewards = np.zeros((runs, 2))\n",
    "    starts = np.zeros((runs, 1))\n",
    "    final_states = np.zeros((runs, 9))\n",
    "    agent1_info = {\"discount\": 1, \"network\": nns[0], \"tau\": 1, \"num_actions\": 9, \"seed\": 747}\n",
    "    agent2_info = {\"discount\": 1, \"network\": nns[1], \"tau\": 1, \"num_actions\": 9, \"seed\": 101}\n",
    "    env_info = {}\n",
    "    rlglue.rl_init(agent1_info, agent2_info, env_info)\n",
    "\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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "runs = 30000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30000/30000 [05:57<00:00, 83.90it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(runs, [nn1, nn2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4709, 5102)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": [
    "Doesn't seem to be working that great. I guess in this architecture, the agent just doesn't have enough capacity to learn enough..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's save this agent\n",
    "ai.network.model.save_weights(\"agent-4-keras-9-12-12-9.h5\")"
   ]
  }
 ],
 "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
}