CS6700_Tutorial_2_MENACE_solved.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ptrfMg83-IXT"
      },
      "source": [
        "# CS6700: Reinforcement Learning - Tutorial 1 (MENACE)\n",
        "\n",
        "#### Tasks\n",
        "1. Complete code to determine if there is a winner at a particular state\n",
        "2. Complete code to update state-action values of a player based on play history\n",
        "3. Plot win, draw and loss %ages while training MENACE vs MENACE\n",
        "4. Plot win, draw and loss %ages while training MENACE vs Random policy\n",
        "5. Report any observations and inferences from the plots in 3 & 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "LD5-1Iw8PafI"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from typing import NamedTuple\n",
        "from google.colab import output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "I04JDLKvQwPo"
      },
      "outputs": [],
      "source": [
        "SEED = 0\n",
        "NUM_EPOCHS = 1_00_000\n",
        "\n",
        "BOARD_COL = 3\n",
        "BOARD_ROW = 3\n",
        "BOARD_SIZE = BOARD_COL * BOARD_ROW\n",
        "\n",
        "\"\"\"\n",
        "Game board and actions are: {q, w, e, a, s, d, z, x, c}\n",
        "\n",
        "q | w | e\n",
        "--|---|--\n",
        "a | s | d\n",
        "--|---|--\n",
        "z | x | c\n",
        "\"\"\"\n",
        "ACTIONS_KEY_MAP = {'q': 0, 'w': 1, 'e': 2,\n",
        "                   'a': 3, 's': 4, 'd': 5,\n",
        "                   'z': 6, 'x': 7, 'c': 8}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "n7lTbDhBy5Of"
      },
      "outputs": [],
      "source": [
        "np.random.seed(SEED)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQhLYLOByy-D"
      },
      "source": [
        "## State Definition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "IFBWExhtRAMR"
      },
      "outputs": [],
      "source": [
        "def print_state(board, clear_output=False): # used to show output\n",
        "  if clear_output:\n",
        "    output.clear()\n",
        "  for i in range(BOARD_ROW):\n",
        "    print('-------------')\n",
        "    out = '| '\n",
        "    for j in range(BOARD_COL):\n",
        "      if board[i, j] == 1:\n",
        "          token = 'x'\n",
        "      elif board[i, j] == -1:\n",
        "          token = 'o'\n",
        "      else:\n",
        "          token = ' '  # empty position\n",
        "      out += token + ' | '\n",
        "    print(out)\n",
        "  print('-------------')\n",
        "\n",
        "\n",
        "class State:\n",
        "  def __init__(self, symbol):\n",
        "    # the board is represented by an n * n array,\n",
        "    #  1 represents the player who moves first (X),\n",
        "    # -1 represents another player (O)\n",
        "    #  0 represents an empty position\n",
        "    self.board = np.zeros((BOARD_ROW, BOARD_COL))\n",
        "    self.symbol = symbol\n",
        "    self.winner = 0\n",
        "    self.end = None\n",
        "\n",
        "  @property\n",
        "  def hash_value(self):\n",
        "    hash = 0\n",
        "    for x in np.nditer(self.board):\n",
        "      hash = 3*hash + x + 1   # unique hash\n",
        "    return hash\n",
        "\n",
        "  def next(self, action: str):\n",
        "    id = ACTIONS_KEY_MAP[action]\n",
        "    i, j = id // BOARD_COL, id % BOARD_COL\n",
        "    return self.next_by_pos(i, j)\n",
        "\n",
        "  def next_by_pos(self, i: int, j: int):\n",
        "    assert self.board[i, j] == 0\n",
        "    new_state = State(-self.symbol)      # another player turn\n",
        "    new_state.board = np.copy(self.board)\n",
        "    new_state.board[i, j] = self.symbol  # current player choose to play at (i, j) pos\n",
        "    return new_state\n",
        "\n",
        "  @property\n",
        "  def possible_actions(self):\n",
        "    rev_action_map = {id: key for key, id in ACTIONS_KEY_MAP.items()}\n",
        "    actions = []\n",
        "    for i in range(BOARD_ROW):\n",
        "      for j in range(BOARD_COL):\n",
        "        if self.board[i, j] == 0:\n",
        "          actions.append(rev_action_map[BOARD_COL*i+j])\n",
        "    return actions\n",
        "\n",
        "  def is_end(self):\n",
        "    if self.end is not None:\n",
        "      return self.end\n",
        "    else:\n",
        "      for i in range(BOARD_ROW):\n",
        "        # check row winner\n",
        "        if self.board[i,0] == 1 and self.board[i,1] == 1 and self.board[i,2] == 1:\n",
        "          self.winner = 1\n",
        "          self.end = True\n",
        "          return self.end\n",
        "        elif self.board[i,0] == -1 and self.board[i,1] == -1 and self.board[i,2] == -1:\n",
        "          self.winner = 2\n",
        "          self.end = True\n",
        "          return self.end\n",
        "        # check column winner\n",
        "        elif self.board[0,i] == 1 and self.board[1,i] == 1 and self.board[2,i] == 1:\n",
        "          self.winner = 1\n",
        "          self.end = True\n",
        "          return self.end\n",
        "        elif self.board[0,i] == -1 and self.board[1,i] == -1 and self.board[2,i] == -1:\n",
        "          self.winner = 2\n",
        "          self.end = True\n",
        "          return self.end\n",
        "        # check 1st diagonal winner\n",
        "        elif i == 0:\n",
        "          if self.board[0,0] == 1 and self.board[1,1] == 1 and self.board[2,2] == 1:\n",
        "            self.winner = 1\n",
        "            self.end = True\n",
        "            return self.end\n",
        "          elif self.board[0,0] == -1 and self.board[1,1] == -1 and self.board[2,2] == -1:\n",
        "            self.winner = 2\n",
        "            self.end = True\n",
        "            return self.end\n",
        "        # check 2nd diagonal winner\n",
        "        elif i == 2:\n",
        "          if self.board[0,2] == 1 and self.board[1,1] == 1 and self.board[2,0] == 1:\n",
        "            self.winner = 1\n",
        "            self.end = True\n",
        "            return self.end\n",
        "          elif self.board[0,2] == -1 and self.board[1,1] == -1 and self.board[2,0] == -1:\n",
        "            self.winner = 2\n",
        "            self.end = True\n",
        "            return self.end\n",
        "\n",
        "    ### WRITE YOUR CODE HERE ###\n",
        "    # check 3 rows, 3 columns and both diagonals\n",
        "    # check if the state is an end state\n",
        "    # set self.end to be True when the game has ended\n",
        "    # set self.winner to be 0 (draw), 1 (player 1) or 2 (player 2)\n",
        "\n",
        "    # if there is no winner\n",
        "    # check if there are any available plays\n",
        "    for x in np.nditer(self.board):\n",
        "      if x == 0:\n",
        "        self.end = False\n",
        "        return self.end\n",
        "\n",
        "    # declare a draw\n",
        "    self.winner = 0\n",
        "    self.end = True\n",
        "    return self.end"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ihwyqTpPy2H2"
      },
      "source": [
        "## Environment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "XJG-IRKIDsz9"
      },
      "outputs": [],
      "source": [
        "class Env:\n",
        "  def __init__(self):\n",
        "    self.all_states = self.get_all_states()\n",
        "    self.curr_state = State(symbol=1)\n",
        "\n",
        "  def get_all_states(self):\n",
        "    all_states = {}  # is a dict with key as state_hash_value and value as State object.\n",
        "    def explore_all_substates(state):\n",
        "      for i in range(BOARD_ROW):\n",
        "        for j in range(BOARD_COL):\n",
        "          if state.board[i, j] == 0:\n",
        "            next_state = state.next_by_pos(i, j)\n",
        "            if next_state.hash_value not in all_states:\n",
        "              all_states[next_state.hash_value] = next_state\n",
        "              if not next_state.is_end():\n",
        "                explore_all_substates(next_state)\n",
        "    curr_state = State(symbol=1)\n",
        "    all_states[curr_state.hash_value] = curr_state\n",
        "    explore_all_substates(curr_state)\n",
        "    return all_states\n",
        "\n",
        "  def reset(self):\n",
        "    self.curr_state = State(symbol=1)\n",
        "    return self.curr_state\n",
        "\n",
        "  def step(self, action):\n",
        "    assert action in self.curr_state.possible_actions, f\"Invalid {action} for the current state \\n{print_state(self.curr_state.board)}\"\n",
        "    next_state_hash = self.curr_state.next(action).hash_value\n",
        "    next_state = self.all_states[next_state_hash]\n",
        "    self.curr_state = next_state\n",
        "    reward = 0\n",
        "    return self.curr_state, reward\n",
        "\n",
        "  def is_end(self):\n",
        "    return self.curr_state.is_end()\n",
        "\n",
        "  @property\n",
        "  def winner(self):\n",
        "    result_id = self.curr_state.winner\n",
        "    result = 'draw'\n",
        "    if result_id == 1:\n",
        "      result = 'player1'\n",
        "    elif result_id == 2:\n",
        "      result = 'player2'\n",
        "    return result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZKfXapCzHNq"
      },
      "source": [
        "## Policy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "pN3u_Ss0lf88"
      },
      "outputs": [],
      "source": [
        "class BasePolicy:\n",
        "  def reset(self):\n",
        "    pass\n",
        "\n",
        "  def update_values(self, *args):\n",
        "    pass\n",
        "\n",
        "  def select_action(self, state):\n",
        "    raise Exception('Not Implemented Error')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "OfddswzCRK8p"
      },
      "outputs": [],
      "source": [
        "class HumanPolicy(BasePolicy):\n",
        "  def __init__(self, symbol):\n",
        "    self.symbol = symbol\n",
        "\n",
        "  def select_action(self, state):\n",
        "    assert state.symbol == self.symbol, f\"Its not {self.symbol} symbol's turn\"\n",
        "    print_state(state.board, clear_output=True)\n",
        "    key = input(\"Input your position: \")\n",
        "    return key"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "kJ_18UpiogzN"
      },
      "outputs": [],
      "source": [
        "class RandomPolicy(BasePolicy):\n",
        "  def __init__(self, symbol):\n",
        "    self.symbol = symbol\n",
        "\n",
        "  def select_action(self, state):\n",
        "    assert state.symbol == self.symbol, f\"Its not {self.symbol} symbol's turn\"\n",
        "    return np.random.choice(state.possible_actions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "mos8O8H1RFe5"
      },
      "outputs": [],
      "source": [
        "class ActionPlayed(NamedTuple):\n",
        "  hash_value: str\n",
        "  action: str\n",
        "\n",
        "\n",
        "class MenacePolicy(BasePolicy):\n",
        "  def __init__(self, all_states, symbol, tau=5.0):\n",
        "    self.all_states = all_states\n",
        "    self.symbol = symbol\n",
        "    self.tau = tau\n",
        "\n",
        "    # It store the number of stones for each action for each state\n",
        "    self.state_action_value = self.initialize()\n",
        "    # variable to store the history for updating the number of stones\n",
        "    self.history = []\n",
        "\n",
        "  def initialize(self):\n",
        "    state_action_value = {}\n",
        "    for hash_value, state in self.all_states.items():\n",
        "      # initially all actions have 0 stones\n",
        "      state_action_value[hash_value] = {action: 0 for action in state.possible_actions}\n",
        "    return state_action_value\n",
        "\n",
        "  def reset(self):\n",
        "    for action_value in self.state_action_value.values():\n",
        "      for action in action_value.keys():\n",
        "        action_value[action] = 0\n",
        "\n",
        "  def print_updates(self, reward):\n",
        "    print(f'Player with symbol {self.symbol} updates the following history with {reward} stone')\n",
        "    for item in self.history:\n",
        "      board = np.copy(self.all_states[item.hash_value].board)\n",
        "      id = ACTIONS_KEY_MAP[item.action]\n",
        "      i, j = id//BOARD_COL, id%BOARD_COL\n",
        "      board[i, j] = self.symbol\n",
        "      print_state(board)\n",
        "\n",
        "  def update_values(self, reward, show_update=False):\n",
        "    # reward: if wins receive reward of 1 stone for the chosen action\n",
        "    #         else -1 stone.\n",
        "    # reward is either 1 or -1 depending upon if the player has won or lost the game.\n",
        "\n",
        "    if show_update:\n",
        "      self.print_updates(reward)\n",
        "\n",
        "    # for every state-action in history\n",
        "    # use reward to update the state-action values\n",
        "    ### WRITE CODE HERE\n",
        "\n",
        "    for i in range(len(self.history)):\n",
        "      last_hashVal = self.history[i][0]\n",
        "      last_action = self.history[i][1]\n",
        "      self.state_action_value[last_hashVal][last_action] += reward\n",
        "\n",
        "\n",
        "    self.history = []\n",
        "\n",
        "  def select_action(self, state):  # Softmax action probability\n",
        "    assert state.symbol == self.symbol, f\"Its not {self.symbol} symbol's turn\"\n",
        "    action_value = self.state_action_value[state.hash_value]\n",
        "    max_value = action_value[max(action_value, key=action_value.get)]\n",
        "    exp_values = {action: np.exp((v-max_value) / self.tau) for action, v in action_value.items()}\n",
        "    normalizer = np.sum([v for v in exp_values.values()])\n",
        "    prob = {action: v/normalizer for action, v in exp_values.items()}\n",
        "    action = np.random.choice(list(prob.keys()), p=list(prob.values()))\n",
        "    self.history.append(ActionPlayed(state.hash_value, action))\n",
        "    return action"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MvkDRmozqWM"
      },
      "source": [
        "## Game Board"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "qzO3FQJcCqpJ"
      },
      "outputs": [],
      "source": [
        "class Game:\n",
        "  def __init__(self, env, player1, player2):\n",
        "    self.env = env\n",
        "    self.player1 = player1\n",
        "    self.player2 = player2\n",
        "    self.show_updates = False\n",
        "    self.train_results = None\n",
        "\n",
        "  def alternate(self):\n",
        "    while True:\n",
        "      yield self.player1\n",
        "      yield self.player2\n",
        "\n",
        "  def train(self, epochs=1_00_000):\n",
        "    self.train_results = [[], []]\n",
        "    player1_reward_map = {'player1': 1, 'player2': -1, 'draw': 0}\n",
        "    for _ in range(epochs):\n",
        "      result = self.play()\n",
        "\n",
        "      # if player1 wins add 1 stone for the action chosen\n",
        "      player1_reward = player1_reward_map[result]\n",
        "      player2_reward = -player1_reward   # if player2 wins add 1 stone\n",
        "\n",
        "      self.player1.update_values(player1_reward)\n",
        "      self.player2.update_values(player2_reward)\n",
        "\n",
        "      # append results\n",
        "      self.train_results[0].append(player1_reward)\n",
        "      self.train_results[1].append(player2_reward)\n",
        "\n",
        "  def play(self):\n",
        "    alternate = self.alternate()\n",
        "    state = self.env.reset()\n",
        "    while not self.env.is_end(): # runs while false\n",
        "      player = next(alternate)\n",
        "      action = player.select_action(state)\n",
        "      state, _ = self.env.step(action)\n",
        "    result = self.env.winner\n",
        "    return result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X-gqpWkKztLm"
      },
      "source": [
        "## Experiments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "Pr62H-hLLYdt"
      },
      "outputs": [],
      "source": [
        "env = Env()\n",
        "\n",
        "# Game 1: train MENACE vs MENACE\n",
        "# plot win, draw, loss fractions for player 1\n",
        "player1 = MenacePolicy(env.all_states, symbol=1)\n",
        "player2 = MenacePolicy(env.all_states, symbol=-1)\n",
        "game1 = Game(env, player1, player2)\n",
        "game1.train(epochs=NUM_EPOCHS)\n",
        "\n",
        "# GAME 2: train MENACE vs RANDOM\n",
        "# plot win, draw, loss fractions for player 3\n",
        "player3 = MenacePolicy(env.all_states, symbol=1)\n",
        "player4 = RandomPolicy(symbol=-1)\n",
        "game2 = Game(env, player3, player4)\n",
        "game2.train(epochs=NUM_EPOCHS)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "INfZuvYiJsh_",
        "outputId": "cf9c9d91-69cf-46d3-dcc1-9bfd67593ba9"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "results1 = game1.train_results[0]\n",
        "wins1, draws1, losses1, tot1 = 0., 0., 0., 0.\n",
        "fracs1 = [[], [], []]\n",
        "for i in range(NUM_EPOCHS):\n",
        "  tot1 += 1\n",
        "  if results1[i] == 1: wins1 += 1\n",
        "  elif results1[i] == 0: draws1 += 1\n",
        "  else: losses1 += 1\n",
        "\n",
        "  fracs1[0].append((wins1/tot1)*100)\n",
        "  fracs1[1].append((losses1/tot1)*100)\n",
        "  fracs1[2].append((draws1/tot1)*100)\n",
        "\n",
        "plt.plot(range(NUM_EPOCHS), fracs1[0], label = 'wins')\n",
        "plt.plot(range(NUM_EPOCHS), fracs1[1], label = 'losses')\n",
        "plt.plot(range(NUM_EPOCHS), fracs1[2], label = 'draws')\n",
        "plt.title('Win-Loss-Draw percentages for Player 1 (MENACE trained vs MENACE)')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "pJLVk_xKPEmS",
        "outputId": "5c4ce83a-8cc7-4dcb-e347-8b2e3932709c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "results2 = game2.train_results[0]\n",
        "wins2, draws2, losses2, tot2 = 0., 0., 0., 0.\n",
        "fracs2 = [[], [], []]\n",
        "for i in range(NUM_EPOCHS):\n",
        "  tot2 += 1\n",
        "  if results2[i] == 1: wins2 += 1\n",
        "  elif results2[i] == 0: draws2 += 1\n",
        "  else: losses2 += 1\n",
        "\n",
        "  fracs2[0].append((wins2/tot2)*100)\n",
        "  fracs2[1].append((losses2/tot2)*100)\n",
        "  fracs2[2].append((draws2/tot2)*100)\n",
        "\n",
        "plt.plot(range(NUM_EPOCHS), fracs2[0], label = 'wins')\n",
        "plt.plot(range(NUM_EPOCHS), fracs2[1], label = 'losses')\n",
        "plt.plot(range(NUM_EPOCHS), fracs2[2], label = 'draws')\n",
        "plt.title('Win-Loss-Draw percentages for Player 3 (MENACE trained vs Random)')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qMbqaln6TDXZ",
        "outputId": "2ecc73e9-4a77-4b14-a3a1-ca8cc8da185e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-------------\n",
            "| o |   | x | \n",
            "-------------\n",
            "|   | x | x | \n",
            "-------------\n",
            "|   |   | o | \n",
            "-------------\n",
            "Input your position: a\n",
            "winner: player1\n",
            "Player with symbol 1 updates the following history with 1 stone\n",
            "-------------\n",
            "|   |   | x | \n",
            "-------------\n",
            "|   |   |   | \n",
            "-------------\n",
            "|   |   |   | \n",
            "-------------\n",
            "-------------\n",
            "| o |   | x | \n",
            "-------------\n",
            "|   |   | x | \n",
            "-------------\n",
            "|   |   |   | \n",
            "-------------\n",
            "-------------\n",
            "| o |   | x | \n",
            "-------------\n",
            "|   | x | x | \n",
            "-------------\n",
            "|   |   | o | \n",
            "-------------\n",
            "-------------\n",
            "| o |   | x | \n",
            "-------------\n",
            "| o | x | x | \n",
            "-------------\n",
            "| x |   | o | \n",
            "-------------\n"
          ]
        }
      ],
      "source": [
        "# GAME 3: Play against player 1 (MENACE trained vs MENACE)\n",
        "# See if you can beat this policy!\n",
        "\n",
        "game3 = Game(env, player1, HumanPolicy(symbol=-1))\n",
        "game3.play()\n",
        "\n",
        "result = env.winner\n",
        "print(f\"winner: {result}\")\n",
        "\n",
        "player1_reward_map = {'player1': 1, 'player2': -1, 'draw': 0}\n",
        "player1.update_values(player1_reward_map[result], show_update=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FgNksx7ZQrGU"
      },
      "source": [
        "#### Question\n",
        "\n",
        "What can you infer from the above series of experiments?\n",
        "\n",
        "**ENTER ANSWER HERE**\n",
        "\n",
        "1. While MENACE plays against itself, the number of draws increases with increasing training epochs and wins keep going down.\n",
        "2. However, while playing with the Random Policy algorithm the MENACE player is able to outperform the opponent resulting in more wins and lesser draws with increasing epochs.\n",
        "3. Playing against a trained MENACE player, even the best a human can hope for is a draw."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4Dmt8VOuiWok"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "2MvkDRmozqWM"
      ],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}