Merge branch 'main' into Adrien

.gitignore

+*.pyc
+*.pyd
+*.pyo
+__pycache__
\ No newline at end of file

README.md

 # MLP1
 
+tmc.py, autrement dit TransitionMatrixCalculator est le fichier qui permet de calculer les différentes matrices de transitions
 
 
 ## Getting started

markovDecion.py → markovDecision.py

@@ -4,7 +4,7 @@ from tmc import TransitionMatrixCalculator as tmc
 
 # testing our TransitionMatrix function based on random layout
 # [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
-def markovDecision(layout, circle) :
+def markovDecision(layout : list, circle : bool) :
 
     Numberk = 15 # Number of states k on the board
     tmc_instance = tmc()

plot.py

+import numpy as np
+import random as rd
+import matplotlib.pyplot as plt
+from tmc import TransitionMatrixCalculator as tmc
+from markovDecision import markovDecision as mD
+from validation import Validation
+
+def plot_results(validation_instance):
+    results_markov = validation_instance.simulate_game('markov')
+    results_safe = validation_instance.simulate_game([1]*15)
+    results_normal = validation_instance.simulate_game([2]*15)
+    results_risky = validation_instance.simulate_game([3]*15)
+    results_random = validation_instance.simulate_game(np.random.randint(1, 4, size=15))
+
+    plt.figure(figsize=(12, 8))
+    plt.plot(range(len(validation_instance.layouts)), results_markov, label='Markov')
+    plt.plot(range(len(validation_instance.layouts)), results_safe, label='SafeDice')
+    plt.plot(range(len(validation_instance.layouts)), results_normal, label='NormalDice')
+    plt.plot(range(len(validation_instance.layouts)), results_risky, label='RiskyDice')
+    plt.plot(range(len(validation_instance.layouts)), results_random, label='Random')
+
+    plt.xticks(range(len(validation_instance.layouts)), range(len(validation_instance.layouts)))
+    plt.xlabel('Layout Number', fontsize=13)
+    plt.ylabel('Average Number of Turns', fontsize=13)
+    plt.legend(loc='upper left', bbox_to_anchor=(1, 1), ncol=1)
+    plt.show()
+
+# Example usage
+layouts = [
+    [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0],
+    # Add more layouts as needed
+]
+
+validation_instance = Validation(layouts, circle=False, n_iterations=10000)
+plot_results(validation_instance)
\ No newline at end of file

test_files/md_test.py

+import numpy as np
+from tmc import TransitionMatrixCalculator as tmc
+
+def markov_decision(layout: list, circle: bool):
+    Numberk = 15
+    tmc_instance = tmc()
+    safe_dice = tmc_instance._compute_safe_matrix(layout, circle)
+    normal_dice = tmc_instance._compute_normal_matrix(layout, circle)
+    risky_dice = tmc_instance._compute_risky_matrix(layout, circle)
+    
+    jail = [i for i, x in enumerate(layout) if x == 3]
+    
+    def compute_value(v, dice_matrix):
+        return np.sum(dice_matrix * v) + (0.5 if dice_matrix is normal_dice else 1) * np.sum(dice_matrix[jail])
+
+
+    value = np.zeros(Numberk)
+    dice_for_states = np.zeros(Numberk - 1)
+
+    while True:
+        new_value = np.zeros(Numberk)
+
+        for k in range(Numberk - 1):
+            vi_safe = compute_value(value, safe_dice[k])
+            vi_normal = compute_value(value, normal_dice[k])
+            vi_risky = compute_value(value, risky_dice[k])
+
+            new_value[k] = 1 + min(vi_safe, vi_normal, vi_risky)
+            dice_for_states[k] = 1 if new_value[k] == 1 + vi_safe else (2 if new_value[k] == 1 + vi_normal else 3)
+
+        if np.allclose(new_value, value):
+            value = new_value
+            break
+
+        value = new_value
+
+    return value[:-1], dice_for_states
+
+layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
+print("\nWin as soon as land on or overstep the final square")
+print(markov_decision(layout, False))
+print("\nStopping on the square to win")
+print(markov_decision(layout, True))

test_files/tmc_test.py

+import numpy as np
+import random as rd
+
+class TransitionMatrixCalculator:
+    def __init__(self):
+        # Probabilités de transition pour les dés "safe", "normal" et "risky"
+        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: list, circle: bool):
+        size = len(layout)
+        matrix_safe = self._compute_matrix(layout, self.safe_dice, size, circle, 'safe')
+        matrix_normal = self._compute_matrix(layout, self.normal_dice, size, circle, 'normal')
+        matrix_risky = self._compute_matrix(layout, self.risky_dice, size, circle, 'risky')
+        return matrix_safe, matrix_normal, matrix_risky
+
+    def _compute_matrix(self, layout: list, dice_probs: list, size: int, circle: bool, matrix_type: str):
+        transition_matrix = np.zeros((size, size))
+        dice_type = None
+
+        if matrix_type == 'safe':
+            dice_type = self.safe_dice
+        elif matrix_type == 'normal':
+            dice_type = self.normal_dice
+        elif matrix_type == 'risky':
+            dice_type = self.risky_dice
+
+        for k in range(size):
+            for s, p in enumerate(dice_probs):
+                k_prime = (k + s) % size if circle else min(size - 1, k + s)
+
+                if k == 9 and s == 1 and matrix_type == 'safe':
+                    k_prime = size - 1
+                elif k == 2 and s > 0 and matrix_type == 'safe':
+                    p /= 2
+                    k_prime = 10 + s - 1
+                    if layout[k_prime] == 1:
+                        k_prime = 0
+                    elif layout[k_prime] == 2:
+                        k_prime = max(0, k_prime - 3)
+                elif k == 7 and s == 3 and matrix_type == 'risky':
+                    k_prime = size - 1
+                elif k == 8 and s in [2, 3] and matrix_type == 'risky':
+                    if circle or s == 2:
+                        k_prime = size - 1
+                    else:
+                        k_prime = 0
+                elif k == 9 and s in [1, 2, 3] and matrix_type == 'risky':
+                    if not circle or s == 1:
+                        k_prime = size - 1
+                    elif circle and s == 2:
+                        k_prime = 0
+                    elif circle and s == 3:
+                        k_prime = 1
+                        if layout[k_prime] in [1, 2]:
+                            k_prime = max(0, k_prime - 3) if layout[k_prime] == 2 else 0
+
+                transition_matrix[k, k_prime] += p * dice_type[s]
+
+        return transition_matrix
+
+    def generate_arrays(self,n):
+        arrays = []
+        for _ in range(n):
+            array = np.zeros(15, dtype=int)
+            indices = rd.sample(range(1, 14), 3)
+            array[indices] = 1, 2, 3
+            arrays.append(array)
+        return arrays
+    
+    def tst_transition_matrix(self):
+        layouts = self.generate_arrays(1000)
+        for array in layouts:
+            print(array)
+            self.compute_transition_matrix(array, False)
+            self.compute_transition_matrix(array, True)
+
+#tmc = TransitionMatrixCalculator()
+#tmc.tst_transition_matrix()

tmc.py

 import numpy as np
 import random as rd
-from openpyxl import Workbook
 
 class TransitionMatrixCalculator:
     def __init__(self):
@@ -9,12 +8,9 @@ class TransitionMatrixCalculator:
         self.matrix_normal = np.zeros((15, 15))
         self.matrix_risky = np.zeros((15, 15))
         # Probability to go from state k to k'
-        safe_dice = np.array([1/2, 1/2])
-        normal_dice = np.array([1/3, 1/3, 1/3])
-        risky_dice = np.array([1/4, 1/4, 1/4, 1/4])
-        self.safe_dice = safe_dice 
-        self.normal_dice = normal_dice
-        self.risky_dice = risky_dice
+        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)
@@ -179,7 +175,7 @@ class TransitionMatrixCalculator:
 
                 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] in [1, 2]:
                     if layout[k_prime] == 1:
                         k_prime = 0
                         self.matrix_risky[k,k_prime] += p
@@ -208,10 +204,10 @@ class TransitionMatrixCalculator:
             array = np.zeros(15, dtype=int)
 
             # Generate 3 random indices between 1 and 13 (exclusive)
-            indices = rd.sample(range(1, 14), 4)
+            indices = rd.sample(range(1, 14), 3)
 
             # Assign the values 1, 2 and 3 to the randomly generated indices
-            array[indices] = 1, 2, 3,4
+            array[indices] = 1, 2, 3
 
             # Append the generated array to the list
             arrays.append(array)
@@ -221,7 +217,7 @@ class TransitionMatrixCalculator:
     # 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(1000)
+        layouts = self.generate_arrays(100)
         for array in layouts:
             print(array)
             self.compute_transition_matrix(array, False)

validation.py

+import numpy as np
+from tmc import TransitionMatrixCalculator
+
+class Validation:
+    def __init__(self, layout, circle=False):
+        self.layout = layout
+        self.circle = circle
+        self.tmc_instance = TransitionMatrixCalculator()
+
+    def simulate_game(self, strategy='optimal', num_games=1000):
+        total_turns = 0
+
+        for _ in range(num_games):
+            if strategy == 'optimal':
+                turns = self.play_optimal_strategy()
+            elif strategy == 'dice1':
+                turns = self.play_dice_strategy(1)
+            elif strategy == 'dice2':
+                turns = self.play_dice_strategy(2)
+            elif strategy == 'dice3':
+                turns = self.play_dice_strategy(3)
+            elif strategy == 'random':
+                turns = self.play_random_strategy()
+
+            total_turns += turns
+
+        average_turns = total_turns / num_games
+        return average_turns
+
+    def play_optimal_strategy(self):
+        # Implement the optimal strategy using value iteration results
+        # Use TransitionMatrixCalculator to compute transitions and make decisions
+
+        # calculer la stratégie optimale pour ou un tour 
+
+
+
+        pass
+
+    def play_dice_strategy(self, dice):
+        # Implement a strategy where only one type of dice is used (1, 2, or 3)
+        pass
+
+    def play_random_strategy(self):
+        # Implement a purely random strategy
+        pass
+
+    def compare_strategies(self, num_games=1000):
+        optimal_cost = self.simulate_game(strategy='optimal', num_games=num_games)
+        dice1_cost = self.simulate_game(strategy='dice1', num_games=num_games)
+        dice2_cost = self.simulate_game(strategy='dice2', num_games=num_games)
+        dice3_cost = self.simulate_game(strategy='dice3', num_games=num_games)
+        random_cost = self.simulate_game(strategy='random', num_games=num_games)
+
+        return {
+            'optimal': optimal_cost,
+            'dice1': dice1_cost,
+            'dice2': dice2_cost,
+            'dice3': dice3_cost,
+            'random': random_cost
+        }
+
+# Example usage
+layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
+validation = Validation(layout, circle=False)
+results = validation.compare_strategies(num_games=10000)
+print("Average Costs:")
+for strategy, cost in results.items():
+    print(f"{strategy}: {cost}")

validation_ex.py

+import numpy as np
+from tmc import TransitionMatrixCalculator
+import random
+import matplotlib.pyplot as plt
+from markovDecision import markovDecision
+
+class Validation:
+    def __init__(self, layout, circle=False):
+        self.layout = layout
+        self.circle = circle
+        self.tmc_instance = TransitionMatrixCalculator()
+
+    def simulate_game(self, strategy='optimal', num_games=1000):
+        total_turns = 0
+
+        for _ in range(num_games):
+            if strategy == 'optimal':
+                turns = self.play_optimal_strategy()
+            elif strategy == 'dice1':
+                turns = self.play_dice_strategy(1)
+            elif strategy == 'dice2':
+                turns = self.play_dice_strategy(2)
+            elif strategy == 'dice3':
+                turns = self.play_dice_strategy(3)
+            elif strategy == 'random':
+                turns = self.play_random_strategy()
+
+            total_turns += turns
+
+        average_turns = total_turns / num_games
+        return average_turns
+
+    def play_optimal_strategy(self):
+        _, optimal_policy = markovDecision(self.layout, self.circle)
+        return self.empirical_results(optimal_policy.astype(int))
+
+    def play_dice_strategy(self, dice):
+        policy = np.ones(len(self.layout), dtype=int) * dice
+        return self.empirical_results(policy)
+
+    def play_random_strategy(self):
+        policy = np.zeros(len(self.layout), dtype=int)
+        for i in range(len(policy) - 1):
+            policy[i] = random.choice([1, 2, 3])
+        return self.empirical_results(policy)
+
+    def empirical_results(self, policy):
+        avgnTurnsPlayed = 0
+        nSimul = 10000
+
+        for _ in range(nSimul):
+            nTurns = self.playOneGame(policy)
+            avgnTurnsPlayed += nTurns
+
+        return avgnTurnsPlayed / nSimul
+
+    def playOneGame(self, policy):
+        nSquares = len(self.layout)
+        nTurns = 0
+        curPos = 0
+        jail = False
+
+        while curPos < nSquares - 1:
+            newPos, jail = self.playOneTurn(policy[curPos], curPos)
+            curPos = newPos
+            nTurns += 1
+
+        return nTurns
+
+    def playOneTurn(self, diceChoice, curPos):
+        nSquares = len(self.layout)
+
+        if curPos == nSquares - 1:
+            return nSquares - 1, False
+
+        if jail :
+            return curPos, False
+
+        listDiceResults = [i for i in range(diceChoice + 1)]
+        result = random.choice(listDiceResults)
+
+        if curPos == 2 and result != 0:
+            slowLane = random.choice([0, 1])
+            if slowLane:
+                newPos = curPos + result
+            else:
+                newPos = curPos + result + 7
+        elif ((curPos == 9 and result != 0) or ((curPos in [7, 8, 9]) and (curPos + result >= 10))):
+            newPos = curPos + result + 4
+        else:
+            newPos = curPos + result
+
+        if newPos > nSquares - 1:
+            if self.circle:
+                newPos -= nSquares
+            else:
+                return nSquares - 1, True
+
+        newSquare = self.layout[newPos]
+
+        if diceChoice == 1:
+            return newPos, False
+        elif diceChoice == 2:
+            newSquare = random.choice([0, newSquare])
+
+        if newSquare == 0:
+            return newPos, False
+        elif newSquare == 1:
+            return 0, False
+        elif newSquare == 2:
+            if newPos - 3 < 0:
+                return 0, False
+            return newPos - 3, False
+        elif newSquare == 3:
+            return newPos, True
+        elif newSquare == 4:
+            newSquare = random.choice([1, 2, 3])
+            if newSquare == 1:
+                return 0, False
+            elif newSquare == 2:
+                if newPos - 3 < 0:
+                    return 0, False
+                return newPos - 3, False
+            elif newSquare == 3:
+                return newPos, True
+
+    def compare_strategies(self, num_games=1000):
+        optimal_cost = self.simulate_game(strategy='optimal', num_games=num_games)
+        dice1_cost = self.simulate_game(strategy='dice1', num_games=num_games)
+        dice2_cost = self.simulate_game(strategy='dice2', num_games=num_games)
+        dice3_cost = self.simulate_game(strategy='dice3', num_games=num_games)
+        random_cost = self.simulate_game(strategy='random', num_games=num_games)
+
+        return {
+            'optimal': optimal_cost,
+            'dice1': dice1_cost,
+            'dice2': dice2_cost,
+            'dice3': dice3_cost,
+            'random': random_cost
+        }
+
+# Example usage
+layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
+validation = Validation(layout, circle=False)
+results = validation.compare_strategies(num_games=10000)
+print("Average Costs:")
+for strategy, cost in results.items():
+    print(f"{strategy}: {cost}")

validation_test.py

+import random as rd
+import numpy as np
+import matplotlib.pyplot as plt
+from tmc import TransitionMatrixCalculator as tmc
+from markovDecision import markovDecision as mD
+
+class EmpiricalComparision :
+    def __init__(self) : 
+        return
+        
+
+    def simulation(strategy, layout : list, circle, nIter : int) :
+        tmc_instance = tmc()
+        safe_dice = tmc_instance._compute_safe_matrix(layout, circle)
+        normal_dice = tmc_instance._compute_normal_matrix(layout, circle)
+        risky_dice = tmc_instance._compute_risky_matrix(layout, circle)
+        matrices_transition = [safe_dice, normal_dice, risky_dice]
+        nTurns = []
+        turns = 0
+        for _ in range(nIter) : 
+            turns = 0
+            k = 0
+            while k < len(layout)-1 :
+                action = strategy[k]
+                transitionMatrix  = matrices_transition[int(action -1)]
+                k = np.rd.choice(len(layout), p = transitionMatrix[k])
+                if layout[k] == 3 and action == 2 : 
+                    turns +=1 if np.rd.uniform(0,1) < 0.5 else 2
+                elif layout[k] == 3 and action == 3 :
+                    turns += 2
+                else :
+                    turns += 1
+            nTurns.append(turns)
+        
+        return np.mean(nTurns)
+
+    
+    def plot(layouts : list, circle, nIter : int) :
+        Markov = []
+        Safe = []
+        Normal = []
+        Risky = []
+        Random = []
+        for layout in layouts :
+            expec, policy = mD(layout, circle)
+            # Simulate the game
+
+        return
+
+
+
+
+
+
+layout = [0,0,3,0,0,0,2,0,0,0,3,0,0,1,0]
+results(layout, False, 1000000)
+results(layout, True, 1000000)
\ No newline at end of file