update the readme

README.md

 # Group 5 - Projet de Machine Learning
  
-Ce projet vise à implémenter un jeu de "Snake and Ladders" ainsi que de l'entrainer afin d'obtenir la meilleure stratégie.
+Ce projet vise à implémenter un jeu de "Snake and Ladders" afin d'observer quelle est la  optimale parmis l'ensemble des stratégies.
  
 Ce README présente la structure et résume notre projet.
  
@@ -10,11 +10,8 @@ Pour exécuter les différents scripts et notebooks, assurez-vous d'avoir instal
  
 ```bash
 pip install numpy
-pip install TransitionMatrixCalculator
-pip install Validation
 pip install matplotlib.pyplot
 pip install random
-pip install MarkovDecisionSolver
 ```
  
 ## Codes Python
@@ -23,20 +20,21 @@ Ces codes permettent d'implémenter le jeu du Snake and Ladders, de déterminer
  
 ### tmc.py
  
-Ce code définit une **classe TransitionMatrixCalculator** qui calcule les matrices de transitions en fonctions des trois scénarios possible. Les règles de ce jeux diffèrent de celles traditionnellement utilisées, en effet à chaque étape le joueur à le choix entre trois dés : safe, normal ou risqué. Ils ont une influence sur la suite du jeu, effectivement le choix de dé occassione ou non la présence de pièges sur le plateau de jeu.
+Le fichier **tmc.py**  définit une **class TransitionMatrixCalculator** qui calcule les matrices de transitions en fonctions des trois scénarios possible. Les règles de ce jeux diffèrent de celles traditionnellement utilisées, en effet à chaque étape le joueur à le choix entre trois dés : safe, normal ou risky. Ils ont une influence sur la suite du jeu, effectivement le choix du dé occassione ou non la présence de pièges sur le plateau de jeu.
  
 ### markovDecison.py
  
-Ce code contient une **classe MarkovDecisionProcess** qui définit les algorithmes de Value Iteration relatifs aux différentes stratégies. La fonction **solve** permet de calculer la politique optimale. Ensuite, la fonction **markovDecision** faisant appel à la fonction **solve**, permet d'obtenir la stratégie optimale.
+Le fichier **markovDecison.py**  contient une **class MarkovDecisionProcess** qui définit les algorithmes de Value Iteration relatifs aux différentes stratégies. La fonction **solve** permet de calculer la politique optimale par l'algorithme de Value Iteration. Ceci est réalisé en faisant appel aux 3 fonctions **_compute_vi_safe**,**_compute_vi_normal**,**_compute_vi_risky**  qui permettent de calculer pour chacun des dés la Value Iteration et de choisir le minimum d'entre toutes les valeurs. Ensuite, la fonction **markovDecision** faisant appel à la fonction **solve**, permet d'afficher la stratégie optimale (les dés devant être joué suivant un layout) et les coût théorique de chaque case en fonction d'un jeu cyclique ou acyclique.
  
 ### validation.py
  
-Dans ce code nous définissons une **classe validation** dans laquelle nous créons différentes fonctions de simulation du jeu. Cela va permettre d'obtenir le coût empirique de notre jeu (pour la fonction **simulate_rounds**) et le nombre de tour moyen nécessaire pour atteindre la case finale du jeu (pour la fonction **state_simulation**). Ensuite, nous implémentons des fonctions permettant de comparer les résultats empiriques, des simulations de jeu, aux résultats théoriques attendus, obtenus par value iteration.
+Dans ce code nous définissons une **class validation** dans laquelle nous créons différentes fonctions de simulation du jeu et d'états. Cela va permettre d'obtenir le coût empirique de notre jeu (pour la fonction **simulate_rounds**) et le nombre de tour moyen nécessaire pour atteindre la case finale du jeu (pour la fonction **state_simulation**). Ensuite, nous implémentons des fonctions permettant de comparer les résultats empiriques, des simulations de jeu (dés safe, normal, risky et random), aux résultats théoriques attendus, obtenus par value iteration.
  
 ### plot.py
  
-Ce code permet de réaliser différents graphiques afin de comparer les résultats obtenus des stratégies.
- 
+Ce code permet de réaliser différents graphiques afin de comparer les résultats obtenus des stratégies. 4 graphiques peuvent être imprimés via 4 fonctions différentes dépendant d'un layout : **plot_strategy_comparison**,**plot_state_based_turns**,**plot_state_based_comparison**,**plot_state_based_comparison_once**. Le layout utilisé pour comparer nos stratégies est celui-ci : layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]. La fonction **plot_strategy_comparison** permet de comparer les différentes stratégies en fonction de leur average turns sur un histogramme. La fonction **plot_state_based_turns** renvoie un graphe permettant de comparer l'average turn pour chaque état. La fonction **plot_state_based_comparison** a été implémentée dans l'optique de comparer l'algorithme de Value Iteration (theorical cost) et différentes simulations (empirical cost : 100, 10.000 et 1000.000) permettant de montrer la précision obtenue en fonction du nombre de simulations. Enfin, la fonction **plot_state_based_comparison_once** permet de comparer le theorical cost et l'empirical cost basé sur un nombre de simulations définies.
+
+
 ## Contact
 Pour toute question, suggestion, ou demande de collaboration sur ce projet, n'hésitez pas à nous contacter. Pour des discussions plus approfondies sur notre recherche et notre méthodologie, nous pouvez contacter :
 - Audrey Ghilain à audrey.ghilain@student.uclouvain.be
@@ -53,4 +51,6 @@ Nous tenons à exprimer notre gratitude envers plusieurs parties qui ont jouées
 - Nathanaël Kindidi
 - Adrien Payen
  
-## Références
+## Références
\ No newline at end of file
+
+Cours de Monsieurs Saerens.
\ No newline at end of file

markovDecision.py

+# All the imports
 import numpy as np
 from tmc import TransitionMatrixCalculator as tmc
 

plot.py

+# All the imports
 import matplotlib.pyplot as plt
 from validation import Validation as Val
-import numpy as np
 
 
 def plot_strategy_comparison(num_games : int):
@@ -93,25 +93,25 @@ if __name__ == '__main__':
     ##### Paramètres #####
 
     # Define the layout of the game board
-   #layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
+    layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
     
+    # All the layout for the comparison
+    #classiclayout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
     #layout = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 1, 0]
-
-    #layoutfastlaneWt = [0, 0, 3, 0, 2, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0]
-    #layoutslowlaneWt = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 1, 0]
-
-    layout = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    #layouttpslowlane = [0, 0, 3, 0, 2, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0] # layout with a trapped slowlane
+    #layouttpfastlane = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 1, 0] # layout with a trapped fastlane
+    #zerolayout = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    
     # Indicates whether the board is circular or linear
-    circle = True
+    circle = False
     # Number of games to simulate
-    num_games = 1000000
+    num_games = 1000
     # Initialize Validation instance with the specified layout and circle type
     validation_instance = Val(layout, circle)
 
-     ##### Launch Plots #####
-
+    ##### Launch Plots #####
     # Run the defined plotting functions with specified parameters
-    #plot_strategy_comparison(num_games)
+    plot_strategy_comparison(num_games)
     plot_state_based_turns()
-    #plot_state_based_comparison(num_games_list = [10,100,1000])
-    #plot_state_based_comparison_once(num_games)
+    plot_state_based_comparison(num_games_list = [10,100,1000])
+    plot_state_based_comparison_once(num_games)
\ No newline at end of file

tmc.py

+# The import
 import numpy as np
 
 class TransitionMatrixCalculator:

validation.py

+# All the imports
 import random as rd
 import numpy as np
 from tmc import TransitionMatrixCalculator as tmc