A5_Build_TicTacToe_Agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A5_Build_TicTacToe_Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains the code for the tic tac toe problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "200\n",
      "400\n",
      "600\n",
      "800\n",
      "1000\n",
      "1200\n",
      "1400\n",
      "1600\n",
      "1800\n",
      "2000\n",
      "2200\n",
      "2400\n",
      "2600\n",
      "2800\n",
      "3000\n",
      "3200\n",
      "3400\n",
      "3600\n",
      "3800\n",
      "4000\n",
      "4200\n",
      "4400\n",
      "4600\n",
      "4800\n",
      "5000\n",
      "5200\n",
      "5400\n",
      "5600\n",
      "5800\n",
      "6000\n",
      "6200\n",
      "6400\n",
      "6600\n",
      "6800\n",
      "7000\n",
      "7200\n",
      "7400\n",
      "7600\n",
      "7800\n",
      "8000\n",
      "8200\n",
      "8400\n",
      "8600\n",
      "8800\n",
      "9000\n",
      "9200\n",
      "9400\n",
      "9600\n",
      "9800\n",
      "Taking a greedy action\n",
      "------------------\n",
      " 0.66| 0.36| 0.60|\n",
      "------------------\n",
      " 0.66| 0.97| 0.49|\n",
      "------------------\n",
      " 0.55| 0.73| 0.44|\n",
      "------------------\n",
      "-------------\n",
      "            \n",
      "-------------\n",
      "      x     \n",
      "-------------\n",
      "            \n",
      "-------------\n"
     ]
    }
   ],
   "source": [
    "# https://www.udemy.com/artificial-intelligence-reinforcement-learning-in-python\n",
    "# Simple reinforcement learning algorithm for learning tic-tac-toe\n",
    "# Use the update rule: V(s) = V(s) + alpha*(V(s') - V(s))\n",
    "# Use the epsilon-greedy policy:\n",
    "#   action|s = argmax[over all actions possible from state s]{ V(s) }  if rand > epsilon\n",
    "#   action|s = select random action from possible actions from state s if rand < epsilon\n",
    "#\n",
    "# INTERESTING THINGS TO TRY:\n",
    "#\n",
    "# Currently, both agents use the same learning strategy while they play against each other.\n",
    "# What if they have different learning rates?\n",
    "# What if they have different epsilons? (probability of exploring)\n",
    "#   Who will converge faster?\n",
    "# What if one agent doesn't learn at all?\n",
    "#   Poses an interesting philosophical question: If there's no one around to challenge you,\n",
    "#   can you reach your maximum potential?\n",
    "from __future__ import print_function, division\n",
    "from builtins import range, input\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "LENGTH = 3\n",
    "\n",
    "\n",
    "class Agent:\n",
    "  def __init__(self, eps=0.1, alpha=0.5):\n",
    "    self.eps = eps # probability of choosing random action instead of greedy\n",
    "    self.alpha = alpha # learning rate\n",
    "    self.verbose = False\n",
    "    self.state_history = []\n",
    "  \n",
    "  def setV(self, V):\n",
    "    self.V = V\n",
    "\n",
    "  def set_symbol(self, sym):\n",
    "    self.sym = sym\n",
    "\n",
    "  def set_verbose(self, v):\n",
    "    # if true, will print values for each position on the board\n",
    "    self.verbose = v\n",
    "\n",
    "  def reset_history(self):\n",
    "    self.state_history = []\n",
    "\n",
    "  def take_action(self, env):\n",
    "    # choose an action based on epsilon-greedy strategy\n",
    "    r = np.random.rand()\n",
    "    best_state = None\n",
    "    if r < self.eps:\n",
    "      # take a random action\n",
    "      if self.verbose:\n",
    "        print(\"Taking a random action\")\n",
    "\n",
    "      possible_moves = []\n",
    "      for i in range(LENGTH):\n",
    "        for j in range(LENGTH):\n",
    "          if env.is_empty(i, j):\n",
    "            possible_moves.append((i, j))\n",
    "      idx = np.random.choice(len(possible_moves))\n",
    "      next_move = possible_moves[idx]\n",
    "    else:\n",
    "      # choose the best action based on current values of states\n",
    "      # loop through all possible moves, get their values\n",
    "      # keep track of the best value\n",
    "      pos2value = {} # for debugging\n",
    "      next_move = None\n",
    "      best_value = -1\n",
    "      for i in range(LENGTH):\n",
    "        for j in range(LENGTH):\n",
    "          if env.is_empty(i, j):\n",
    "            # what is the state if we made this move?\n",
    "            env.board[i,j] = self.sym\n",
    "            state = env.get_state()\n",
    "            env.board[i,j] = 0 # don't forget to change it back!\n",
    "            pos2value[(i,j)] = self.V[state]\n",
    "            if self.V[state] > best_value:\n",
    "              best_value = self.V[state]\n",
    "              best_state = state\n",
    "              next_move = (i, j)\n",
    "\n",
    "      # if verbose, draw the board w/ the values\n",
    "      if self.verbose:\n",
    "        print(\"Taking a greedy action\")\n",
    "        for i in range(LENGTH):\n",
    "          print(\"------------------\")\n",
    "          for j in range(LENGTH):\n",
    "            if env.is_empty(i, j):\n",
    "              # print the value\n",
    "              print(\" %.2f|\" % pos2value[(i,j)], end=\"\")\n",
    "            else:\n",
    "              print(\"  \", end=\"\")\n",
    "              if env.board[i,j] == env.x:\n",
    "                print(\"x  |\", end=\"\")\n",
    "              elif env.board[i,j] == env.o:\n",
    "                print(\"o  |\", end=\"\")\n",
    "              else:\n",
    "                print(\"   |\", end=\"\")\n",
    "          print(\"\")\n",
    "        print(\"------------------\")\n",
    "\n",
    "    # make the move\n",
    "    env.board[next_move[0], next_move[1]] = self.sym\n",
    "\n",
    "  def update_state_history(self, s):\n",
    "    # cannot put this in take_action, because take_action only happens\n",
    "    # once every other iteration for each player\n",
    "    # state history needs to be updated every iteration\n",
    "    # s = env.get_state() # don't want to do this twice so pass it in\n",
    "    self.state_history.append(s)\n",
    "\n",
    "  def update(self, env):\n",
    "    # we want to BACKTRACK over the states, so that:\n",
    "    # V(prev_state) = V(prev_state) + alpha*(V(next_state) - V(prev_state))\n",
    "    # where V(next_state) = reward if it's the most current state\n",
    "    #\n",
    "    # NOTE: we ONLY do this at the end of an episode\n",
    "    # not so for all the algorithms we will study\n",
    "    reward = env.reward(self.sym)\n",
    "    target = reward\n",
    "    for prev in reversed(self.state_history):\n",
    "      value = self.V[prev] + self.alpha*(target - self.V[prev])\n",
    "      self.V[prev] = value\n",
    "      target = value\n",
    "    self.reset_history()\n",
    "\n",
    "\n",
    "# this class represents a tic-tac-toe game\n",
    "# is a CS101-type of project\n",
    "class Environment:\n",
    "  def __init__(self):\n",
    "    self.board = np.zeros((LENGTH, LENGTH))\n",
    "    self.x = -1 # represents an x on the board, player 1\n",
    "    self.o = 1 # represents an o on the board, player 2\n",
    "    self.winner = None\n",
    "    self.ended = False\n",
    "    self.num_states = 3**(LENGTH*LENGTH)\n",
    "\n",
    "  def is_empty(self, i, j):\n",
    "    return self.board[i,j] == 0\n",
    "\n",
    "  def reward(self, sym):\n",
    "    # no reward until game is over\n",
    "    if not self.game_over():\n",
    "      return 0\n",
    "\n",
    "    # if we get here, game is over\n",
    "    # sym will be self.x or self.o\n",
    "    return 1 if self.winner == sym else 0\n",
    "\n",
    "  def get_state(self):\n",
    "    # returns the current state, represented as an int\n",
    "    # from 0...|S|-1, where S = set of all possible states\n",
    "    # |S| = 3^(BOARD SIZE), since each cell can have 3 possible values - empty, x, o\n",
    "    # some states are not possible, e.g. all cells are x, but we ignore that detail\n",
    "    # this is like finding the integer represented by a base-3 number\n",
    "    k = 0\n",
    "    h = 0\n",
    "    for i in range(LENGTH):\n",
    "      for j in range(LENGTH):\n",
    "        if self.board[i,j] == 0:\n",
    "          v = 0\n",
    "        elif self.board[i,j] == self.x:\n",
    "          v = 1\n",
    "        elif self.board[i,j] == self.o:\n",
    "          v = 2\n",
    "        h += (3**k) * v\n",
    "        k += 1\n",
    "    return h\n",
    "\n",
    "  def game_over(self, force_recalculate=False):\n",
    "    # returns true if game over (a player has won or it's a draw)\n",
    "    # otherwise returns false\n",
    "    # also sets 'winner' instance variable and 'ended' instance variable\n",
    "    if not force_recalculate and self.ended:\n",
    "      return self.ended\n",
    "    \n",
    "    # check rows\n",
    "    for i in range(LENGTH):\n",
    "      for player in (self.x, self.o):\n",
    "        if self.board[i].sum() == player*LENGTH:\n",
    "          self.winner = player\n",
    "          self.ended = True\n",
    "          return True\n",
    "\n",
    "    # check columns\n",
    "    for j in range(LENGTH):\n",
    "      for player in (self.x, self.o):\n",
    "        if self.board[:,j].sum() == player*LENGTH:\n",
    "          self.winner = player\n",
    "          self.ended = True\n",
    "          return True\n",
    "\n",
    "    # check diagonals\n",
    "    for player in (self.x, self.o):\n",
    "      # top-left -> bottom-right diagonal\n",
    "      if self.board.trace() == player*LENGTH:\n",
    "        self.winner = player\n",
    "        self.ended = True\n",
    "        return True\n",
    "      # top-right -> bottom-left diagonal\n",
    "      if np.fliplr(self.board).trace() == player*LENGTH:\n",
    "        self.winner = player\n",
    "        self.ended = True\n",
    "        return True\n",
    "\n",
    "    # check if draw\n",
    "    if np.all((self.board == 0) == False):\n",
    "      # winner stays None\n",
    "      self.winner = None\n",
    "      self.ended = True\n",
    "      return True\n",
    "\n",
    "    # game is not over\n",
    "    self.winner = None\n",
    "    return False\n",
    "\n",
    "  def is_draw(self):\n",
    "    return self.ended and self.winner is None\n",
    "\n",
    "  # Example board\n",
    "  # -------------\n",
    "  # | x |   |   |\n",
    "  # -------------\n",
    "  # |   |   |   |\n",
    "  # -------------\n",
    "  # |   |   | o |\n",
    "  # -------------\n",
    "  def draw_board(self):\n",
    "    for i in range(LENGTH):\n",
    "      print(\"-------------\")\n",
    "      for j in range(LENGTH):\n",
    "        print(\"  \", end=\"\")\n",
    "        if self.board[i,j] == self.x:\n",
    "          print(\"x \", end=\"\")\n",
    "        elif self.board[i,j] == self.o:\n",
    "          print(\"o \", end=\"\")\n",
    "        else:\n",
    "          print(\"  \", end=\"\")\n",
    "      print(\"\")\n",
    "    print(\"-------------\")\n",
    "\n",
    "\n",
    "\n",
    "class Human:\n",
    "  def __init__(self):\n",
    "    pass\n",
    "\n",
    "  def set_symbol(self, sym):\n",
    "    self.sym = sym\n",
    "\n",
    "  def take_action(self, env):\n",
    "    while True:\n",
    "      # break if we make a legal move\n",
    "      move = input(\"Enter coordinates i,j for your next move (i,j=0..2): \")\n",
    "      i, j = move.split(',')\n",
    "      i = int(i)\n",
    "      j = int(j)\n",
    "      if env.is_empty(i, j):\n",
    "        env.board[i,j] = self.sym\n",
    "        break\n",
    "\n",
    "  def update(self, env):\n",
    "    pass\n",
    "\n",
    "  def update_state_history(self, s):\n",
    "    pass\n",
    "\n",
    "\n",
    "# recursive function that will return all\n",
    "# possible states (as ints) and who the corresponding winner is for those states (if any)\n",
    "# (i, j) refers to the next cell on the board to permute (we need to try -1, 0, 1)\n",
    "# impossible games are ignored, i.e. 3x's and 3o's in a row simultaneously\n",
    "# since that will never happen in a real game\n",
    "def get_state_hash_and_winner(env, i=0, j=0):\n",
    "  results = []\n",
    "\n",
    "  for v in (0, env.x, env.o):\n",
    "    env.board[i,j] = v # if empty board it should already be 0\n",
    "    if j == 2:\n",
    "      # j goes back to 0, increase i, unless i = 2, then we are done\n",
    "      if i == 2:\n",
    "        # the board is full, collect results and return\n",
    "        state = env.get_state()\n",
    "        ended = env.game_over(force_recalculate=True)\n",
    "        winner = env.winner\n",
    "        results.append((state, winner, ended))\n",
    "      else:\n",
    "        results += get_state_hash_and_winner(env, i + 1, 0)\n",
    "    else:\n",
    "      # increment j, i stays the same\n",
    "      results += get_state_hash_and_winner(env, i, j + 1)\n",
    "\n",
    "  return results\n",
    "\n",
    "# play all possible games\n",
    "# need to also store if game is over or not\n",
    "# because we are going to initialize those values to 0.5\n",
    "# NOTE: THIS IS SLOW because MANY possible games lead to the same outcome / state\n",
    "# def get_state_hash_and_winner(env, turn='x'):\n",
    "#   results = []\n",
    "\n",
    "#   state = env.get_state()\n",
    "#   # board_before = env.board.copy()\n",
    "#   ended = env.game_over(force_recalculate=True)\n",
    "#   winner = env.winner\n",
    "#   results.append((state, winner, ended))\n",
    "\n",
    "#   # DEBUG\n",
    "#   # if ended:\n",
    "#   #   if winner is not None and env.win_type.startswith('col'):\n",
    "#   #     env.draw_board()\n",
    "#   #     print \"Winner:\", 'x' if winner == -1 else 'o', env.win_type\n",
    "#   #     print \"\\n\\n\"\n",
    "#   #     assert(np.all(board_before == env.board))\n",
    "\n",
    "#   if not ended:\n",
    "#     if turn == 'x':\n",
    "#       sym = env.x\n",
    "#       next_sym = 'o'\n",
    "#     else:\n",
    "#       sym = env.o\n",
    "#       next_sym = 'x'\n",
    "\n",
    "#     for i in xrange(LENGTH):\n",
    "#       for j in xrange(LENGTH):\n",
    "#         if env.is_empty(i, j):\n",
    "#           env.board[i,j] = sym\n",
    "#           results += get_state_hash_and_winner(env, next_sym)\n",
    "#           env.board[i,j] = 0 # reset it\n",
    "#   return results\n",
    "\n",
    "\n",
    "def initialV_x(env, state_winner_triples):\n",
    "  # initialize state values as follows\n",
    "  # if x wins, V(s) = 1\n",
    "  # if x loses or draw, V(s) = 0\n",
    "  # otherwise, V(s) = 0.5\n",
    "  V = np.zeros(env.num_states)\n",
    "  for state, winner, ended in state_winner_triples:\n",
    "    if ended:\n",
    "      if winner == env.x:\n",
    "        v = 1\n",
    "      else:\n",
    "        v = 0\n",
    "    else:\n",
    "      v = 0.5\n",
    "    V[state] = v\n",
    "  return V\n",
    "\n",
    "\n",
    "def initialV_o(env, state_winner_triples):\n",
    "  # this is (almost) the opposite of initial V for player x\n",
    "  # since everywhere where x wins (1), o loses (0)\n",
    "  # but a draw is still 0 for o\n",
    "  V = np.zeros(env.num_states)\n",
    "  for state, winner, ended in state_winner_triples:\n",
    "    if ended:\n",
    "      if winner == env.o:\n",
    "        v = 1\n",
    "      else:\n",
    "        v = 0\n",
    "    else:\n",
    "      v = 0.5\n",
    "    V[state] = v\n",
    "  return V\n",
    "\n",
    "\n",
    "def play_game(p1, p2, env, draw=False):\n",
    "  # loops until the game is over\n",
    "  current_player = None\n",
    "  while not env.game_over():\n",
    "    # alternate between players\n",
    "    # p1 always starts first\n",
    "    if current_player == p1:\n",
    "      current_player = p2\n",
    "    else:\n",
    "      current_player = p1\n",
    "\n",
    "    # draw the board before the user who wants to see it makes a move\n",
    "    if draw:\n",
    "      if draw == 1 and current_player == p1:\n",
    "        env.draw_board()\n",
    "      if draw == 2 and current_player == p2:\n",
    "        env.draw_board()\n",
    "\n",
    "    # current player makes a move\n",
    "    current_player.take_action(env)\n",
    "\n",
    "    # update state histories\n",
    "    state = env.get_state()\n",
    "    p1.update_state_history(state)\n",
    "    p2.update_state_history(state)\n",
    "\n",
    "  if draw:\n",
    "    env.draw_board()\n",
    "\n",
    "  # do the value function update\n",
    "  p1.update(env)\n",
    "  p2.update(env)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "  # train the agent\n",
    "  p1 = Agent()\n",
    "  p2 = Agent()\n",
    "\n",
    "  # set initial V for p1 and p2\n",
    "  env = Environment()\n",
    "  state_winner_triples = get_state_hash_and_winner(env)\n",
    "\n",
    "\n",
    "  Vx = initialV_x(env, state_winner_triples)\n",
    "  p1.setV(Vx)\n",
    "  Vo = initialV_o(env, state_winner_triples)\n",
    "  p2.setV(Vo)\n",
    "\n",
    "  # give each player their symbol\n",
    "  p1.set_symbol(env.x)\n",
    "  p2.set_symbol(env.o)\n",
    "\n",
    "  T = 10000\n",
    "  for t in range(T):\n",
    "    if t % 200 == 0:\n",
    "      print(t)\n",
    "    play_game(p1, p2, Environment())\n",
    "\n",
    "  # play human vs. agent\n",
    "  # do you think the agent learned to play the game well?\n",
    "  human = Human()\n",
    "  human.set_symbol(env.o)\n",
    "  while True:\n",
    "    p1.set_verbose(True)\n",
    "    play_game(p1, human, Environment(), draw=2)\n",
    "    # I made the agent player 1 because I wanted to see if it would\n",
    "    # select the center as its starting move. If you want the agent\n",
    "    # to go second you can switch the human and AI.\n",
    "    answer = input(\"Play again? [Y/n]: \")\n",
    "    if answer and answer.lower()[0] == 'n':\n",
    "      break\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Tic Tac Toe Code Outline:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tic Tac toe Implementation\n",
    "- Typically in ML we implement line-by-line procedural algorithms (which are easier to follow)\n",
    "- but, in RL we have multiple objects interacting, we have to take an OOP (object oriented approach) approach\n",
    "\n",
    "We will start with an overview in this section (Outline) of all the objects we need to represent and how they interact.\n",
    "After that we will look at the details of each obejct. Keep in mind that this solution is no way unique. In fact, there is some poor coupling between objects that are probably not optimal."
   ]
  },
  {
   "attachments": {
    "Tic_Tac_Toe%20Outline.PNG": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Tic_Tac_Toe%20Outline.PNG](attachment:Tic_Tac_Toe%20Outline.PNG)\n",
    "\n",
    "<span style='color:blue'> At a high level, we'll have two main objects: the agent and the enviroment.</span>\n",
    "\n",
    "<span style='color:blue'>During any game there will be 2 instances of the agent object. And they will both interact with the same single instance of the envirment.</span>\n",
    "\n",
    "<span style='color:blue'>In order to make these things intract we can create a function called play game which accepts the agent from player one, the agent from player 2, and the enviroment object.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_game(p1,p2,env,draw=False):\n",
    "    # loops until the game is over\n",
    "    current_player = None #(while loop,checks if the game is over)\n",
    "    while not env.game_over():\n",
    "        # alternate between players (switch whom the current player is) \n",
    "        # p1 always starts first\n",
    "        if current_player == p1:\n",
    "            current_player = p2\n",
    "        else:\n",
    "            current_player = p1\n",
    "            \n",
    "        #draw the board before the user who wants to see it makes a move\n",
    "        # (Draw board function)\n",
    "        if draw:\n",
    "            if draw == 1 and current_player == p1:\n",
    "                env.draw_board()\n",
    "            if draw == 2 and current_player == p2:\n",
    "                env.draw_board()\n",
    "        # Current player makes a move (Agent take action function)\n",
    "        # (We need to make the current player perform an action that update the enviroment)\n",
    "        current_player.take_action(env)\n",
    "        \n",
    "        # Updates state histories\n",
    "        state = env.get_state()\n",
    "        p1.update_state_history(state)\n",
    "        p2.update_state_history(state)\n",
    "        \n",
    "    if draw:\n",
    "        env.draw_board()\n",
    "        \n",
    "    # do the value function update\n",
    "    p1.update(env)\n",
    "    p2.update(env)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What should go inside the play_game function?\n",
    "- Inside the function it is basically a single loop.\n",
    "- It loops until the game is over.\n",
    "- At each iteration of the loop we need to do a few things.\n",
    "- We need to make the current player perform an action that update the enviroment\n",
    "- So we need to switch whom the current player is on order to alternante between players.\n",
    "- Third we need to check if the current game is over (current_player= None, while not env.game_over(): )\n",
    "- Here we have created a partial API for some instance methodS that our objects will need.\n",
    "- The enviroment is will be the game over function that returns a boolean. True if the game is over. False if the game is not."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    " current_player = None #(while loop,checks if the game is over)\n",
    "    while not env.game_over():\n",
    "        # alternate between players"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This will have to check the board to see if the board is full and there is a winner or if its full but there is no winner then it is a draw.\n",
    "- The agent will need a take action function. Which accepts as a parameter the enviroment. This will update the enviroment and hence the state."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "        # Current player makes a move (Agent take action function)\n",
    "        # (We need to make the current player perform an action that update the enviroment)\n",
    "        current_player.take_action(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Another function we will need on the agent is the update function. The update function, updates the agent's internal estimate of the value function. This is where the update equation previously discussed is going to go $$V(s) \\leftarrow V(s)+ \\alpha (V(s^{'}) - V(s) ) $$. The update function will have to query the enviroment as well since, it will have to querry the most current reward from the current enviroment.\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "    if draw:\n",
    "        env.draw_board()\n",
    "        \n",
    "    # do the value function update\n",
    "    p1.update(env)\n",
    "    p2.update(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Another function that is extremely useful however not strictly necessary is the draw board function. This displays what positions are currently occupied and by what pieces (X or O) ."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "        #draw the board before the user who wants to see it makes a move\n",
    "        # (Draw board function)\n",
    "        if draw:\n",
    "            if draw == 1 and current_player == p1:\n",
    "                env.draw_board()\n",
    "            if draw == 2 and current_player == p2:\n",
    "                env.draw_board()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Tic Tac Toe Code: Representing the states:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'> \n",
    "How are we going to represent states in our tic-tac-toe game?\n",
    "    </span>\n",
    "    \n",
    "<span style='color:blue'> \n",
    "Earlier we discussed how this could be a O of one lookup, which in python is basically an array (matrix) / or a list of tuples.\n",
    "    </span>\n",
    "    \n",
    "<span style='color:blue'> \n",
    "One way to accomplish this would be to use a dictionary, since the keys to a dictionary since the keys to a dictionary can be any immutable object. So we could repredent the game as a 2D tuple of size 3 by 3 and store the values inside as tuple elements.\n",
    "    </span>\n",
    "    \n",
    " <span style='color:blue'> \n",
    "However we can do this so that each state maps to a number, and by doing that we can store the value function as a numpy array.\n",
    "  </span>\n",
    "\n",
    "- Earlier, We discussed how there will be a [O(1) lookup](https://stackoverflow.com/questions/25541478/why-is-lookup-in-an-array-o1) (as in an array)\n",
    "- Possible solution: convert the board to a tuple of tuples, use a dictionary key\n",
    "- Better solution: Map each state into a number, use Numpy array\n",
    "\n",
    "#### Mapping state to a number\n",
    " <span style='color:blue'> \n",
    "How do we code a state to a number? \n",
    "  </span>\n",
    "  \n",
    "  <span style='color:blue'> \n",
    "Notice that $3^{9}$ also encodes impossible states such as an X in all the 9 locations.\n",
    "Some states are overheads and cannot be reached such as an x at each point on the board as you only need 3 X's to win. These overheads do not affect the algorithm at all so we will not worry about it. These states are never reachable anyway, since at each iteration of the loop we are going to check if the game is over and if it is we will quit the loop.\n",
    "  </span>\n",
    "  \n",
    "  <span style='color:blue'> \n",
    "So these impossible values never show up in the state history meaning that they're values will never be used or updated.\n",
    "  </span>\n",
    "  \n",
    "- $3^{9} = 19683$ states, not impossible as we have a small board (3 by 3) in Tic-Tac-Toe\n",
    "- Overhead not a problem, these states are unreachable (e.g. 3 X's in a row and 3 o's in a row on the same board)\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2:13\n",
    "\n",
    "- Should remind you of binary numbers (2 possible symbols in each location VS. 3)\n",
    "- Binary to decimal\n",
    "$$ D = 2^{N-1} b_{N-1} + \\dots + 2^{1} b_{1} + 2^{0} b_{0} $$\n",
    "- For us:\n",
    "$$D = 3^{N-1} b_{N-1} + \\dots + 3^{1} b_{1} + 3^{0} b_{0}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <span style='color:blue'> \n",
    "In code, it's going to look like this. Notice how we loop through each location on the board, which requires a nested four loop but that's only because of the structure of the board.\n",
    "</span>\n",
    "\n",
    " <span style='color:blue'> \n",
    "We need to keep track of the power which starts at three to the power zero and gets multiplied by three on each new location so we keep track of that with the variable k.\n",
    "</span> \n",
    "\n",
    " <span style='color:blue'> \n",
    "We use the variable h to accumulate the final result. We use the letter h because h stands for hash and that's essentially what we're doing when hashing an object, and the output is an integer.\n",
    "    </span> "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "k=0\n",
    "h=0\n",
    "for i in xrange(LENGTH):\n",
    "    for j in xrange(LENGTH):\n",
    "        if self.board[i,j]==0:\n",
    "            v = 0\n",
    "        elif self.board[i,j] == self.x:\n",
    "            v=1\n",
    "        elif self.board[i,j] == self.o:\n",
    "            v=2\n",
    "        h += (3**k)*v\n",
    "        k += 1\n",
    "return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env is the instance of a class\n",
    "\n",
    "def get_state_hash_and_winner(env, i=0, j=0):\n",
    "    results = []\n",
    "    \n",
    "    for v in (0, env.x, env.o):\n",
    "        env.board[i,j] = v# if the board is empty should already be 0\n",
    "        if j == 2:\n",
    "            # j goes back to 0, increase i, unless i=2, then we are done\n",
    "            if i ==2:\n",
    "                # the board is full, collect results and return\n",
    "                state = env.get_state()\n",
    "                ended = env.game_over( force_recalculate=True)\n",
    "                winner = env.winner\n",
    "                results.append((state,winner,ended))\n",
    "            else:\n",
    "                results += get_state_hash_and_winner(env, i+1, 0)\n",
    "        else:\n",
    "            # increment j, i stays the same\n",
    "            results += get_state_hash_and_winner(env,i,j+1)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "                # the board is full, collect results and return\n",
    "                state = env.get_state()\n",
    "                ended = env.game_over( force_recalculate=True)\n",
    "                winner = env.winner\n",
    "                results.append((state,winner,ended))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If i ==2 and j == 2 then we are filling up the last location on the board. \n",
    "- This means we should  now check the game state, which means check whom the winner is and whether or not the game has ended."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summarizing Tic-tac-toe\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Summary:\n",
    "    - First, what is the most naive solution to the tic-tac-toe problem.\n",
    "        - Answer is we would end up building an agent with a bunch of if statements.\n",
    "    - Would not be able to increase intelligence by learning from experience.\n",
    "    - Would not be generalizable to other enviroments.\n",
    "        \n",
    "<span style='color:blue'> \n",
    "It would not adapt to its enviroment or get better as it is played for more games. So even if it seemed intelligent at first it would not be able to increase its intelligence.\n",
    "</span>\n",
    "\n",
    "<span style='color:blue'> \n",
    "Moreover the algorithm would not be generalizable to new games. It would just work for tic tac toe. So, we have set out to find algorithms that are intelligent and that can potentially solve anything given the right rewards.\n",
    "</span>\n",
    "    - Next, we took a deeper look at **Components of a RL system**\n",
    "    - Agent, Enviroment, state, action and reward\n",
    "    - Episodes, terminal states\n",
    "    - Choosing rewards carefully\n",
    " <span style='color:blue'> \n",
    "We discussed defined the terms: agents, enviroment, state, action and reward. We discussed how reward structures can lead to poor results. Hence, we need to choose them carefully. We looked at new terms like episode and terminal states. We needed to understand these concepts in order to implement Tic-tac-toe.\n",
    "</span>\n",
    "\n",
    "- Next, we looked at:\n",
    "    - Credit Assignment problem\n",
    "    - Delayed reward\n",
    "    - Planning intgelligently to maximize the overall rewards\n",
    "- Value function\n",
    "- $V(s) \\leftarrow V(s) + \\alpha [V(s^{'}) - V(s)]$ \n",
    "- We then saw this in implementation\n",
    "\n",
    " <span style='color:blue'> \n",
    "\n",
    "</span>"
   ]
  }
 ],
 "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
}