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

création de tmc

parent 10daac96
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
import numpy as np
import random as rd
def compute_transition(layout, circle = False) :
# probability from a state k to another state k'
safe_dice = np.array([0.5,0.5])
normal_dice = np.array([0.33,0.33,0.33])
risky_dice = np.array([0.25,0.25,0.25,0.25])
# initialization of matrices
safe_matrix = np.zeros((15,15))
normal_matrix = np.zeros((15,15))
risky_matrix = np.zeros((15,15))
for k in range(0,15) : # browse the different states k
for s, p in enumerate(safe_dice) : # Compute for each square of the game the probability of transition
if k == 9 and s == 1 :
k_prime = 14
safe_matrix[k][k_prime] += p
elif k == 2 and s > 0 : # if we are in square 3
p /= 2
k_prime = 10
safe_matrix[k][k_prime] += p
k_prime = 3
safe_matrix[k][k_prime] += p
else : # normal scenario
k_prime = k + s # state k + square
k_prime = min(14,k_prime)
safe_matrix[k][k_prime] += p
print("Safe Dice Transition Matrix:")
print(safe_matrix)
compute_transition(None)
# MLP1 # MLP1
tmc.py, autrement dit TransitionMatrixCalculator est le fichier qui permet de calculer les différentes matrices de transitions
## Getting started ## Getting started
......
import numpy as np
import random as rd
from openpyxl import Workbook
class TransitionMatrixCalculator:
def __init__(self):
# Initialisation des matrices de transition pour les dés "safe", "normal" et "risky"
self.matrix_safe = np.zeros((15, 15))
self.matrix_normal = np.zeros((15, 15))
self.matrix_risky = np.zeros((15, 15))
# Probability to go from state k to k'
self.safe_dice = np.array([1/2,1/2])
self.normal_dice = np.array([1/3,1/3,1/3])
self.risky_dice = np.array([1/4, 1/4, 1/4, 1/4])
def compute_transition_matrix(self, layout, circle=False):
self.matrix_safe.fill(0)
self.matrix_normal.fill(0)
self.matrix_risky.fill(0)
self._compute_safe_matrix(layout, circle)
self._compute_normal_matrix(layout, circle)
self._compute_risky_matrix(layout, circle)
return self.matrix_safe, self.matrix_normal, self.matrix_risky
def _compute_safe_matrix(self, layout, circle):
for k in range(0,15):
for s, p in enumerate(self.safe_dice):
if k == 9 and s == 1:
k_prime = 14
self.matrix_safe[k,k_prime] += p
elif k == 2 and s > 0:
p /= 2
k_prime = 10
self.matrix_safe[k,k_prime] += p
k_prime = 3
self.matrix_safe[k,k_prime] += p
else:
k_prime = k + s
k_prime = min(14, k_prime)
self.matrix_safe[k,k_prime] += p
return self.matrix_safe
def _compute_normal_matrix(self, layout, circle):
for k in range(0, 15):
for s, p in enumerate(self.normal_dice):
if k == 8 and s == 2:
k_prime = 14
self.matrix_normal[k,k_prime] += p
continue
elif k == 9 and s in [1, 2]:
if not circle or s == 1:
k_prime = 14
self.matrix_normal[k,k_prime] += p
elif circle and s == 2:
k_prime = 0
self.matrix_normal[k,k_prime] += p
continue
# handle the fast lane
if k == 2 and s > 0:
p /= 2
k_prime = 10 + (s - 1)
if layout[k_prime] in [0, 3]: # normal or prison square
self.matrix_normal[k,k_prime] += p
elif layout[k_prime] == 1: # handle type 1 trap
self.matrix_normal[k,k_prime] += p / 2
k_prime = 0
self.matrix_normal[k,k_prime] += p / 2
elif layout[k_prime] == 2: # handle type 2 trap
self.matrix_normal[k,k_prime] += p / 2
if k_prime == 10:
k_prime = 0
elif k_prime == 11:
k_prime = 1
elif k_prime == 12:
k_prime = 2
else:
k_prime = max(0, k_prime - 3)
self.matrix_normal[k,k_prime] += p / 2
k_prime = 3 + (s - 1)
if layout[k_prime] in [0, 3]: # normal or prison square
self.matrix_normal[k,k_prime] += p
elif layout[k_prime] == 1: # handle type 1 trap
self.matrix_normal[k,k_prime] += p / 2
k_prime = 0
self.matrix_normal[k,k_prime] += p / 2
elif layout[k_prime] == 2: # handle type 2 trap
self.matrix_normal[k,k_prime] += p / 2
k_prime = max(0, k_prime - 3)
self.matrix_normal[k,k_prime] += p / 2
continue
k_prime = k + s
k_prime = k_prime % 15 if circle else min(14, k_prime)
if layout[k_prime] in [1, 2]:
p /= 2
if layout[k_prime] == 1:
k_prime = 0
self.matrix_normal[k,k_prime] += p
continue
elif layout[k_prime] == 2:
if k_prime == 10:
k_prime = 0
elif k_prime == 11:
k_prime = 1
elif k_prime == 12:
k_prime = 2
else:
k_prime = max(0, k_prime - 3)
self.matrix_normal[k,k_prime] += p
continue
self.matrix_normal[k,k_prime] += p
return self.matrix_normal
def _compute_risky_matrix(self, layout, circle):
for k in range(0, 15):
for s, p in enumerate(self.risky_dice):
if k == 7 and s == 3:
k_prime = 14
self.matrix_risky[k,k_prime] += p
continue
elif k == 8 and s in [2, 3]:
if not circle or s == 2:
k_prime = 14
self.matrix_risky[k,k_prime] += p
elif circle:
k_prime = 0
self.matrix_risky[k,k_prime] += p
continue
elif k == 9 and s in [1, 2, 3]:
if not circle or s == 1:
k_prime = 14
self.matrix_risky[k,k_prime] += p
elif circle and s == 2:
k_prime = 0
self.matrix_risky[k,k_prime] += p
elif circle and s == 3:
k_prime = 1
if layout[k_prime] != 0:
if layout[k_prime] == 1:
k_prime = 0
self.matrix_risky[k,k_prime] += p
elif layout[k_prime] == 2:
k_prime = max(0, k_prime - 3)
self.matrix_risky[k,k_prime] += p
self.matrix_risky[k,k_prime] += p
continue
continue
if k == 2 and s > 0:
p /= 2
k_prime = 10 + (s - 1)
if layout[k_prime] == 1:
k_prime = 0
self.matrix_risky[k,k_prime] += p
elif layout[k_prime] == 2:
if k_prime == 10:
k_prime = 0
elif k_prime == 11:
k_prime = 1
elif k_prime == 12:
k_prime = 2
else:
k_prime = max(0, k_prime - 3)
self.matrix_risky[k,k_prime] += p
else:
self.matrix_risky[k,k_prime] += p
k_prime = 3 + (s - 1)
self.matrix_risky[k,k_prime] += p
continue
k_prime = k + s
k_prime = k_prime % 15 if circle else min(14, k_prime)
if layout[k_prime] in [1, 2, 4]:
if layout[k_prime] == 1:
k_prime = 0
self.matrix_risky[k,k_prime] += p
continue
elif layout[k_prime] == 2:
if k_prime == 10:
k_prime = 0
elif k_prime == 11:
k_prime = 1
elif k_prime == 12:
k_prime = 2
else:
k_prime = max(0, k_prime - 3)
self.matrix_risky[k,k_prime] += p
continue
self.matrix_risky[k,k_prime] += p
return self.matrix_risky
def generate_arrays(self,n):
# Initialize an empty list to store all the arrays
arrays = []
for _ in range(n):
# Initialize a zero array of size 15
array = np.zeros(15, dtype=int)
# Generate 3 random indices between 1 and 13 (exclusive)
indices = rd.sample(range(1, 14), 4)
# Assign the values 1, 2 and 3 to the randomly generated indices
array[indices] = 1, 2, 3,4
# Append the generated array to the list
arrays.append(array)
return arrays
# create a function that test the transition matrix for different layout each time with one trap of each sort
def tst_transition_matrix(self):
# create a list of 100 different layouts
layouts = self.generate_arrays(100)
for array in layouts:
print(array)
self.compute_transition_matrix(array, False)
self.compute_transition_matrix(array, True)
#tmc = TransitionMatrixCalculator()
#tmc.tst_transition_matrix()
"""
# create a function that test the transition matrix for different layout each time with one trap of each sort
def tst_transition_matrix(self):
# create a list of 100 different layouts
layout = np.array([0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0])
print(layout)
matrix_safe, matrix_normal, matrix_risky = self.compute_transition_matrix(layout, False)
print("Matrix Safe:")
print(matrix_safe)
print("Matrix Normal:")
print(matrix_normal)
print("Matrix Risky:")
print(matrix_risky)
matrix_safe, matrix_normal, matrix_risky = self.compute_transition_matrix(layout, True)
print("Matrix Safe (Circle):")
print(matrix_safe)
print("Matrix Normal (Circle):")
print(matrix_normal)
print("Matrix Risky (Circle):")
print(matrix_risky)
"""
\ No newline at end of file
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