Test probability engine

.gitignore

@@ -2,6 +2,8 @@ __pycache__/
 A.txt
 B.txt
 gamelog.txt
+game_log_analyze.txt
+monte_carlo_test_logs.txt
 *.class
 .DS_Store
 .idea/

python_skeleton/player.py

@@ -9,6 +9,7 @@
 import helper
 import random
 import eval7
+import probability_engine
 
 
 class Player(Bot):

python_skeleton/skeleton/monte_carlo_tests.py

@@ -0,0 +1,364 @@
+import time
+import eval7
+import sys
+
+from probability_engine import Probability_Engine
+
+class Pseudo_Round_State():
+    def __init__(self):
+        self.street = 0
+        self.deck = []
+
+class Monte_Carlo_Tests():
+    def __init__(self):
+        self.probability_engine = Probability_Engine()
+
+    def test_all(self, iters, precision, sim):
+        print('=================================================')
+        print('Testing Probability Engine on the Flop, Turn, and River')
+
+        flop_results = self.test_flop(iters, precision, sim)
+        turn_results = self.test_turn(iters, precision, sim)
+        river_results =  self.test_river(iters, precision, sim)
+
+        print('=================================================')
+        print(f'Ran {3 * iters} tests, {iters} tests on each flop, turn, and river, and half with auction, half without auction')
+        print(f'Average Auction Diff: {flop_results[0] + turn_results[0] + river_results[0] / (iters * 3)}')
+        print(f'Average Non Auction Diff: {flop_results[1] + turn_results[1] + river_results[1] / (iters * 3)}')
+        print(f'Average Engine Runtime: {flop_results[2] + turn_results[2] + river_results[2] / (iters * 3)}')
+        print(f'Average Sim Runtime: {flop_results[3] + turn_results[3] + river_results[3] / (iters * 3)}')
+
+        return (flop_results[0] + turn_results[0] + river_results[0] / (iters * 3), 
+                flop_results[1] + turn_results[1] + river_results[1] / (iters * 3),
+                flop_results[2] + turn_results[2] + river_results[2] / (iters * 3),
+                flop_results[3] + turn_results[3] + river_results[3] / (iters * 3))
+
+    def test_flop(self, iters, precision, sim):
+        print('=================================================')
+        print(f'Testing Probability Engine on the Flop')
+
+        engine_runtime = 0 
+        sim_runtime = 0
+
+        print('=================================================')
+        print('Testing with auction card')
+
+        avg_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(6)
+            my_cards = [str(card) for card in draw[:3]]
+            board_cards = [str(card) for card in draw[3:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:3], draw[3:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print('Testing without auction card')
+
+        avg_non_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(5)
+            my_cards = [str(card) for card in draw[:2]]
+            board_cards = [str(card) for card in draw[2:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:2], draw[2:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_non_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print(f'Ran {iters} tests, half with auction and half without auction')
+        print(f'Average Auction Diff: {avg_auction_diff / (iters // 2)}')
+        print(f'Average Non Auction Diff: {avg_non_auction_diff / (iters // 2)}')
+        print(f'Average Engine Runtime: {engine_runtime / (iters // 2)}')
+        print(f'Average Sim Runtime: {sim_runtime / (iters // 2)}')
+
+        return (avg_auction_diff / (iters // 2), avg_non_auction_diff / (iters // 2), engine_runtime / (iters // 2), sim_runtime / (iters // 2))
+
+
+    def test_turn(self, iters, precision, sim):
+        print('=================================================')
+        print(f'Testing Probability Engine on the Turn')
+
+        engine_runtime = 0 
+        sim_runtime = 0
+
+        print('=================================================')
+        print('Testing with auction card')
+
+        avg_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(7)
+            my_cards = [str(card) for card in draw[:3]]
+            board_cards = [str(card) for card in draw[3:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:3], draw[3:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print('Testing without auction card')
+
+        avg_non_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(6)
+            my_cards = [str(card) for card in draw[:2]]
+            board_cards = [str(card) for card in draw[2:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:2], draw[2:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_non_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print(f'Ran {iters} tests, half with auction and half without auction')
+        print(f'Average Auction Diff: {avg_auction_diff / (iters // 2)}')
+        print(f'Average Non Auction Diff: {avg_non_auction_diff / (iters // 2)}')
+        print(f'Average Engine Runtime: {engine_runtime / (iters // 2)}')
+        print(f'Average Sim Runtime: {sim_runtime / (iters // 2)}')
+
+        return (avg_auction_diff / (iters // 2), avg_non_auction_diff / (iters // 2), engine_runtime / (iters // 2), sim_runtime / (iters // 2))
+
+    def test_river(self, iters, precision, sim):
+        print('=================================================')
+        print(f'Testing Probability Engine on the River')
+
+        engine_runtime = 0 
+        sim_runtime = 0
+
+        print('=================================================')
+        print('Testing with auction card')
+
+        avg_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(8)
+            my_cards = [str(card) for card in draw[:3]]
+            board_cards = [str(card) for card in draw[3:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:3], draw[3:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print('Testing without auction card')
+
+        avg_non_auction_diff = 0
+
+        for _ in range(iters // 2):
+            print('-------------------------')
+
+            deck = eval7.Deck()
+            deck.shuffle()
+            draw = deck.peek(7)
+            my_cards = [str(card) for card in draw[:2]]
+            board_cards = [str(card) for card in draw[2:]]
+
+            round_state = Pseudo_Round_State()
+            round_state.street = 3
+            round_state.deck = board_cards
+
+            print(f'my_cards = {my_cards}')
+            print(f'board_cards = {board_cards}')
+
+            engine_start = time.time()
+            engine_probability = self.probability_engine.calculate_win_probability(my_cards, round_state, sim)
+            engine_end = time.time()
+
+            sim_start = time.time()
+            monte_carlo_probability = self.probability_engine.monte_carlo_flop_and_turn(draw[:2], draw[2:], deck, precision)
+            sim_end = time.time()
+
+            net_diff = abs(engine_probability - monte_carlo_probability)
+
+            avg_non_auction_diff += net_diff
+            engine_runtime += engine_end - engine_start
+            sim_runtime += sim_end - sim_start
+
+            print('Probabilities')
+            print(f'Engine: {engine_probability} | Sim: {monte_carlo_probability} | Diff: {net_diff}')
+            print('Runtimes')
+            print(f'Engine: {engine_end - engine_start} | Sim: {sim_end - sim_start} | Diff: {abs((engine_end - engine_start) - (sim_end - sim_start))}')
+
+        print('=================================================')
+        print(f'Ran {iters} tests, half with auction and half without auction')
+        print(f'Average Auction Diff: {avg_auction_diff / (iters // 2)}')
+        print(f'Average Non Auction Diff: {avg_non_auction_diff / (iters // 2)}')
+        print(f'Average Engine Runtime: {engine_runtime / (iters // 2)}')
+        print(f'Average Sim Runtime: {sim_runtime / (iters // 2)}')
+
+        return (avg_auction_diff / (iters // 2), avg_non_auction_diff / (iters // 2), engine_runtime / (iters // 2), sim_runtime / (iters // 2))
+
+
+if __name__ == '__main__':
+
+    ###################################################
+    # Calculate winrate using engine on a single hand #
+    ###################################################
+
+    # # Initialize Test
+    # round_state = Pseudo_Round_State()
+    # engine = Probability_Engine()
+
+    # # Set up Arguments
+    # my_cards = ['6d', '7s', 'Qs']
+    # board_cards = ['3c', 'Ad', '8h']
+    # round_state.street = 3
+    # round_state.deck = board_cards
+    # monte_carlo_sim_iters = 0
+
+    # # Run Test
+    # print(engine.calculate_win_probability(my_cards, round_state, monte_carlo_sim_iters))
+
+    #########################
+    # Run Monte Carlo Tests #
+    #########################
+
+    # Initialize Test
+    temp = sys.stdout
+    sys.stdout = open('monte_carlo_test_logs.txt','wt')
+    test_suite = Monte_Carlo_Tests()
+
+    # Set up Arguments
+    iters = 1000
+    precision = 10000
+    sim = 10
+
+    # Run Test
+    test_suite.test_all(iters, precision, sim)
+
+    # Close Test
+    temp = sys.stdout