diff --git a/plotting.py b/plotting.py
deleted file mode 100644
index 5ce647646ee75ca2845919db6734d4203c2a1ee2..0000000000000000000000000000000000000000
--- a/plotting.py
+++ /dev/null
@@ -1,41 +0,0 @@
-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)
diff --git a/simulate.py b/simulate.py
deleted file mode 100644
index bbaa211f8998013a57c5536726a1a0c083a5baf3..0000000000000000000000000000000000000000
--- a/simulate.py
+++ /dev/null
@@ -1,61 +0,0 @@
-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)
diff --git a/simulation.py b/simulation.py
new file mode 100644
index 0000000000000000000000000000000000000000..1741debc2017d58f09f24ade194745e2326c59f4
--- /dev/null
+++ b/simulation.py
@@ -0,0 +1,75 @@
+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)