notebooks/k-arms.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# K-Arm no-brown player vs Dummy player"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code used to implement the k-arm algorithm is inspired from the excercises in the Coursera course \"Fundamentals of Reinforcement Learning\" created by the University of Alberta (link [here](https://www.coursera.org/learn/fundamentals-of-reinforcement-learning))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.chdir('..')\n",
    "\n",
    "from monosim.player import Player\n",
    "from monosim.board import get_board, get_roads, get_properties, get_community_chest_cards, get_bank\n",
    "import random\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.stats import binom_test\n",
    "from tqdm import tqdm\n",
    "\n",
    "import seaborn as sns\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Greedy agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we modify a player implementing a simple greedy K-arm algorithm. In particular, the player learns through playing whether it's convenient to buy a brown property or not. The player is unaware of any state of the game (neither their state nor their opponent's). This is a big simplification of the game, as unlikely a game's outcome is determined by modifying the behaviour on whether a player buys a brown property or not. Also, decisions need to be made by observing the player and the opponent's state. This is just an example to show how to modify a player implementing Reinforcement Learning (RL) based algorithms.\n",
    "\n",
    "The action to be taken by the player, when ending in a brown cell with no owner is \"buy\" or \"do not buy\". This can be formalized as:\n",
    "\n",
    "$A_t = 1 \\quad (Buy)$ \\\n",
    "$A_t = 0 \\quad (Do Not Buy)$\n",
    "\n",
    "The reward ($R_n$) is 1 if the player wins and 0 otherwise. The game can get in stalemate with the current impementation, in which case no reward is provided by the environment, and the Q-values not updated.\n",
    "\n",
    "We're trying to estimate the expected reward for each action:\n",
    "\n",
    "$q_*(a) = \\mathop{\\mathbb{E}} [R_t|A_t=a]$\n",
    "\n",
    "and since we're implementing a simple greedy algorithm, the action will be selected as $A_t \\doteq \\underset{a}{\\arg\\max} Q_t(a)$\n",
    "\n",
    "The use an incremental sample-average method to estimate the action-values as follow:\n",
    "\n",
    "$Q_n+1 = Q_n+\\frac{1}{n}(R_n-Q_n))$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modify player"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we modify the Player class to implement the RL-based player."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decorate buy() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a decorator used to modify the buy() function. This function will run the RL trained action when the player ends in a brown cell, which is not owned by other players. When the player doesn't end in a brown road, the default buy() behaviour will be used. When the player ends in a brown cell, the function brown_k_arm_action() is run, which is implemented below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modify_buy(buy):\n",
    "    def _wrapper(self, dict_road_info, road_name):\n",
    "        if dict_road_info['color'] == 'brown':\n",
    "            action = self.brown_k_arm_action()\n",
    "            if action == 1:\n",
    "                buy(self, dict_road_info, road_name)\n",
    "            else:\n",
    "                pass\n",
    "        else:\n",
    "            buy(self, dict_road_info, road_name)\n",
    "    return _wrapper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inherit the class Player_brown_k_arm_greedy from Player. The function reset_val is used to set the player's state to default (e.g., cash=1500, 0 owned roads, etc.). Instead of re-creating a new Player object for each game, we reset the state of the existing Player object. This is important since we are adding four new state variables (q_values, count_actions, won_last_game_with_brown, last_action) which cannot be erased after each game. In particular, the list q_values contains the action-values which need to be incrementally updated.\n",
    "\n",
    "The new variables are:\n",
    "\n",
    "* q_values = list of 2 elements, containing the action-value for 0 (do not buy) and 1 (buy)\n",
    "* count_actions = count how many times each action has been taken\n",
    "* won_last_game_with_brown = 0 if the previous game was lost, 1 otherwise\n",
    "* last_action = 0 if the last action was \"do not buy brown road\", 1 otherwise\n",
    "\n",
    "The function update_q_values() updates the action-values, and it's run only when the player ends in a brown property without an owner. The function brown_k_arm_action uses the trained value-actions to decide wich action to take."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player_brown_k_arm_greedy(Player):\n",
    "    def __init__(self, name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck):\n",
    "        super().__init__(name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        self.q_values = [0, 0]  # Initially the player doesn't know which is the best action\n",
    "        self.count_actions = [0, 0]\n",
    "        self.won_last_game_with_brown = 0\n",
    "        self.last_action = 0\n",
    "        \n",
    "    def reset_val(self, name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck):\n",
    "        \"\"\" Reset Player's info (cash, properties, etc.). This function is used to reset\n",
    "            the player's information, so that at each game we don't have to create a new\n",
    "            Player object.\n",
    "        \"\"\"\n",
    "        super().__init__(name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "\n",
    "    def update_q_values(self):\n",
    "        \"\"\" Implement sample-average method. Update the q-value every time the player ends in a brown cell.\n",
    "            The q-value is updated greedily, using the equation above.\n",
    "        \"\"\"\n",
    "        q_value_old = self.q_values[self.last_action]\n",
    "        self.count_actions[self.last_action] += 1\n",
    "        reward = self.won_last_game_with_brown\n",
    "        q_value_new = q_value_old + (1/self.count_actions[self.last_action]) * (reward - q_value_old)\n",
    "        self.q_values[self.last_action] = q_value_new\n",
    "        \n",
    "    def brown_k_arm_action(self):\n",
    "        \"\"\" Select an action based on the most recently updated q-values. The action is chosen greedily, getting\n",
    "            the action with the maximum q-value all the times. This leads to no exploration by the agent, which\n",
    "            will always select the last best-action.\n",
    "        \"\"\"\n",
    "        if self.q_values[0] == self.q_values[1]:\n",
    "            new_action = random.randint(0, 1)\n",
    "        else:\n",
    "            new_action = np.argmax(self.q_values)\n",
    "        self.last_action = new_action\n",
    "        return new_action\n",
    "    \n",
    "    #  Decorate buy() function.\n",
    "    buy = modify_buy(Player.buy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementing the reset_val() function also for the not-RL based player."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player_dummy(Player):\n",
    "    def reset_val(self, name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck):\n",
    "        \"\"\" Reset Player's info (cash, properties, etc.). This function is used to reset\n",
    "            the player's information, so that at each game we don't have to create a new\n",
    "            Player object.\n",
    "        \"\"\"\n",
    "        super().__init__(name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We run 10K simulations where at each iteration the seed of the random value is changed. This will modify the values of the dice used in each game, providing different games results. At the end of the simulation, we compare the number of times each player has won the game. We randomize which player starts first to further avoid bias in the results.\n",
    "\n",
    "Note: We set a maximum number of turns equal to 1000 because there are situations in which the game doesn't end. This is possible in the game of Monopoly, though the number of times this happens might depend on the implementation as well. For now, we analyze results filtering out the occurrences where the game didn't end.\n",
    "    \n",
    "Player 1 is the dummy player and player 2 is the RL-based player. The action-values for player 2 are not updated when the game ends in stalemate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:32<00:00, 309.33it/s]\n"
     ]
    }
   ],
   "source": [
    "list_results = []\n",
    "list_scores = [0]\n",
    "list_averages = []          #  Keep track of the average reward (just for reporting/plotting purpose)\n",
    "count_games_with_end = 0\n",
    "list_actions = []           #  Keep track of the actions taken by player 2 (just for reporting purpose)\n",
    "\n",
    "for seed in tqdm(range(0, 10000)):\n",
    "    random.seed(seed)\n",
    "    bank = get_bank()\n",
    "    dict_board = get_board()\n",
    "    dict_roads = get_roads()\n",
    "    dict_properties = get_properties()\n",
    "    dict_community_chest_cards = get_community_chest_cards()\n",
    "    community_cards_deck = list(dict_community_chest_cards.keys())\n",
    "    if seed == 0:\n",
    "        player1 = Player_dummy('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        player2 = Player_brown_k_arm_greedy('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "    else:\n",
    "        player1.reset_val('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        player2.reset_val('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "\n",
    "    player1.meet_other_players([player2])\n",
    "    player2.meet_other_players([player1])\n",
    "\n",
    "    list_players = [player1, player2]\n",
    "    random.shuffle(list_players)  # Shuffle so that player1 doesn't always start first\n",
    "\n",
    "    idx_count = 0\n",
    "    while not player1.has_lost() and not player2.has_lost() and idx_count < 1000:\n",
    "        for player in list_players:\n",
    "            player.play()\n",
    "        idx_count += 1\n",
    "    \n",
    "    if player1.has_lost() or player2.has_lost():\n",
    "        count_games_with_end += 1\n",
    "        if player1.has_lost():\n",
    "            list_results.append((seed, 'player1_lost', list_players[0]._name))\n",
    "            player2.won_last_game_with_brown = 1\n",
    "            list_scores.append(list_scores[-1] + 1)\n",
    "        else:\n",
    "            list_results.append((seed, 'player2_lost', list_players[0]._name))\n",
    "            player2.won_last_game_with_brown = 0\n",
    "            list_scores.append(list_scores[-1] + 0)\n",
    "        player2.update_q_values()\n",
    "        list_averages.append(list_scores[-1]/count_games_with_end)\n",
    "        list_actions.append(player2.last_action)\n",
    "    else:\n",
    "        list_results.append((seed, 'nobody_lost', list_players[0]._name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot below shows the average reward throw time. The average reward is estimated only when the player wins or loses, discarding the situations in which the game doesn't end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Average reward')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ser_avg_reward = pd.Series(list_averages, name='average_reward')\n",
    "\n",
    "ax = ser_avg_reward.plot(figsize=(10, 6), linewidth=2)\n",
    "ax.set_title('Average reward of the greedy player', fontsize=28)\n",
    "ax.set_xlabel('Games played', fontsize=22)\n",
    "ax.set_ylabel('Average reward', fontsize=22)\n",
    "\n",
    "# fig = ax.get_figure()\n",
    "# fig.savefig('images/k_arm_greedy_no_brown_avg_reward.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It should be noted that the player 2 always decides to buy the brown property (action=1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 2 choses action 1 (buy brown) 8679 times out of 8679\n"
     ]
    }
   ],
   "source": [
    "print('Player 2 choses action 1 (buy brown) {} times out of {}'.format(sum(list_actions), len(list_actions)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is due to how the greedy algorithm works, where each time the action with the highest action-value is chosen. Since the first action of player 2 is buy(), ending in a victory, the action-value for the action \"buy\" is updated, getting higher than 0. This is the exploitation-exploration dilemma, where the agent greedily decides to choose the action with the highest reward (exploitation), without trying to embrace different behaviours (exploration)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Player 2 finally follows the same strategy as player 1 (buy alwasy), so it behaves exactly like a dummy player, hence player 2 is not statistically stronger than player 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "player 1 started 4320 times and lost 4271 times\n",
      "player 2 started 4359 times and lost 4408 times\n",
      "nobody lost 1321 times\n"
     ]
    }
   ],
   "source": [
    "df_res = pd.DataFrame(list_results, columns=['seed', 'lost_player', 'starting_player'])\n",
    "n_lost_p1 = df_res[df_res.lost_player == 'player1_lost'].shape[0]\n",
    "n_lost_p2 = df_res[df_res.lost_player == 'player2_lost'].shape[0]\n",
    "count_start_p1 = df_res[(df_res.starting_player == 'player1') & (df_res.lost_player != 'nobody_lost')].shape[0]\n",
    "count_start_p2 = df_res[(df_res.starting_player == 'player2') & (df_res.lost_player != 'nobody_lost')].shape[0]\n",
    "\n",
    "print('player 1 started {} times and lost {} times'.format(count_start_p1, n_lost_p1))\n",
    "print('player 2 started {} times and lost {} times'.format(count_start_p2, n_lost_p2))\n",
    "print('nobody lost {} times'.format(df_res[df_res.lost_player == 'nobody_lost'].shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.14433079836105622"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binom_test(x=n_lost_p1, n=n_lost_p1+n_lost_p2, p=1/2, alternative='two-sided')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Epsilon-Greedy agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we implement an epsilon-greedy K-arm algorithm. Unlike in the previous section, we do not select the action with the highest q-value. Instead, the action is chosen at random with probability $ \\epsilon$ (in this section we use $ \\epsilon=0.5$). In particular, the action is selected using the following rule:\n",
    "\n",
    "$\\left\\{\\begin{matrix} \\underset{a}{\\arg\\max} \\ Q(a)\n",
    " & \\ with \\ probability \\ 1- \\epsilon \\\\ \n",
    " random \\ action & \\ with \\ probability \\ \\epsilon \\ \\ \\ \\ \\ \\\n",
    "\\end{matrix}\\right.\n",
    "$\n",
    "\n",
    "This allows the agent to explore multiple actions at different times, instead of greedily choosing always the last best action, allowing it not to get stuck on the same decision.\n",
    "\n",
    "We inherit the Player_brown_k_arm_epsilon_greedy from the previously created class Player_brown_k_arm_greedy (previously inherited from the class Player). This allows us to save some code, as the only things we need to modify are: 1) function brown_k_arm_action, 2) add the epsilon variable to the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player_brown_k_arm_epsilon_greedy(Player_brown_k_arm_greedy):\n",
    "    def __init__(self, name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck):\n",
    "        super().__init__(name, number, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        self.epsilon = 0.5\n",
    "        \n",
    "    def brown_k_arm_action(self):\n",
    "        \"\"\" Select action randomly with probability epsilon, or use the greedy algorirhm with probability\n",
    "            - - epsilon.\n",
    "        \"\"\"\n",
    "        if self.q_values[0] == self.q_values[1]:\n",
    "            new_action = random.randint(0, 1)\n",
    "        else:\n",
    "            rnd = np.random.random()\n",
    "            if rnd < self.epsilon:\n",
    "                new_action = np.random.randint(0, len(self.q_values))\n",
    "            else:\n",
    "                new_action = np.argmax(self.q_values)\n",
    "                \n",
    "        self.last_action = new_action\n",
    "        return new_action\n",
    "    \n",
    "    #  Decorate buy() function.\n",
    "    buy = modify_buy(Player.buy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:32<00:00, 310.39it/s]\n"
     ]
    }
   ],
   "source": [
    "list_results = []\n",
    "list_scores = [0]\n",
    "list_averages = []          #  Keep track of the average reward (just for reporting/plotting purpose)\n",
    "count_games_with_end = 0\n",
    "list_actions = []           #  Keep track of the actions taken by player 2 (just for reporting purpose)\n",
    "\n",
    "for seed in tqdm(range(0, 10000)):\n",
    "    random.seed(seed)\n",
    "    bank = get_bank()\n",
    "    dict_board = get_board()\n",
    "    dict_roads = get_roads()\n",
    "    dict_properties = get_properties()\n",
    "    dict_community_chest_cards = get_community_chest_cards()\n",
    "    community_cards_deck = list(dict_community_chest_cards.keys())\n",
    "    if seed == 0:\n",
    "        player1 = Player_dummy('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        player2 = Player_brown_k_arm_epsilon_greedy('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "    else:\n",
    "        player1.reset_val('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "        player2.reset_val('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "\n",
    "    player1.meet_other_players([player2])\n",
    "    player2.meet_other_players([player1])\n",
    "\n",
    "    list_players = [player1, player2]\n",
    "    random.shuffle(list_players)  # Shuffle so that player1 doesn't always start first\n",
    "\n",
    "    idx_count = 0\n",
    "    while not player1.has_lost() and not player2.has_lost() and idx_count < 1000:\n",
    "        for player in list_players:\n",
    "            player.play()\n",
    "        idx_count += 1\n",
    "    \n",
    "    if player1.has_lost() or player2.has_lost():\n",
    "        count_games_with_end += 1\n",
    "        if player1.has_lost():\n",
    "            list_results.append((seed, 'player1_lost', list_players[0]._name))\n",
    "            player2.won_last_game_with_brown = 1\n",
    "            list_scores.append(list_scores[-1] + 1)\n",
    "        else:\n",
    "            list_results.append((seed, 'player2_lost', list_players[0]._name))\n",
    "            player2.won_last_game_with_brown = 0\n",
    "            list_scores.append(list_scores[-1] + 0)\n",
    "        player2.update_q_values()\n",
    "        list_averages.append(list_scores[-1]/count_games_with_end)\n",
    "        list_actions.append(player2.last_action)\n",
    "    else:\n",
    "        list_results.append((seed, 'nobody_lost', list_players[0]._name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Average reward')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ser_avg_reward_eps05 = pd.Series(list_averages, name='average_reward')\n",
    "\n",
    "ax = ser_avg_reward_eps05.plot(figsize=(10, 6), linewidth=2)\n",
    "ax.set_title('Average reward of the epsilon-greedy player ($\\epsilon=0.5$)', fontsize=28)\n",
    "ax.set_xlabel('Games played', fontsize=22)\n",
    "ax.set_ylabel('Average reward', fontsize=22)\n",
    "\n",
    "# fig = ax.get_figure()\n",
    "# fig.savefig('images/k_arm_epsilon_greedy_05_no_brown_avg_reward.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 2 choses action 1 (buy brown) 7299 times out of 8673\n"
     ]
    }
   ],
   "source": [
    "print('Player 2 choses action 1 (buy brown) {} times out of {}'.format(sum(list_actions), len(list_actions)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "player 1 started 4317 times and lost 4191 times\n",
      "player 2 started 4356 times and lost 4482 times\n",
      "nobody lost 1327 times\n"
     ]
    }
   ],
   "source": [
    "df_res = pd.DataFrame(list_results, columns=['seed', 'lost_player', 'starting_player'])\n",
    "n_lost_p1 = df_res[df_res.lost_player == 'player1_lost'].shape[0]\n",
    "n_lost_p2 = df_res[df_res.lost_player == 'player2_lost'].shape[0]\n",
    "count_start_p1 = df_res[(df_res.starting_player == 'player1') & (df_res.lost_player != 'nobody_lost')].shape[0]\n",
    "count_start_p2 = df_res[(df_res.starting_player == 'player2') & (df_res.lost_player != 'nobody_lost')].shape[0]\n",
    "\n",
    "print('player 1 started {} times and lost {} times'.format(count_start_p1, n_lost_p1))\n",
    "print('player 2 started {} times and lost {} times'.format(count_start_p2, n_lost_p2))\n",
    "print('nobody lost {} times'.format(df_res[df_res.lost_player == 'nobody_lost'].shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random choice between the \"buy\" and \"do-not-buy\" brown properties leads player 2 to lose several games. Unlike before, the null hypothesis in the statistical test is rejected, since player 1 is statistically stronger than player 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0018443039790837989"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binom_test(x=n_lost_p1, n=n_lost_p1+n_lost_p2, p=1/2, alternative='two-sided')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though player 2 loses a few games, this allows the agent to test what's the best strategy overall, the q-values for both the action is updated. Looking at the final q-values, it can be noted that the \"buy\" action has the highest value, suggesting the buying the brown properties is the best action. It should also be noted that the q-value for the \"do-not-buy action\" is relatively high. Intuitively, this can be explained by the fact that buying or not buying properties of a specific colour is not a very \"granular\" action, and there can be several occasions when even not buying brown colour, a player can win a game. Better and more specific strategies should be selected (e.g., buy/do-not-buy a road/station/utility) or having an ad-hoc action for each situation (see contextual bandits)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.42649199417758316, 0.49390327442115356]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player2.q_values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Epsilon-Greedy agent (multiple $\\epsilon$ values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we compare results using the epsilon-greedy agent with different values for $\\epsilon$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:33<00:00, 302.87it/s]\n",
      "100%|██████████| 10000/10000 [00:32<00:00, 304.62it/s]\n",
      "100%|██████████| 10000/10000 [00:32<00:00, 307.25it/s]\n",
      "100%|██████████| 10000/10000 [00:33<00:00, 302.48it/s]\n"
     ]
    }
   ],
   "source": [
    "list_series = []            #  Store Pandas Series with rewards for each epsilon\n",
    "\n",
    "for eps in [0.1, 0.5, 0.7, 0.9]:\n",
    "    list_results = []\n",
    "    list_scores = [0]\n",
    "    list_averages = []          #  Keep track of the average reward (just for reporting/plotting purpose)\n",
    "    count_games_with_end = 0\n",
    "    for seed in tqdm(range(0, 10000)):\n",
    "        random.seed(seed)\n",
    "        bank = get_bank()\n",
    "        dict_board = get_board()\n",
    "        dict_roads = get_roads()\n",
    "        dict_properties = get_properties()\n",
    "        dict_community_chest_cards = get_community_chest_cards()\n",
    "        community_cards_deck = list(dict_community_chest_cards.keys())\n",
    "        if seed == 0:\n",
    "            player1 = Player_dummy('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "            player2 = Player_brown_k_arm_epsilon_greedy('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "            player2.epsilon = eps\n",
    "        else:\n",
    "            player1.reset_val('player1', 1, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "            player2.reset_val('player2', 2, bank, dict_board, dict_roads, dict_properties, community_cards_deck)\n",
    "\n",
    "        player1.meet_other_players([player2])\n",
    "        player2.meet_other_players([player1])\n",
    "\n",
    "        list_players = [player1, player2]\n",
    "        random.shuffle(list_players)  # Shuffle so that player1 doesn't always start first\n",
    "\n",
    "        idx_count = 0\n",
    "        while not player1.has_lost() and not player2.has_lost() and idx_count < 1000:\n",
    "            for player in list_players:\n",
    "                player.play()\n",
    "            idx_count += 1\n",
    "\n",
    "        if player1.has_lost() or player2.has_lost():\n",
    "            count_games_with_end += 1\n",
    "            if player1.has_lost():\n",
    "                list_results.append((seed, 'player1_lost', list_players[0]._name))\n",
    "                player2.won_last_game_with_brown = 1\n",
    "                list_scores.append(list_scores[-1] + 1)\n",
    "            else:\n",
    "                list_results.append((seed, 'player2_lost', list_players[0]._name))\n",
    "                player2.won_last_game_with_brown = 0\n",
    "                list_scores.append(list_scores[-1] + 0)\n",
    "            player2.update_q_values()\n",
    "            list_averages.append(list_scores[-1]/count_games_with_end)\n",
    "        else:\n",
    "            list_results.append((seed, 'nobody_lost', list_players[0]._name))\n",
    "    series_tmp = pd.Series(list_averages, name='average_reward')\n",
    "    series_tmp.name = 'epsilon ' + str(eps)\n",
    "    list_series.append(series_tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_res = pd.concat(list_series, axis=1)\n",
    "\n",
    "ax = df_res.plot(figsize=(10, 6), linewidth=2)\n",
    "ax.set_title('Average reward of the epsilon-greedy player', fontsize=28)\n",
    "ax.set_xlabel('Games played', fontsize=22)\n",
    "ax.set_ylabel('Average reward', fontsize=22)\n",
    "\n",
    "fig = ax.get_figure()\n",
    "fig.savefig('images/k_arm_epsilon_greedy_multi_eps_no_brown_avg_reward.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}