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

update simulation

parent b775d77f
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
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)
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)
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)
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