def test_threecard(self):
hole = [Card(Card.CLUB, 3), Card(Card.CLUB, 4)]
val = HandEvaluator.THREECARD | (5 << 4) | 0
self.false(ContributionChecker.check(hole, val))
val = HandEvaluator.THREECARD | (3 << 4) | 0
self.true(ContributionChecker.check(hole, val))
val = HandEvaluator.THREECARD | (4 << 4) | 0
self.true(ContributionChecker.check(hole, val))
def test_onepair(self):
hole = [Card(Card.CLUB, 3), Card(Card.CLUB, 4)]
val = HandEvaluator.ONEPAIR | (5 << 4) | 0
self.false(ContributionChecker.check(hole, val))
val = HandEvaluator.ONEPAIR | (4 << 4) | 0
self.true(ContributionChecker.check(hole, val))
val = HandEvaluator.ONEPAIR | (3 << 4) | 0
self.true(ContributionChecker.check(hole, val))
def test_twopair(self):
hole = [Card(Card.CLUB, 3), Card(Card.CLUB, 4)]
val = HandEvaluator.TWOPAIR | (14 << 4) | 5
self.false(ContributionChecker.check(hole, val))
val = HandEvaluator.TWOPAIR | (14 << 4) | 3
self.true(ContributionChecker.check(hole, val))
val = HandEvaluator.TWOPAIR | (3 << 4) | 14
self.true(ContributionChecker.check(hole, val))
def test_straight(self):
hole = [Card(Card.CLUB, 7), Card(Card.CLUB, 8)]
val = HandEvaluator.STRAIGHT | (6 << 4) | 0
self.true(ContributionChecker.check(hole, val))
val = HandEvaluator.STRAIGHT | (8 << 4) | 0
self.false(ContributionChecker.check(hole, val))
val = HandEvaluator.STRAIGHT | (3 << 4) | 0
self.false(ContributionChecker.check(hole, val))
def test_predict_on_flop(self):
model = Neuralnet("flop")
model.compile()
hole = [Card(suit=Card.SPADE, rank=4), Card(suit=Card.SPADE, rank=2)]
community = [
Card(suit=Card.DIAMOND, rank=12),
Card(suit=Card.CLUB, rank=11),
Card(suit=Card.DIAMOND, rank=10)
]
prediction = model.predict(hole, community)
self.almosteq(0.29, prediction, 0.01)
def to_hole_card(self, available_suits=None):
if not available_suits:
SUITS = np.array([2, 4, 8, 16])
cards = []
for rank in self.ranks:
cards.append(Card(np.random.choice(SUITS, 1), rank))
return cards
cards = [
Card(x[0], x[1]) for x in assign_suit(self.ranks, available_suits)
]
# print('--')
return cards
def test_act__when_odds_average__call(self):
cards = [Card(Suit.diamonds, Rank.Ace), Card(Suit.diamonds, Rank.King), ]
community_cards = []
def mock_estimation(cards1, community_cards1):
if cards1 == [Card.from_str("DA"), Card.from_str("DK")] and community_cards1 == []:
return 0.2
raise Exception("Bad arguments passed in test")
player = ComputerPlayer("myComputer", 100)
player.estimate_winrate = mock_estimation
player.money_in_pot = 0
player.receive_cards(cards)
player.see_community_cards(community_cards)
decision, amount = player.act(10)
self.assertEqual(Action.ACTION_CALL, decision)
self.assertEqual(10, amount)
def test_act__when_chances_to_win_small_and_check_is_available__check(self):
cards = [Card(Suit.diamonds, Rank.r3), Card(Suit.diamonds, Rank.r9), ]
community_cards = [Card(Suit.hearts, Rank.r6), Card(Suit.hearts, Rank.r7), Card(Suit.hearts, Rank.r8)]
def mock_estimation(cards1, community_cards1):
if cards1 == [Card.from_str("D3"), Card.from_str("D9")] and community_cards1 == [Card.from_str("H6"), Card.from_str("H7"), Card.from_str("H8")]:
return 0.1
raise Exception("Bad arguments passed in test")
player = ComputerPlayer("myComputer", 100)
player.estimate_winrate = mock_estimation
player.money_in_pot = 10
player.receive_cards(cards)
player.see_community_cards(community_cards)
decision, amount = player.act(10)
self.assertEqual(Action.ACTION_CALL, decision)
self.assertEqual(10, amount)
def test_act__when_chances_to_win_small_and_call_is_required__fold(self):
cards = [Card(Suit.diamonds, Rank.r2), Card(Suit.diamonds, Rank.r10), ]
community_cards = []
def mock_estimation(cards1, community_cards1):
if cards1 == [Card.from_str("D2"), Card.from_str("DT")] and community_cards1 == []:
return 0.1
raise Exception("Bad arguments passed in test")
player = ComputerPlayer("myComputer", 100)
player.estimate_winrate = mock_estimation
player.money_in_pot = 0
player.receive_cards(cards)
player.see_community_cards(community_cards)
decision, amount = player.act(10)
self.assertEqual(Action.ACTION_FOLD, decision)
self.assertEqual(0, amount)
def test_to_string(self):
self.eq(str(Card(Card.CLUB, 1)), "CA")
self.eq(str(Card(Card.CLUB, 14)), "CA")
self.eq(str(Card(Card.CLUB, 2)), "C2")
self.eq(str(Card(Card.HEART, 10)), "HT")
self.eq(str(Card(Card.SPADE, 11)), "SJ")
self.eq(str(Card(Card.DIAMOND, 12)), "DQ")
self.eq(str(Card(Card.DIAMOND, 13)), "DK")
def test_to_string(self):
self.eq(str(Card(Card.CLUB, 1)), '2c')
self.eq(str(Card(Card.CLUB, 2)), '3c')
self.eq(str(Card(Card.HEART, 10)), 'Jh')
self.eq(str(Card(Card.SPADE, 11)), 'Qs')
self.eq(str(Card(Card.DIAMOND, 12)), 'Kd')
self.eq(str(Card(Card.DIAMOND, 13)), 'Ad')
def test_evaluate_hand(self):
community = [
Card(Card.CLUB, 3),
Card(Card.CLUB, 7),
Card(Card.CLUB, 10),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 2)]
expected = {"hand": "HIGHCARD", "strength": 37522}
self.eq(expected, U.evaluate_hand(hole, community))
def test_gen_cards(self):
self.eq([Card(rank=13, suit=4),
Card(rank=11, suit=2)], U.gen_cards(['Ac', 'Qd']))
self.eq(
[Card(rank=8, suit=8), Card(rank=9, suit=4)],
U.gen_cards(['9H', 'Tc']))
self.eq([Card(rank=10, suit=16),
Card(rank=12, suit=2)], U.gen_cards(['Js', 'Kd']))
def test_gen_cards(self):
self.eq(
[Card(rank=1, suit=2), Card(rank=12, suit=4)],
U.gen_cards(["CA", "DQ"]))
self.eq(
[Card(rank=9, suit=8), Card(rank=10, suit=2)],
U.gen_cards(["H9", "CT"]))
self.eq([Card(rank=11, suit=16),
Card(rank=13, suit=4)], U.gen_cards(["SJ", "DK"]))
def test_predict_on_river(self):
model = Neuralnet("river")
model.compile()
hole = [Card(suit=Card.SPADE, rank=1), Card(suit=Card.HEART, rank=4)]
community = [
Card(suit=Card.SPADE, rank=2),
Card(suit=Card.SPADE, rank=4),
Card(suit=Card.DIAMOND, rank=4),
Card(suit=Card.HEART, rank=1),
Card(suit=Card.HEART, rank=5)
]
prediction = model.predict(hole, community)
self.almosteq(0.97, prediction, 0.01)
def test_twopair2(self):
community = [
Card(Card.DIAMOND, 4),
Card(Card.SPADE, 8),
Card(Card.HEART, 4),
Card(Card.DIAMOND, 7),
Card(Card.CLUB, 8)
]
hole = [Card(Card.CLUB, 7), Card(Card.SPADE, 5)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.TWOPAIR,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(8, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(7, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
def test_gen_hand_info(self):
community = [
Card(Card.CLUB, 3),
Card(Card.CLUB, 7),
Card(Card.CLUB, 10),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 2)]
info = HandEvaluator.gen_hand_rank_info(hole, community)
self.eq('HIGHCARD', info['hand']['strength'])
self.eq(9, info['hand']['high'])
self.eq(2, info['hand']['low'])
self.eq(9, info['hole']['high'])
self.eq(2, info['hole']['low'])
def test_twopair(self):
community = [
Card(Card.CLUB, 7),
Card(Card.CLUB, 9),
Card(Card.DIAMOND, 2),
Card(Card.DIAMOND, 3),
Card(Card.DIAMOND, 5)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 3)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.TWOPAIR,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(9, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
def test_gen_hand_info(self):
community = [
Card(Card.CLUB, 3),
Card(Card.CLUB, 7),
Card(Card.CLUB, 10),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 2)]
info = HandEvaluator.gen_hand_rank_info(hole, community)
self.eq("HIGHCARD", info["hand"]["strength"])
self.eq(9, info["hand"]["high"])
self.eq(2, info["hand"]["low"])
self.eq(9, info["hole"]["high"])
self.eq(2, info["hole"]["low"])
def test_predict_on_turn(self):
model = Neuralnet("turn")
model.compile()
hole = [Card(suit=Card.CLUB, rank=1), Card(suit=Card.DIAMOND, rank=10)]
community = [
Card(suit=Card.HEART, rank=6),
Card(suit=Card.HEART, rank=9),
Card(suit=Card.DIAMOND, rank=8),
Card(suit=Card.CLUB, rank=11)
]
prediction = model.predict(hole, community)
self.almosteq(0.50, prediction, 0.01)
def test_eval_high_card(self):
community = [
Card(Card.CLUB, 3),
Card(Card.CLUB, 7),
Card(Card.CLUB, 10),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 2)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.HIGHCARD,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(9, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(2, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(9, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(2, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_straightflush(self):
community = [
Card(Card.DIAMOND, 4),
Card(Card.DIAMOND, 5),
Card(Card.HEART, 10),
Card(Card.HEART, 11),
Card(Card.HEART, 12)
]
hole = [Card(Card.HEART, 9), Card(Card.HEART, 13)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.STRAIGHTFLUSH,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(13, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(0, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(13, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(9, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_fullhouse(self):
community = [
Card(Card.CLUB, 4),
Card(Card.DIAMOND, 2),
Card(Card.DIAMOND, 4),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 4), Card(Card.DIAMOND, 5)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.FULLHOUSE,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(4, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(5, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(5, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(4, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_flush(self):
community = [
Card(Card.CLUB, 7),
Card(Card.DIAMOND, 2),
Card(Card.DIAMOND, 3),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 4), Card(Card.DIAMOND, 5)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.FLUSH,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(6, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(0, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(5, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(4, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_threecard(self):
community = [
Card(Card.CLUB, 3),
Card(Card.CLUB, 7),
Card(Card.DIAMOND, 3),
Card(Card.DIAMOND, 5),
Card(Card.DIAMOND, 6)
]
hole = [Card(Card.CLUB, 9), Card(Card.DIAMOND, 3)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.THREECARD,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(0, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(9, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_straight_ace_low(self):
community = [
Card(Card.CLUB, 2),
Card(Card.CLUB, 6),
Card(Card.DIAMOND, 1),
Card(Card.DIAMOND, 4),
Card(Card.DIAMOND, 13)
]
hole = [Card(Card.CLUB, 3), Card(Card.DIAMOND, 4)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.STRAIGHT,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(4, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(0, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(4, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_fullhouse2(self):
community = [
Card(Card.CLUB, 3),
Card(Card.DIAMOND, 7),
Card(Card.DIAMOND, 3),
Card(Card.HEART, 3),
Card(Card.HEART, 7)
]
hole = [Card(Card.SPADE, 8), Card(Card.SPADE, 7)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.FULLHOUSE,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(7, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(8, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(7, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
def test_fourcard(self):
community = [
Card(Card.CLUB, 3),
Card(Card.DIAMOND, 7),
Card(Card.DIAMOND, 3),
Card(Card.HEART, 3),
Card(Card.HEART, 7)
]
hole = [Card(Card.SPADE, 3), Card(Card.SPADE, 8)]
bit = HandEvaluator.eval_hand(hole, community)
self.eq(HandEvaluator.FOURCARD,
HandEvaluator._HandEvaluator__mask_hand_strength(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hand_high_rank(bit))
self.eq(0, HandEvaluator._HandEvaluator__mask_hand_low_rank(bit))
self.eq(8, HandEvaluator._HandEvaluator__mask_hole_high_rank(bit))
self.eq(3, HandEvaluator._HandEvaluator__mask_hole_low_rank(bit))
import os
import sys
root = os.path.join(os.path.dirname(__file__), "..")
sys.path.append(root)
sys.path.append(os.path.join(root, "holecardhandicapper"))
from holecardhandicapper.model.neuralnet import Neuralnet
from pypokerengine.engine.card import Card
# preflop
preflop_model = Neuralnet("preflop")
preflop_model.compile()
holecard = [Card(suit=Card.HEART, rank=1), Card(suit=Card.SPADE, rank=1)]
prediction = preflop_model.predict(holecard)
print "win rate of [ holecard=%s ] is %f" % (map(str, holecard), prediction)
# flop
flop_model = Neuralnet("flop")
flop_model.compile()
holecard = [Card(suit=Card.SPADE, rank=4), Card(suit=Card.SPADE, rank=2)]
communitycard = [Card(suit=Card.DIAMOND, rank=12), Card(suit=Card.CLUB, rank=11), Card(suit=Card.DIAMOND, rank=10)]
prediction = flop_model.predict(holecard, communitycard)
print "win rate of [ holecard=%s, communitycard=%s ] is %f" % (map(str, holecard), map(str, communitycard), prediction)
# turn
turn_model = Neuralnet("turn")
turn_model.compile()
holecard = [Card(suit=Card.CLUB, rank=1), Card(suit=Card.DIAMOND, rank=10)]
communitycard = [Card(suit=Card.HEART, rank=6), Card(suit=Card.HEART, rank=9), Card(suit=Card.DIAMOND, rank=8), Card(suit=Card.CLUB, rank=11)]
prediction = turn_model.predict(holecard, communitycard)
print "win rate of [ holecard=%s, communitycard=%s ] is %f" % (map(str, holecard), map(str, communitycard), prediction)
# ## See model prediction on sample data
# In[35]:
from pypokerengine.engine.card import Card
C, D, H, S = Card.CLUB, Card.DIAMOND, Card.HEART, Card.SPADE
test_case = [[(8, D), (4, C), (13, C), (1, C), (6, C), (2, C), 0.994],
[(3, D), (3, H), (5, H), (4, D), (5, S), (4, H), 0.11],
[(1, C), (10, D), (6, H), (9, H), (8, D), (11, C), 0.505]]
gen_one_hot = lambda target_ids: [
1 if i in target_ids else 0 for i in range(1, 53)
]
to_id = lambda card: card.to_id()
for card1, card2, card3, card4, card5, card6, expected in test_case:
cards = [
Card(rank=rank, suit=suit)
for rank, suit in [card1, card2, card3, card4, card5, card6]
]
hole = cards[:2]
community = cards[2:]
hole_onehot = gen_one_hot(map(to_id, hole))
community_onehot = gen_one_hot(map(to_id, community))
x = hole_onehot + community_onehot
X = np.array([x])
y = model.predict(X)[0][0]
print "HOLE = [%s, %s], COMMUNITY = [%s, %s, %s, %s] => win_rate = { prediction=%f, expected=%f }" % tuple(
map(str, hole) + map(str, community) + [y, expected])
