Newer
Older
def plot_strategy_comparison(num_games : int):
"""Plot a bar chart comparing average costs of different strategies over specified number of games."""
# Compare strategies and get their costs
strategy_costs = validation_instance.compare_strategies(num_games=num_games)
plt.figure(figsize=(10, 6))
plt.bar(strategy_costs.keys(), strategy_costs.values(), color=['blue', 'green', 'orange', 'red', 'purple'])
plt.xlabel('Strategies')
plt.ylabel('Average Cost')
plt.title('Comparison of Strategies')
plt.show()
def plot_state_based_turns():
"""Plot the average number of turns per state for different strategies."""
strategies = [validation_instance.optimal_policy,
validation_instance.safe_strategy,
validation_instance.normal_strategy,
validation_instance.risky_strategy,
validation_instance.random_strategy]
strategy_names = ['Optimal', 'SafeDice', 'NormalDice', 'RiskyDice', 'Random']
plt.figure(figsize=(12, 6))
for strategy, name in zip(strategies, strategy_names):
mean_turns = validation_instance.simulate_state(strategy, layout, circle, num_games)
plt.plot(range(len(mean_turns)), mean_turns, marker='o', linestyle='-', label=name)
plt.xlabel('State')
plt.ylabel('Average Turns')
plt.title('Average Turns per State for Different Strategies')
plt.grid(True)
plt.legend()
plt.show()
def plot_state_based_comparison(num_games_list):
"""Plot a comparison between optimal turns and empirical turns per state for different num_games."""
plt.figure(figsize=(12, 6)) # Create a single figure for all plots
optimal_turns = None # Initialize optimal_turns to None
for num_games in num_games_list:
_, empirical_turns = validation_instance.compare_state_based_turns(num_games=num_games)
# Plotting empirical turns per state for the current num_games
plt.plot(range(len(empirical_turns)), empirical_turns, marker='x', linestyle='-', label=f'Empirical (num_games={num_games})')
if optimal_turns is None:
# Only fetch optimal_turns once (for the first num_games)
optimal_turns, _ = validation_instance.compare_state_based_turns(num_games=num_games)
plt.plot(range(len(optimal_turns)), optimal_turns, marker='o', linestyle='-', label=f'ValueIteration')
plt.xlabel('State')
plt.ylabel('Average Turns')
plt.title('Average Turns per State - ValueIteration vs. Empirical')
plt.grid(True)
plt.legend()
def plot_state_based_comparison_once(num_games : int):
optimal_turns, empirical_turns = validation_instance.compare_state_based_turns(num_games=num_games)
# Plotting the state-based average turns comparison
plt.figure(figsize=(12, 6))
# Plot optimal strategy turns
plt.plot(range(len(optimal_turns)), optimal_turns, marker='o', linestyle='-', label='ValueIteration')
# Plot empirical strategy turns
plt.plot(range(len(empirical_turns)), empirical_turns, marker='x', linestyle='-', label='Empirical')
plt.xlabel('State')
plt.ylabel('Average Turns')
plt.title('Average Turns per State - ValueIteration vs. Empirical')
plt.grid(True)
plt.legend()
plt.show()
if __name__ == '__main__':
##### Paramètres #####
# Define the layout of the game board
layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
# Indicates whether the board is circular or linear
circle = False
# Number of games to simulate
num_games = 10000
# Initialize Validation instance with the specified layout and circle type
validation_instance = Val(layout, circle)
##### Launch Plots #####
# Run the defined plotting functions with specified parameters
plot_strategy_comparison(num_games)
plot_state_based_turns()
plot_state_based_comparison(num_games_list = [10, 100, 1000])
plot_state_based_comparison_once(num_games)