def test_board_card_plays(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)]
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([0, 2])
self.assertEqual([2, 0], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([2, 0])
self.assertEqual([0, 2], payoffs.tolist())
def test_bet_fold(self):
bet_sequences = [(PlayerActions.BET_RAISE, PlayerActions.FOLD), ()]
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([1, 2])
self.assertEqual([2, 0], payoffs.tolist())
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE,
PlayerActions.FOLD), ()]
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([2, 1])
self.assertEqual([0, 2], payoffs.tolist())
def test_call_reraise_r2(self):
cost = LeducPokerGame.LeducNode(
bet_sequences=[(PlayerActions.CHECK_CALL,
PlayerActions.CHECK_CALL),
(PlayerActions.BET_RAISE, PlayerActions.BET_RAISE)],
board_card=0).add_action(PlayerActions.CHECK_CALL)
self.assertEqual(4, cost)
def test_round2_bets_are_4_check_reraise(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
(PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE,
PlayerActions.BET_RAISE, PlayerActions.CHECK_CALL)]
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([1, 2])
self.assertEqual([0, 18], payoffs.tolist())
def test_game_rrc_is_round_1(self):
bet_sequence = (PlayerActions.BET_RAISE, PlayerActions.BET_RAISE,
PlayerActions.CHECK_CALL)
self.assertEqual(
1,
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).game_round)
def test_r2_cannot_raise_after_crr(self):
r1_actions = (PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)
bet_sequence = (PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE,
PlayerActions.BET_RAISE)
self.assertFalse(
LeducPokerGame.LeducNode([r1_actions, bet_sequence],
board_card=0).can_raise)
def test_suits_are_equivalent(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)]
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=0).get_payoffs([3, 2])
self.assertEqual([2, 0], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=3).get_payoffs([0, 2])
self.assertEqual([2, 0], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=2).get_payoffs([0, 5])
self.assertEqual([0, 2], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=5).get_payoffs([0, 2])
self.assertEqual([0, 2], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=1).get_payoffs([0, 4])
self.assertEqual([0, 2], payoffs.tolist())
payoffs = LeducPokerGame.LeducNode(bet_sequences=bet_sequences,
board_card=4).get_payoffs([0, 1])
self.assertEqual([0, 2], payoffs.tolist())
def eval_exploitability(self, policy: Policies.Policy):
values = np.zeros((2, 1, NUM_HOLDINGS))
reach = np.ones((2, NUM_BOARD, NUM_HOLDINGS))
self._eval(policy, LeducPoker.LeducGameState(
player_cards=[0, 1], bet_sequences=[(), ()], board_card=None), reach, values)
exploitability = np.zeros(2)
for p in range(2):
for h in range(NUM_HOLDINGS):
exploitability[p] += values[p][0][h]
return exploitability
def get_game_value(self) -> float:
game_values = []
for my_card in LeducPoker.LeducPokerGame.DECK:
opponent_card_probs = np.array([1 / 5] * 6)
opponent_card_probs[my_card] = 0
my_infoset = LeducPoker.LeducInfoset(card=my_card,
bet_sequences=[(), ()],
board_card=None)
game_value = self._get_game_state_value(my_infoset,
opponent_card_probs)
game_values.append(game_value[self.player_num])
return sum(game_values) / len(game_values)
def _get_opponent_game_value(
self, my_infoset: LeducPoker.LeducInfoset,
opponent_card_probs: np.ndarray) -> np.ndarray:
cards_to_action_probs = {}
total_action_probs = np.zeros(3)
for opponent_card in LeducPoker.LeducPokerGame.DECK:
if opponent_card == my_infoset.card or opponent_card == my_infoset.board_card:
assert opponent_card_probs[opponent_card] == 0
continue
opponent_infoset = LeducPoker.LeducInfoset(
card=opponent_card,
bet_sequences=my_infoset.bet_sequences,
board_card=my_infoset.board_card)
action_probs = self.opponent_policy.action_prob(opponent_infoset)
if not my_infoset.can_raise:
action_probs[PlayerActions.CHECK_CALL] += action_probs[
PlayerActions.BET_RAISE]
action_probs[PlayerActions.BET_RAISE] = 0
if not my_infoset.can_fold:
action_probs[PlayerActions.CHECK_CALL] += action_probs[
PlayerActions.FOLD]
action_probs[PlayerActions.FOLD] = 0
cards_to_action_probs[opponent_card] = action_probs
total_action_probs += opponent_card_probs[
opponent_card] * np.array(action_probs)
retval = np.zeros(2)
for action in PlayerActions.ALL_ACTIONS:
if total_action_probs[action] == 0:
continue
post_action_card_probs = opponent_card_probs.copy()
for opponent_card in LeducPoker.LeducPokerGame.DECK:
if opponent_card == my_infoset.card or opponent_card == my_infoset.board_card:
continue
post_action_card_probs[opponent_card] *= cards_to_action_probs[
opponent_card][action]
post_action_card_probs = self._normalize(post_action_card_probs)
post_action_infoset = copy.deepcopy(my_infoset)
post_action_infoset.add_action(action)
game_value = self._get_game_state_value(post_action_infoset,
post_action_card_probs)
retval += game_value * total_action_probs[action]
return retval
def test_checkraise_is_not_terminal(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
(PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE)]
self.assertFalse(
LeducPokerGame.LeducNode(bet_sequences, board_card=1).is_terminal)
def test_cannot_fold_after_c_r2(self):
r1_bet_sequence = (PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)
bet_sequence = (PlayerActions.CHECK_CALL, )
self.assertFalse(
LeducPokerGame.LeducNode([r1_bet_sequence, bet_sequence],
board_card=0).can_fold)
def test_can_fold_after_cr_r2(self):
r1_bet_sequence = (PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)
bet_sequence = (PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE)
self.assertTrue(
LeducPokerGame.LeducNode([r1_bet_sequence, bet_sequence],
board_card=0).can_fold)
def test_p2_folds_is_terminal(self):
bet_sequence = (PlayerActions.BET_RAISE, PlayerActions.BET_RAISE,
PlayerActions.FOLD)
self.assertTrue(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).is_terminal)
def test_r2_can_raise_after_c(self):
r1_actions = (PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL)
bet_sequence = (PlayerActions.CHECK_CALL, )
self.assertTrue(
LeducPokerGame.LeducNode([r1_actions, bet_sequence],
board_card=0).can_raise)
def test_game_r_is_round_0(self):
bet_sequence = (PlayerActions.BET_RAISE, )
self.assertEqual(
0,
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).game_round)
def test_game_start_is_not_terminal(self):
bet_sequence = ()
self.assertFalse(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).is_terminal)
def test_final_call_r1(self):
cost = LeducPokerGame.LeducNode(
bet_sequences=[(PlayerActions.BET_RAISE, PlayerActions.BET_RAISE,
PlayerActions.BET_RAISE), ()],
board_card=None).add_action(PlayerActions.CHECK_CALL)
self.assertEqual(2, cost)
def test_reraise_r1(self):
cost = LeducPokerGame.LeducNode(
bet_sequences=[(PlayerActions.BET_RAISE, ), ()],
board_card=None).add_action(PlayerActions.BET_RAISE)
self.assertEqual(5, cost)
def test_cc_r1(self):
cost = LeducPokerGame.LeducNode(
bet_sequences=[(PlayerActions.CHECK_CALL, ), ()],
board_card=None).add_action(PlayerActions.CHECK_CALL)
self.assertEqual(1, cost)
def test_first_bet(self):
cost = LeducPokerGame.LeducNode(bet_sequences=[(), ()],
board_card=None).add_action(
PlayerActions.BET_RAISE)
self.assertEqual(3, cost)
def test_can_raise_after_cr(self):
bet_sequence = (PlayerActions.CHECK_CALL, PlayerActions.BET_RAISE)
self.assertTrue(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).can_raise)
def test_can_fold_after_r(self):
bet_sequence = (PlayerActions.BET_RAISE, )
self.assertTrue(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).can_fold)
def test_first_check_is_free_r2(self):
cost = LeducPokerGame.LeducNode(
bet_sequences=[(PlayerActions.CHECK_CALL,
PlayerActions.CHECK_CALL), ()],
board_card=0).add_action(PlayerActions.CHECK_CALL)
self.assertEqual(0, cost)
def test_round1_is_not_terminal(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
()]
self.assertFalse(
LeducPokerGame.LeducNode(bet_sequences, board_card=1).is_terminal)
def test_can_open_raise(self):
bet_sequence = ()
self.assertTrue(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).can_raise)
def test_game_start_is_round_0(self):
bet_sequence = ()
self.assertEqual(
0,
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).game_round)
def test_nonterminal_payoff_raises_exception(self):
with self.assertRaises(RuntimeError):
LeducPokerGame.LeducNode(bet_sequences=[(), ()],
board_card=0).get_payoffs([0, 0])
def test_raisecall_showdown_is_terminal(self):
bet_sequences = [(PlayerActions.CHECK_CALL, PlayerActions.CHECK_CALL),
(PlayerActions.BET_RAISE, PlayerActions.CHECK_CALL)]
self.assertTrue(
LeducPokerGame.LeducNode(bet_sequences, board_card=1).is_terminal)
def test_cannot_raise_after_rr(self):
bet_sequence = (PlayerActions.BET_RAISE, PlayerActions.BET_RAISE)
self.assertFalse(
LeducPokerGame.LeducNode([bet_sequence, ()],
board_card=0).can_raise)
