fixed parallelization bug

ee-lang · ee-lang · commit a971d1fbd989 · 2024-09-03T14:50:33.000+02:00
diff --git a/DominoGame.py b/DominoGame.py
@@ -91,7 +91,7 @@ def play_game(self):
 		games_tied = 0  # Number of tied games
 		round_scores = []  # List to store scores for each round
 		
-		winning_score = 100 if self.variant != 'international' else 1
+		winning_score = 100 if self.variant != 'international' else 150
 		
 		while max(self.scores) < winning_score:
 			round_winner, round_score = self.play_round()
diff --git a/DominoPlayer.py b/DominoPlayer.py
@@ -70,10 +70,11 @@ def next_move(self, game_state: DominoGameState, player_hand: list[tuple[int, in
 				print('illegal input', e)
 
 	def end_round(self, scores: list[int], team: int) -> None:
-		self.missing_tiles = defaultdict(set)
-		print(f"HumanPlayer: Round ended. Scores - Team 1: {scores[0]}, Team 2: {scores[1]}")
-		print(f"HumanPlayer: Your team (Team {team + 1}) score: {scores[team]}")
-		print("HumanPlayer: Reset missing tiles for the next round.")
+		# self.missing_tiles = defaultdict(set)
+		# print(f"HumanPlayer: Round ended. Scores - Team 1: {scores[0]}, Team 2: {scores[1]}")
+		# print(f"HumanPlayer: Your team (Team {team + 1}) score: {scores[team]}")
+		# print("HumanPlayer: Reset missing tiles for the next round.")
+		pass
 
 	def get_unplayed_tiles(self, game_state: DominoGameState, player_hand: list[tuple[int, int]]) -> list[tuple[int,int]]:
 		max_pip = 9 if game_state.variant == "cuban" else 6
diff --git a/analytic_agent_player_parallel.py b/analytic_agent_player_parallel.py
@@ -50,7 +50,7 @@ def next_move(self, game_state: DominoGameState, player_hand: list[tuple[int,int
         if verbose:
             self.print_verbose_info(_player_hand, _unplayed_tiles, _knowledge_tracker, _player_tiles_count, _starting_player)
 
-        num_samples = 1000 if len(game_state.history) > 8 else 100 if len(game_state.history) > 4 else 25 if len(game_state.history) > 0 else 1
+        num_samples = 1000 if len(game_state.history) > 8 else 100 if len(game_state.history) > 4 else 25 if len(game_state.history) > 0 else 25
         best_move = self.get_best_move(set(_player_hand), _remaining_tiles, _knowledge_tracker, _player_tiles_count, _board_ends, num_samples, verbose=verbose)
 
         if best_move is None:
@@ -77,7 +77,7 @@ def print_verbose_info(self, player_hand: list[DominoTile], unplayed_tiles: list
             print(f"  {PlayerPosition_names[player]}: {count}")
         print("----------------------------\n")
 
-    def sample_search(self, final_south_hand: set[DominoTile], final_remaining_tiles_without_south_tiles: set[DominoTile], player_tiles_count: dict[PlayerPosition, int], inferred_knowledge_for_current_player: CommonKnowledgeTracker, board_ends: tuple[int|None,int|None]) -> tuple[move, float]:
+    def sample_and_search(self, final_south_hand: set[DominoTile], final_remaining_tiles_without_south_tiles: set[DominoTile], player_tiles_count: dict[PlayerPosition, int], inferred_knowledge_for_current_player: dict[PlayerPosition, set[DominoTile]], board_ends: tuple[int|None,int|None]) -> list[tuple[move, float]]:
         sample = generate_sample_from_game_state(
             # PlayerPosition.SOUTH,
             PlayerPosition_SOUTH,
@@ -107,6 +107,7 @@ def sample_search(self, final_south_hand: set[DominoTile], final_remaining_tiles
 
         # possible_moves = list_possible_moves(sample_state, include_stats=False)
         possible_moves = list_possible_moves(sample_state)
+        move_scores: list[tuple[move, float]] = []
 
         sample_cache: dict[GameState, tuple[int, int]] = {}
         for move in possible_moves:
@@ -118,7 +119,9 @@ def sample_search(self, final_south_hand: set[DominoTile], final_remaining_tiles
 
             # _, best_score, _ = get_best_move_alpha_beta(new_state, depth, sample_cache, best_path_flag=False)
             _, best_score, _ = get_best_move_alpha_beta(new_state, depth, sample_cache, best_path_flag=False)
-        return move[0], best_score
+            move_scores.append((move[0], best_score))
+        # return move[0], best_score
+        return move_scores
 
     def get_best_move(self, final_south_hand: set[DominoTile], remaining_tiles: set[DominoTile], 
                       knowledge_tracker: CommonKnowledgeTracker, player_tiles_count: dict[PlayerPosition, int], 
@@ -187,28 +190,28 @@ def get_best_move(self, final_south_hand: set[DominoTile], remaining_tiles: set[
 
                 # move_scores[move[0]].append(best_score)
 
-            # move, best_score = self.sample_search(final_south_hand, final_remaining_tiles_without_south_tiles, player_tiles_count, inferred_knowledge_for_current_player, board_ends)
-            # move_scores[move].append(best_score)
-
-    # def sample_search(self, final_south_hand: set[DominoTile], final_remaining_tiles_without_south_tiles: set[DominoTile], player_tiles_count: dict[PlayerPosition, int], inferred_knowledge_for_current_player: CommonKnowledgeTracker, board_ends: tuple[int|None,int|None]) -> tuple[move, float]:
+            # move, best_score = self.sample_and_search(final_south_hand, final_remaining_tiles_without_south_tiles, player_tiles_count, inferred_knowledge_for_current_player, board_ends)
+            # sample_scores = self.sample_and_search(final_south_hand, final_remaining_tiles_without_south_tiles, player_tiles_count, inferred_knowledge_for_current_player, board_ends)
+            # for move, score in sample_scores:
+            #     move_scores[move].append(score)
 
         # Use ProcessPoolExecutor to parallelize the execution
         with ProcessPoolExecutor() as executor:
             futures = [
                 executor.submit(
-                    self.sample_search,
+                    self.sample_and_search,
                     final_south_hand,
                     final_remaining_tiles_without_south_tiles,
                     player_tiles_count,
                     inferred_knowledge_for_current_player,
                     board_ends
                 )
                 for _ in range(num_samples)
-                # for _ in tqdm(range(num_samples), desc="Analyzing moves", leave=False)
             ]
             for future in tqdm(as_completed(futures), total=num_samples, desc="Analyzing moves", leave=False):
-                move, best_score = future.result()
-                move_scores[move].append(best_score)
+                sample_scores = future.result()
+                for move, score in sample_scores:
+                    move_scores[move].append(score)
 
         if not move_scores:
             if verbose:
diff --git a/test.py b/test.py
@@ -30,8 +30,12 @@
 # local_not_with {'E': {1|3}, 'N': set(), 'W': {1|3}}
 
 
-from domino_probability_calc import calculate_tile_probabilities, PlayerTiles,generate_scenarios, generate_sample
-from domino_game_analyzer import DominoTile
+from domino_probability_calc import calculate_tile_probabilities,generate_scenarios, generate_sample
+from domino_data_types import DominoTile, PlayerTiles, PlayerPosition_SOUTH, GameState, PlayerPosition
+from analytic_agent_player_parallel import AnalyticAgentPlayer
+from domino_game_tracker import domino_game_state_our_perspective, generate_sample_from_game_state
+from domino_utils import history_to_domino_tiles_history
+from get_best_move2 import list_possible_moves
 import copy
 
 def test_calculate_probabilities():
@@ -62,65 +66,147 @@ def test_calculate_probabilities():
             print(f"  P({player} has {tile}) = {prob:.6f}")
         print()
 
-def test_calculate_probabilities2():
-# tile 0|6
-# probabilities[tile] {'N': 0.3333333333333333, 'E': 0.0, 'W': 0.0}
-# not_with {'E': set(), 'N': {5|6, 1|4}, 'W': {1|4}}
-# not_with_local {'E': set(), 'N': {5|6, 1|4}, 'W': {1|4}}
-# known_with_local {'W': {0|6}}
-# prob.sum 0.3333333333333333
-# scenarios []
-# player_tiles PlayerTiles(N=1, E=1, W=1)
-    # Remaining tiles: [0|0, 0|1, 0|2, 0|6, 1|3, 1|4, 1|5, 1|6, 2|2, 2|3, 2|6, 3|3, 5|6]
-
-    remaining_tiles = set([
-        DominoTile(0, 0), DominoTile(0, 1), DominoTile(0, 2), DominoTile(0, 6),
-        DominoTile(1, 3), DominoTile(1, 4), DominoTile(1, 5), DominoTile(1, 6),
-        DominoTile(2, 2), DominoTile(2, 3), DominoTile(2, 6), DominoTile(3, 3),
-        DominoTile(5, 6)
-        # DominoTile(2, 4), DominoTile(3, 6)  # Tiles in human player's hand
-    ])
-
-    # Define not_with based on _knowledge_tracker
-    not_with = {
-        'E': set(),
-        'N': {DominoTile(5, 6), DominoTile(1, 4)},
-        'W': {DominoTile(1, 4)}
-    }
+# def test_calculate_probabilities2():
+# # tile 0|6
+# # probabilities[tile] {'N': 0.3333333333333333, 'E': 0.0, 'W': 0.0}
+# # not_with {'E': set(), 'N': {5|6, 1|4}, 'W': {1|4}}
+# # not_with_local {'E': set(), 'N': {5|6, 1|4}, 'W': {1|4}}
+# # known_with_local {'W': {0|6}}
+# # prob.sum 0.3333333333333333
+# # scenarios []
+# # player_tiles PlayerTiles(N=1, E=1, W=1)
+#     # Remaining tiles: [0|0, 0|1, 0|2, 0|6, 1|3, 1|4, 1|5, 1|6, 2|2, 2|3, 2|6, 3|3, 5|6]
+
+#     remaining_tiles = set([
+#         DominoTile(0, 0), DominoTile(0, 1), DominoTile(0, 2), DominoTile(0, 6),
+#         DominoTile(1, 3), DominoTile(1, 4), DominoTile(1, 5), DominoTile(1, 6),
+#         DominoTile(2, 2), DominoTile(2, 3), DominoTile(2, 6), DominoTile(3, 3),
+#         DominoTile(5, 6)
+#         # DominoTile(2, 4), DominoTile(3, 6)  # Tiles in human player's hand
+#     ])
+
+#     # Define not_with based on _knowledge_tracker
+#     not_with = {
+#         'E': set(),
+#         'N': {DominoTile(5, 6), DominoTile(1, 4)},
+#         'W': {DominoTile(1, 4)}
+#     }
+
+#     # Define player_tiles (assuming 7 tiles per player at the start)
+#     player_tiles = PlayerTiles(N=1, E=1, W=1)
+
+#     # Call calculate_tile_probabilities
+#     # probabilities = calculate_tile_probabilities(remaining_tiles, not_with, player_tiles)
+#     # Print the results
+#     # for tile, probs in probabilities.items():
+#     #     print(f"Tile {tile}:")
+#     #     for player, prob in probs.items():
+#     #         print(f"  P({player} has {tile}) = {prob:.6f}")
+#     #     print()
+
+#     player_tiles = PlayerTiles(N=4, E=4, W=5)
+#     sample = generate_sample(remaining_tiles, not_with, player_tiles)
+#     print('sample',sample)
+
+
+
+# def test_generate_scenarios():
+#     player_tiles = [DominoTile(5,6)]
+#     not_with = {'E': set(), 'N': set(), 'W': {DominoTile(5,6)}}
+#     known_with = {'N': set(), 'E': set(), 'W': set()}
+#     player_tiles =  PlayerTiles(N=5, E=6, W=6)
+#     scenarios = generate_scenarios(player_tiles, not_with, known_with)
+#     print(scenarios)
+#     print("known_with['N'].union(known_with['E']).union(known_with['W'])",known_with['N'].union(known_with['E']).union(known_with['W']))
+#     not_with_local = copy.deepcopy(not_with)
+#     # If found a duplication in not_with, it's added now to known_with and need to be removed from not_with
+#     if any(len(s)>0 for s in known_with.values()): 
+#         for p, p_set in not_with_local.items():
+#             not_with_local[p] = not_with_local[p] - known_with['N'].union(known_with['E']).union(known_with['W'])
+#     print('not_with_local',not_with_local)
+
+
+def test_initial_moves() -> None:
+
+# Player's hand: [4|6, 1|3, 2|2, 3|4, 0|4, 2|6, 2|3]
+# Remaining tiles: [0|0, 0|1, 0|2, 0|3, 0|5, 0|6, 1|1, 1|2, 1|4, 1|5, 1|6, 2|4, 2|5, 3|3, 3|5, 3|6, 4|4, 4|5, 5|5, 5|6, 6|6]
+# Move Statistics (based on 5 samples):
+
+# Move: Play 3|4 on the left
+#   Count: 5
+#   Mean Score: -5.5000
+#   Standard Deviation: 46.9441
+#   Median Score: -30.0000
+#   Mode Score: -30.0000
+#   Min Score: -44.0000
+#   Max Score: 68.0000
+
+# Best Move Overall:
+# Best move: Play 3|4 on the left
+# Mean Expected Score: -5.5000
+# First move: (3, 4)
+        ai_player = AnalyticAgentPlayer()
+        verbose = True
+        # unplayed_tiles = self.get_unplayed_tiles(game_state, player_hand)
+        unplayed_tiles = [(0,0), (0,1), (0,2), (0,3), (0,5), (0,6), (1,1), (1,2), (1,4), (1,5), (1,6), (2,4), (2,5), (3,3), (3,5), (3,6), (4,4), (4,5), (5,5), (5,6), (6,6)]
+        _unplayed_tiles = DominoTile.loi_to_domino_tiles(unplayed_tiles)
+
+        player_hand = [(4,6), (1,3), (2,2), (3,4), (0,4), (2,6), (2,3)]
+        _player_hand = DominoTile.loi_to_domino_tiles(player_hand)
+
+        # _moves = history_to_domino_tiles_history(game_state.history)
+        _moves = history_to_domino_tiles_history([])
+        _remaining_tiles = set(_unplayed_tiles)
+        # _initial_player_tiles = {p: 7 for p in PlayerPosition}
+        _initial_player_tiles = {p: 7 for p in range(4)}
+        # _starting_player = PlayerPosition((game_state.history[0][0] - self.position)%4) if len(game_state.history)>0 else PlayerPosition.SOUTH
+        _starting_player = PlayerPosition_SOUTH
+
+        current_player, _final_remaining_tiles, _board_ends, _player_tiles_count, _knowledge_tracker = domino_game_state_our_perspective(
+            _remaining_tiles, _moves, _initial_player_tiles, current_player=_starting_player)
+
+        if verbose:
+            ai_player.print_verbose_info(_player_hand, _unplayed_tiles, _knowledge_tracker, _player_tiles_count, _starting_player)
+
+        # num_samples = 1000 if len(game_state.history) > 8 else 100 if len(game_state.history) > 4 else 25 if len(game_state.history) > 0 else 1
+        num_samples = 1
+        best_move = ai_player.get_best_move(set(_player_hand), _remaining_tiles, _knowledge_tracker, _player_tiles_count, _board_ends, num_samples, verbose=True)
+
+        # inferred_knowledge: dict[PlayerPosition, set[DominoTile]] = {
+        #     player: set() for player in range(4)
+        # }
+
+        # sample = generate_sample_from_game_state(
+        #     # PlayerPosition.SOUTH,
+        #     PlayerPosition_SOUTH,
+        #     set(_player_hand),
+        #     set(_unplayed_tiles),
+        #     _player_tiles_count,
+        #     inferred_knowledge
+        # )
+
+        # sample_hands = (
+        #     frozenset(_player_hand),
+        #     frozenset(sample['E']),
+        #     frozenset(sample['N']),
+        #     frozenset(sample['W'])
+        # )
+
+        # sample_state = GameState(
+        #     player_hands=sample_hands,
+        #     # current_player=PlayerPosition.SOUTH,
+        #     current_player=PlayerPosition_SOUTH,
+        #     left_end=_board_ends[0],
+        #     right_end=_board_ends[1],
+        #     consecutive_passes=0
+        # )
+
+        # possible_moves = list_possible_moves(sample_state)
+
+        # print('possible_moves', possible_moves)
 
-    # Define player_tiles (assuming 7 tiles per player at the start)
-    player_tiles = PlayerTiles(N=1, E=1, W=1)
-
-    # Call calculate_tile_probabilities
-    # probabilities = calculate_tile_probabilities(remaining_tiles, not_with, player_tiles)
-    # Print the results
-    # for tile, probs in probabilities.items():
-    #     print(f"Tile {tile}:")
-    #     for player, prob in probs.items():
-    #         print(f"  P({player} has {tile}) = {prob:.6f}")
-    #     print()
-
-    player_tiles = PlayerTiles(N=4, E=4, W=5)
-    sample = generate_sample(remaining_tiles, not_with, player_tiles)
-    print('sample',sample)
-
-
-
-def test_generate_scenarios():
-    player_tiles = [DominoTile(5,6)]
-    not_with = {'E': set(), 'N': set(), 'W': {DominoTile(5,6)}}
-    known_with = {'N': set(), 'E': set(), 'W': set()}
-    player_tiles =  PlayerTiles(N=5, E=6, W=6)
-    scenarios = generate_scenarios(player_tiles, not_with, known_with)
-    print(scenarios)
-    print("known_with['N'].union(known_with['E']).union(known_with['W'])",known_with['N'].union(known_with['E']).union(known_with['W']))
-    not_with_local = copy.deepcopy(not_with)
-    # If found a duplication in not_with, it's added now to known_with and need to be removed from not_with
-    if any(len(s)>0 for s in known_with.values()): 
-        for p, p_set in not_with_local.items():
-            not_with_local[p] = not_with_local[p] - known_with['N'].union(known_with['E']).union(known_with['W'])
-    print('not_with_local',not_with_local)
 
 if __name__ == "__main__":
-    test_calculate_probabilities2()
-    # test_generate_scenarios()
+    # test_calculate_probabilities2()
+    # test_generate_scenarios()
+    test_initial_moves()
