update simulation

plotting.py

-import matplotlib.pyplot as plt
-import numpy as np
-from simulate import Simulate as sim
-from tmc import TransitionMatrixCalculator as tmc
-from markovDecision import MarkovDecisionSolver as mD
-
-def get_results(layouts, circle, n_iterations=100):
-    results_markov = []
-    results_safe = []
-    results_normal = []
-    results_risky = []
-    results_random = []
-    
-    for layout in layouts:
-        # Compute optimal policy 
-        expec, policy = mD(layout, circle).solve()
-        
-        # Simulate game using Simulate class
-        sim_instance = sim(layout, circle)
-        result_markov = sim_instance.simulate_game(policy, n_iterations)
-        results_markov.append(result_markov)
-        
-        # Simulate with fixed strategies using Simulate class
-        results_safe.append(sim_instance.simulate_game([1]*15, n_iterations))
-        results_normal.append(sim_instance.simulate_game([2]*15, n_iterations))
-        results_risky.append(sim_instance.simulate_game([3]*15, n_iterations))
-        results_random.append(sim_instance.simulate_game(np.random.randint(1, 4, size=15), n_iterations))
-
-    return results_markov, results_safe, results_normal, results_risky, results_random
-
-# Utilisation de la fonction get_results pour obtenir les résultats
-layouts = [[0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]]  # Exemple de layouts à utiliser
-circle = True  # Exemple de valeur pour circle
-results_markov, results_safe, results_normal, results_risky, results_random = get_results(layouts, circle, n_iterations=100)
-
-# Imprimer les résultats (vous pouvez les enregistrer dans un fichier si nécessaire)
-print("Results Markov:", results_markov)
-print("Results Safe:", results_safe)
-print("Results Normal:", results_normal)
-print("Results Risky:", results_risky)
-print("Results Random:", results_random)

simulate.py

-import random as rd
-import numpy as np
-from tmc import TransitionMatrixCalculator as tmc
-from markovDecision import MarkovDecisionSolver as mD
-
-
-class Simulate:
-    def __init__(self, layout, circle):
-        self.layout = layout
-        self.circle = circle
-        self.tmc_instance = tmc()
-        self.safe_dice, self.normal_dice, self.risky_dice = self.tmc_instance.compute_transition_matrix(layout, circle)
-        self.transition_matrices = [self.safe_dice, self.normal_dice, self.risky_dice]
-
-    def simulate_game(self, strategy, n_iterations=10000):
-        number_turns = []
-        for _ in range(n_iterations):
-            total_turns = 0
-            state = 0  # initial state
-
-            while state < len(self.layout) - 1:  # until goal state is reached
-                action = strategy[state]  # get action according to strategy
-                transition_matrix = self.transition_matrices[int(action) - 1]
-                state = np.random.choice(len(self.layout), p=transition_matrix[state])
-
-                if self.layout[state] == 3 and action == 2:
-                    total_turns += rd.choice([1, 2], p=[0.5, 0.5])
-                elif self.layout[state] == 3 and action == 3:
-                    total_turns += 2
-                else:
-                    total_turns += 1
-
-            number_turns.append(total_turns)
-
-        return np.mean(number_turns)
-
-    def simulate_state(self, strategy, n_iterations=10000):
-        number_mean = []
-        for _ in range(n_iterations):
-            number_turns = []
-
-            for state in range(len(self.layout) - 1):
-                total_turns = 0
-
-                while state < len(self.layout) - 1:
-                    print("Current state:", state)
-                    print("Transition matrix:", transition_matrix[state])
-                    state = np.random.choice(len(self.layout), p=transition_matrix[state])
-
-                    if self.layout[state] == 3 and action == 2:
-                        total_turns += rd.choice([1, 2], p=[0.5, 0.5])
-                    elif self.layout[state] == 3 and action == 3:
-                        total_turns += 2
-                    else:
-                        total_turns += 1
-
-                number_turns.append(total_turns)
-
-            number_mean.append(number_turns)
-
-        return np.mean(number_mean, axis=0)

simulation.py

+import numpy as np
+import random as rd
+import matplotlib.pyplot as plt
+from tmc import TransitionMatrixCalculator as tmc
+from markovDecision import MarkovDecisionSolver as mD
+
+class Validation:
+    def __init__(self):
+        self.tmc_instance = tmc()
+
+    def simulate_games(self, layout, circle, num_games):
+        results = []
+
+        for _ in range(num_games):
+            result = mD(layout, circle)
+            # Assuming result is a tuple (costs, path) and you want the last element of 'costs'
+            results.append(result[0][-1])  # Append the number of turns to reach the goal
+
+        return results
+
+    def compare_strategies(self, layout, circle, num_games):
+        optimal_results = self.simulate_games(layout, circle, num_games)
+
+        suboptimal_strategies = {
+            "Dice 1 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 1 simulation
+            "Dice 2 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 2 simulation
+            "Dice 3 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 3 simulation
+            "Mixed Random Strategy": self.simulate_games(layout, circle, num_games),  # Replace with mixed random strategy simulation
+            "Purely Random Choice": self.simulate_games(layout, circle, num_games)  # Replace with purely random choice simulation
+        }
+
+        self.plot_results(optimal_results, suboptimal_strategies)
+
+    def plot_results(self, optimal_results, suboptimal_results):
+        strategies = ["Optimal Strategy"] + list(suboptimal_results.keys())
+        avg_costs = [np.mean(optimal_results)] + [np.mean(suboptimal_results[strategy]) for strategy in suboptimal_results]
+
+        plt.figure(figsize=(10, 6))
+        plt.bar(strategies, avg_costs, color=['blue'] + ['orange'] * len(suboptimal_results))
+        plt.xlabel("Strategies")
+        plt.ylabel("Average Cost")
+        plt.title("Comparison of Strategy Performance")
+        plt.show()
+
+    def run_validation(self, layout, circle, num_games):
+        solver = mD(layout, circle)
+        theoretical_cost, optimal_dice_strategy = solver.solve()
+
+        optimal_results = self.simulate_games(layout, circle, num_games)
+        optimal_average_cost = np.mean(optimal_results)
+
+        suboptimal_strategies = {
+            "Dice 1 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 1 simulation
+            "Dice 2 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 2 simulation
+            "Dice 3 Only": self.simulate_games(layout, circle, num_games),  # Replace with Dice 3 simulation
+            "Mixed Random Strategy": self.simulate_games(layout, circle, num_games),  # Replace with mixed random strategy simulation
+            "Purely Random Choice": self.simulate_games(layout, circle, num_games)  # Replace with purely random choice simulation
+        }
+
+        self.plot_results(optimal_results, suboptimal_strategies)
+
+        print("Theoretical Expected Cost (Value Iteration):", theoretical_cost)
+        print("Empirical Average Cost (Optimal Strategy):", optimal_average_cost)
+
+        for strategy, results in suboptimal_strategies.items():
+            avg_cost = np.mean(results)
+            print(f"Empirical Average Cost ({strategy}):", avg_cost)
+
+# Exemple d'utilisation de la classe Validation
+layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
+circle = True
+num_games = 1000
+
+validation = Validation()
+validation.run_validation(layout, circle, num_games)