Skip to content
Extraits de code Groupes Projets
Valider 934cfe4c rédigé par Adrien Payen's avatar Adrien Payen
Parcourir les fichiers

update ML

parent 2092a35e
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
Affichage de avec 23 ajouts et 28 suppressions
Aucun aperçu pour ce type de fichier
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier déplacé
Fichier ajouté
True/100k_true/Figure_1.png

20,4 ko

True/100k_true/Figure_2.png

94,8 ko

True/10k_true/Figure_1.png

22,9 ko

True/10k_true/Figure_2png.png

106 ko

True/Figure_1.png

63,8 ko

...@@ -30,7 +30,7 @@ def plot_state_based_turns(): ...@@ -30,7 +30,7 @@ def plot_state_based_turns():
plt.figure(figsize=(12, 6)) plt.figure(figsize=(12, 6))
# Simulate and plot average turns for each strategy # Simulate and plot average turns for each strategy
for strategy, name in zip(strategies, strategy_names): for strategy, name in zip(strategies, strategy_names):
mean_turns = validation_instance.simulate_state(strategy, layout, circle, num_games) mean_turns = validation_instance.state_simulation(strategy, layout, circle, num_games)
plt.plot(range(len(mean_turns)), mean_turns, marker='o', linestyle='-', label=name) plt.plot(range(len(mean_turns)), mean_turns, marker='o', linestyle='-', label=name)
plt.xlabel('State') plt.xlabel('State')
...@@ -93,11 +93,18 @@ if __name__ == '__main__': ...@@ -93,11 +93,18 @@ if __name__ == '__main__':
##### Paramètres ##### ##### Paramètres #####
# Define the layout of the game board # Define the layout of the game board
layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0] #layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
#layout = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 1, 0]
#layoutfastlaneWt = [0, 0, 3, 0, 2, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0]
#layoutslowlaneWt = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 1, 0]
layout = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
# Indicates whether the board is circular or linear # Indicates whether the board is circular or linear
circle = False circle = False
# Number of games to simulate # Number of games to simulate
num_games = 10000 num_games = 100
# Initialize Validation instance with the specified layout and circle type # Initialize Validation instance with the specified layout and circle type
validation_instance = Val(layout, circle) validation_instance = Val(layout, circle)
...@@ -106,5 +113,5 @@ if __name__ == '__main__': ...@@ -106,5 +113,5 @@ if __name__ == '__main__':
# Run the defined plotting functions with specified parameters # Run the defined plotting functions with specified parameters
plot_strategy_comparison(num_games) plot_strategy_comparison(num_games)
plot_state_based_turns() plot_state_based_turns()
plot_state_based_comparison(num_games_list = [10, 100, 1000]) plot_state_based_comparison(num_games_list = [10,100,1000])
plot_state_based_comparison_once(num_games) plot_state_based_comparison_once(num_games)
\ No newline at end of file
...@@ -42,7 +42,7 @@ class Validation: ...@@ -42,7 +42,7 @@ class Validation:
self.costs_by_dice_type['RiskyDice'][i] = 3 if die_type == 3 else 0 self.costs_by_dice_type['RiskyDice'][i] = 3 if die_type == 3 else 0
def simulate_game(self, strategy: list, n_iterations: int): def simulate_rounds(self, strategy: list, n_iterations: int):
"""Simulate the game using a given strategy over multiple iterations.""" """Simulate the game using a given strategy over multiple iterations."""
transition_matrices = [self.safe_dice, self.normal_dice, self.risky_dice] transition_matrices = [self.safe_dice, self.normal_dice, self.risky_dice]
total_turns = np.zeros(n_iterations) total_turns = np.zeros(n_iterations)
...@@ -74,7 +74,7 @@ class Validation: ...@@ -74,7 +74,7 @@ class Validation:
return np.mean(total_turns) return np.mean(total_turns)
def simulate_state(self, strategy: list, layout: list, circle: bool, n_iterations: int): def state_simulation(self, strategy: list, layout: list, circle: bool, n_iterations: int):
"""Simulate game states using a given strategy.""" """Simulate game states using a given strategy."""
safe_dice = self.tmc_instance._compute_safe_matrix() safe_dice = self.tmc_instance._compute_safe_matrix()
normal_dice = self.tmc_instance._compute_normal_matrix(layout, circle)[0] normal_dice = self.tmc_instance._compute_normal_matrix(layout, circle)[0]
...@@ -117,7 +117,7 @@ class Validation: ...@@ -117,7 +117,7 @@ class Validation:
def play_optimal_policy(self, n_iterations : int): def play_optimal_policy(self, n_iterations : int):
"""Play using the optimal policy for a number of iterations.""" """Play using the optimal policy for a number of iterations."""
return self.simulate_game(self.optimal_policy, n_iterations) return self.simulate_rounds(self.optimal_policy, n_iterations)
def play_dice_strategy(self, dice_choice, n_iterations : int): def play_dice_strategy(self, dice_choice, n_iterations : int):
"""Play using a specific dice strategy for a number of iterations.""" """Play using a specific dice strategy for a number of iterations."""
...@@ -130,17 +130,17 @@ class Validation: ...@@ -130,17 +130,17 @@ class Validation:
if strategy is None: if strategy is None:
raise ValueError("Invalid dice choice") raise ValueError("Invalid dice choice")
return self.simulate_game(strategy, n_iterations) return self.simulate_rounds(strategy, n_iterations)
def play_random_strategy(self, n_iterations : int ): def play_random_strategy(self, n_iterations : int ):
"""Play using a random strategy for a number of iterations.""" """Play using a random strategy for a number of iterations."""
return self.simulate_game(self.random_strategy, n_iterations) return self.simulate_rounds(self.random_strategy, n_iterations)
def compare_empirical_vs_value_iteration(self, num_games : int): def compare_empirical_vs_value_iteration(self, num_games : int):
"""Compare expected value iteration turns with empirical turns.""" """Compare expected value iteration turns with empirical turns."""
value_iteration_turns = self.expec value_iteration_turns = self.expec
empirical_turns = self.simulate_state(self.optimal_policy, self.layout, self.circle, n_iterations=num_games) empirical_turns = self.state_simulation(self.optimal_policy, self.layout, self.circle, n_iterations=num_games)
mean_turns_by_state = { mean_turns_by_state = {
'ValueIteration': value_iteration_turns.tolist(), 'ValueIteration': value_iteration_turns.tolist(),
...@@ -148,34 +148,22 @@ class Validation: ...@@ -148,34 +148,22 @@ class Validation:
} }
return mean_turns_by_state return mean_turns_by_state
def empirical_cost_of_square(self, strategy: list, n_iterations: int):
"""Calculate the empirical cost of a square for a given strategy."""
total_square_costs = []
for _ in range(n_iterations):
game_cost = self.simulate_game(strategy, 1)
square_cost = game_cost ** 2
total_square_costs.append(square_cost)
empirical_cost = np.mean(total_square_costs)
return empirical_cost
def compare_state_based_turns(self, num_games : int ): def compare_state_based_turns(self, num_games : int ):
# Compare the expected turns from value iteration with empirical state-based turns # Compare the expected turns from value iteration with empirical state-based turns
value_iteration = self.expec value_iteration = self.expec
empirical_turns = self.simulate_state(self.optimal_policy, self.layout, self.circle, n_iterations=num_games) empirical_turns = self.state_simulation(self.optimal_policy, self.layout, self.circle, n_iterations=num_games)
return value_iteration, empirical_turns return value_iteration, empirical_turns
def compare_strategies(self, num_games : int): def compare_strategies(self, num_games : int):
# Compare the costs of different strategies over a number of games # Compare the costs of different strategies over a number of games
optimal_cost = self.simulate_game(self.optimal_policy, n_iterations=num_games) optimal_cost = self.simulate_rounds(self.optimal_policy, n_iterations=num_games)
dice1_cost = self.simulate_game(self.safe_strategy, n_iterations=num_games) dice1_cost = self.simulate_rounds(self.safe_strategy, n_iterations=num_games)
dice2_cost = self.simulate_game(self.normal_strategy, n_iterations=num_games) dice2_cost = self.simulate_rounds(self.normal_strategy, n_iterations=num_games)
dice3_cost = self.simulate_game(self.risky_strategy, n_iterations=num_games) dice3_cost = self.simulate_rounds(self.risky_strategy, n_iterations=num_games)
random_cost = self.simulate_game(self.random_strategy, n_iterations=num_games) random_cost = self.simulate_rounds(self.random_strategy, n_iterations=num_games)
return { return {
'Optimal': optimal_cost, 'Optimal': optimal_cost,
......
0% Chargement en cours ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter