Ce projet vise à implémenter un jeu de "Snake and Ladders" afin d'observer quelle est la optimale parmis l'ensemble des stratégies.
This project aims to implement a game of "Snake and Ladders" to observe which is the optimal among all strategies.
Ce README présente la structure et résume notre projet.
This README presents the structure and summarizes our project.
## Python Libraries :
## Python Libraries :
Pour exécuter les différents scripts et notebooks, assurez-vous d'avoir installé les librairies Python suivantes:
To run the various scripts and notebooks, make sure you have installed the following Python libraries:
```bash
```bash
pip install numpy
pip install numpy
pip install matplotlib.pyplot
pip install matplotlib.pyplot
pip install random
pip install random
```
```
## Codes Python
## Python scripts :
Ces codes permettent d'implémenter le jeu du Snake and Ladders, de déterminer différentes stratégies possible ainsi que d'analyser les résultats de celles-ci.
These codes allow to implement the game of Snake and Ladders, to determine different possible strategies and to analyze the results of them.
### 1. tmc.py
### 1. tmc.py
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.
The**tmc.py**file defines a**class TransitionMatrixCalculator**that calculates the transition matrices based on the three possible scenarios. The rules of this game differ from those traditionally used, indeed at each stage the player to choose between three dice: safe, normal or risky. They have an influence on the rest of the game, indeed the choice of the dice occassione or not the presence of traps on the game board.
### 2. markovDecison.py
### 2. markovDecison.py
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.
The**markovDecison.py**file contains a**class MarkovDecisionProcess**that defines the Value Iteration algorithms for the different strategies. The **solve** function is used to calculate the optimal policy by the Value Iteration algorithm. This is achieved by using the 3 functions **_compute_vi_safe**,*_compute_vi_normal**,**_compute_vi_risky** which make it possible to calculate the Value Iteration for each of the dice and choose the minimum of all the values. Then, the **markovDecision** function using the **solve** function displays the optimal strategy (the dice to be played according to a layout) and the theoretical cost of each square according to a cyclic or acyclic game.
### 3. validation.py
### 3. validation.py
Ce fichier**validation.py**définit 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.
This**validation.py**file defines a**class validation**in which we create different game simulation and state functions. This will allow us to obtain the empirical cost of our game (for the**simulate_rounds**) and the average number of turns needed to reach the final square of the game (for the**state_simulation***). Then, we implement functions to compare empirical results, game simulations (dice safe, normal, risky and random), to the expected theoretical results, obtained by value iteration.
### 4. plot.py
### 4. plot.py
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.
This code allows different graphs to compare the results obtained from the strategies. 4 graphs can be printed via 4 different functions depending on a layout: **plot_strategy_comparison**,**plot_state_based_turns**,**plot_state_based_comparison**,**plot_state_based_comparison_once**. The layout used to compare our strategies is this: layout = [0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]. The**plot_strategy_comparison**function allows comparing different strategies based on their average turns on a histogram. The**plot_state_based_turns**function returns a graph to compare the average turn for each state. The**plot_state_based_comparison**function was implemented in order to compare the Value Iteration algorithm (theorical cost) and different simulations (empirical cost: 100, 10.000 and 1000.000) to show the accuracy obtained as a function of the number of simulations. Finally, the**plot_state_based_comparison_once**function compares the theorical cost and the empirical cost based on a number of defined simulations.
## Contact
## 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 :
For any question, suggestion, or request for collaboration on this project, do not hesitate to contact us. For further discussion on our research and methodology, we can contact:
- Audrey Ghilain à audrey.ghilain@student.uclouvain.be
Nous tenons à exprimer notre gratitude envers plusieurs parties qui ont jouées un rôle crucial dans la réalisation de ce projet:
We would like to express our gratitude to several parties who played a crucial role in the realization of this project:
-**Professeur Saerens Marco**: Pour son enseignement en Machine Learning. Son soutien et ses conseils ont été essentiels pour l'adaptation et l'amélioration de nos codes dans notre projet.
-**Professor Saerens Marco**: For his teaching in Machine Learning. His support and advice were essential for the adaptation and improvement of our codes in our project.
-**Assistant Leleux Pierre**: Pour ses conseils vis-à-vis du projet. Ses conseils ont étés essentiels pour l'implementation de ce projet.
-**Assistant Leleux Pierre**: For his advice on the project. His advice was essential for the implementation of this project.
## Auteurs
## Authors
- Audrey Ghilain
- Audrey Ghilain
- Nathanaël Kindidi
- Nathanaël Kindidi
- Adrien Payen
- Adrien Payen
## Références
## References
Teacher Saerens Course : Saerens, M. (n.d.). Decision making [PDF document]. UCLouvain.
