User Tools

Site Tools


Sidebar

* [[http://www.labri.fr/perso/melancon|Me as a researcher]] --- * [[start|Home]] * [[proj_techno:start|Projets technologiques - Licence 3 Informatique]] 4TIN601U * [[proj_CMI_L2:start|Projet de programmation - CMI ISI]] 4TCM401U * [[MIAGE:processus_stoch_simulation|Processus stochastiques et simulation - MIAGE et e-MIAGE]] 4TYE814U / 4TYE808U ---- * **Fête de la Science** - [[mathc2+:analyse|"Analyse de réseau appliquée aux réseau sociaux"]] ---- * Master U de Bx * [[http://www.labri.fr/perso/melancon/Visual_Analytics_Course/|Visual Analytics]] * [[e-miage_ubx_i|e-MIAGE U de Bx]] * [[estia:estia|ESTIA DataViz / Data Science]] * [[Enseignements passés]] ---- * [[http://www.labri.fr/perso/melancon|Research]] ---- * [[admin:Site admin]]

A PCRE internal error occured. This might be caused by a faulty plugin
miage_epreuve:tp_note_final_b

====== Master 4TYE814U/4TYE808U MIAGE & e-MIAGE -- Processus stochastiques et simulation ====== ;;# "It is a part of probability that many improbabilities will happen." ;;# ;;# Aristotle ;;# ---- ===== Sujet type de TP noté du 28/02/2017 ===== * Le sujet propose des fichiers de code à compléter. Ces fichiers doivent être composés séparément et doivent pouvoir être exécutés séparément (sans problème à l'aide des directives d'import). * Les fichiers de code sont directement téléchargeables (en cliquant dans l'entête). * La bonne exécution du code exige de placer tous ces fichiers dans un même répoertoire. ---- ==== Monopoly ==== {{ :miage:plateaumonopoly.jpg?direct&500 |}} Cet exercice consiste à implémenter la modélisation du [[miage:cours_exemples_travailles|jeu de Monopoly]] à l'aide d'une chaîne de Markov -- en réalité plusieurs chaînes de Markov qui implémente le jeu sous des formes simplifiées puis se rapprochant de plus en plus du jeu avec la totalité des règles. La chaîne permet de simuler les parcours effectués par un seul joueur -- comme s'il jouait seul au Monopoly ... A chaque tour, un joueur lance deux dés et avance, depuis la case sur laquelle il se trouve, sur une autre case du plateau. Les cases représentent, pour une large majorité d'entre elles, des propriétés que l'on peut acheter. Le visiteur arrivant sur un case doit alors payer un loyer son propriétaire (ou l'acheter si elle n'a pas encore de propriétaire). Nous allons chercher ˆ établir les probabilités qu'un joueur tombe sur une case afin de déterminer les propriétés qui sont les plus opportunes ˆ acheter: doit-on acheter dès le départ la rue de la Paix ou les Champs Elysées ? est-il vrai qu'il est opportun de posséder les gares ? etc. ---- Il est utile de se munir d'une variable ''probas_lancers_des'' énumerant les probabilités d'obtenir un lancer de dés qui donne 2, 3, 4, ..., ou 12 (dans un tableau par exemple). __Attention, nous considérons un lancer de deux dés distincts__ (l'un rouge, l'autre bleu disons). On convient de noter les cases depuis 0 (case "Départ") à 39 (case "Rue de la Paix"). Ce sont là les états de la chaîne de Markov. IL sera aussi utile plus loin de disposer d'une variable qui permet de comptabiliser les fréquences de passages sur chacune des cases du jeu. <code python> # -*- coding:utf-8 -*- import numpy import random probas_lancers_des = # ... ... </code> ---- === Une première version très simple === Nous allons d'abord considérer un scénario simpliste, celui où un joueur lance les deux dés et avance ˆ la prochaine case, sans se soucier pour l'instant des //règles des doubles// (lorsque les deux dés ont même valeur), ou des cases "//Chance//" ou "//Caisse de communauté//", etc. * Votre code doit calculer la matrice (au sens de ''numpy'') de transition de cette version simple du jeu. * Votre code doit aussi fournir une fonction ''transition'' permettant d'effectuer une marche aléatoire sur la chaîne (simulant le jeu). * <color red/#efefef>Votre fonction doit //obligatoirement// utiliser et consulter les probabilités contenues dans la matrice fournies en paramètre.</color> <file python monopoly_simpliste.py> # -*- coding:utf-8 -*- import random import numpy ######################################################### # Version simpliste du jeu de monopoly ######################################################### probas_lancers_des = # ... ######################################################### # la fonction matrice_simpliste calcule la matrice de transition # de la version simpliste du jeu de monopoly # elle utilisera les probabilites des lancers de des def matrice_simpliste(nb_etats, probas_lancers_des): # to do # ... return # une matrice def transition(etat, matrice) # to do # ... return # un etat (une case du jeu) </file> ---- * Le jeu démarre avec le pion du joueur sur la case "Départ". * Votre code doit pouvoir calculer une bonne approximation de la distribution stationnaire //à l'aide du calcul matriciel//. * Votre code doit pouvoir calculer une bonne approximation de la distribution stationnaire //à l'aide d'une marche aléatoire//. Vous déterminerez le nombre de pas nécessaire à la marche pour avoir __une approximation à trois décimales__. <file python monopoly_simpliste_test.py> # -*- coding:utf-8 -*- import random import numpy from monopoly_simpliste import * ######################################################### # le code suivant doit pouvoir s'executer sans probleme # apres avoir preciser quelques variables # # les frequences affichees doivent correspondre a la distribution stationnaire nb_etats = # ... nb etats !!! M_simple = matrice_simpliste(nb_etats) ######################################################### # calcul de la distribution stationnaire par calcul matriciel distribution_init = # ... distribution_stat = # ... # ... on utilise la matrice de transition print distribution_stat ######################################################### # calcul de la distribution stationnaire a l'aide d'une marche aleatoire frequences_passage = # ... un tableau nb_pas = # ... a vous de voir etat = # ... etat de depart for i in range(nb_pas): frequences_passage[etat] # ... mise a jour etat = transition_simpliste(etat, M_simple) ######################################################### # cette derniere instruction permet d'afficher les frequences relatives # a partir du tableau de frequences observees print map(lambda x: x/nb_pas, frequences_passage) </file> ---- === Une version plus élaborée === Ce qui rend le jeu intéressant sont ces règles qui perturbent la régularité observée dans cette première matrice de transition $M_{simple}$. L'une de ces règles consiste à permettre à un joueur de relancer les dés dès lors qu'il a eu des doubles (deux dés de même valeur). Cela dit, si le joueur enchaîne des doubles trois fois, il doit aller en prison (sur la case 11) N.B. : La règle selon laquelle on reste en prison trois tours, avec la possibilité d'anticiper sa sortie -- en roulant les dés ou en payant ou en utilisant une carte -- nous importe peu puisque nous modélisons le déplacement d'un seul joueur. Il sera utile maintenant de disposer de fonctions permettant de simuler le lancer de deux dés distincts, et d'une fonction permettant de tester si le lancer de dés est un double: <file python monopoly_double.py> # -*- coding:utf-8 -*- import numpy import random nb_etats = 40 def lancer_des(): return paires_des[numpy.random.randint(11)] def is_double(paire_des): return paire_des[0] == paire_des[1] </file> Vous devez pouvoir simuler cette version du jeu en complétant le code: <file python monopoly_double_test.py> # -*- coding:utf-8 -*- import numpy import random from monopoly_double import * frequences_passage = # ... un tableau nb_pas = # ... a vous de voir etat = # ... etat de depart # on lance les des # il vous faut convenir d'une maniere de gerer la regle des doubles for i in range(nb_pas): frequences_passage[etat] # ... mise a jour des = lancer_des() # il faut prevoir la gestion des doubles if est_double(des): # ... # la variable etat prend une nouvelle valeur etat = # ... else: # ... # la variable etat prend une nouvelle valeur etat = # ... print map(lambda x: x / nb_pas, frequences_passage) ######################################################### # vous indiquez ici en commentaire dans le code votre observation # sur la distribution stationnaire de cette variante du jeu </file> ---- === The Full Bounty === Le plateau comporte aussi des cases qui peuvent changer le cours d'une partie: les cases //Chance// et //Caisse de communauté//. Lorsque l'on pioche une carte //Chance//, de deux choses l'une: ou bien on reste sur place (et on paye une amende ou on reçoit une somme), ou alors on change de case. Dans 43,75\% des cas, on reste sur place. Les autres cas, équiprobables à 6,25\%, déplace le pion: * Vers la case Départ (case 1) * Rue de Belleville (case 2) * Gare Montparnasse (case 5) * En prison (case 11) * Avenue Henri-Martin (case 25) * Rue de la Paix (case 40) * Au service public le plus proche (Compagnie de distribution des eaux / de l'électricité) * A la gare la plus proche * Trois cases en arrière Les cartes //Caisse de communauté// ont un effet semblable, quoique plut™ôt tournées vers le paiement d'amende: * dans 87,5\% des cas on reste sur place (et on paye ...), * dans 6,25\% des cas le joueur se déplace ˆ la case \emph{Départ}, * dans 6,25\% des cas le joueur va en prison. Tout comme la //règles des doubles//, les effets induits par les cartes //Chance// et //Caisse de communauté// viennent changer les probabilités de transition qu'il nous faut considérer. Cette dernière partie de l'épreuve vise à simuler une marche aléatoire sur cette version complète du jeu de Monopoly. * Il sera utile de stocker les numéros des cases dont il faut maintenant tenir compte. * IL vous faut aussi construire des fonctions qui effectuent les actions attendues. <file python monopoly_full.py> caisse_commune = # ... les cases caisse de commune chance = # ... les cases caisse chance gares = # ... les cases des gares service_publics = # ... les cases des services publics ######################################################### # cette fonction renvoie le numero de la case service public la plus proche def service_publique(etat): # to do # ... return # ... la case service public la plus proche ######################################################### # cette fonction renvoie le numero de la case de la gare la plus proche def gare(etat): # to do # ... return # ... la case gare la plus proche ######################################################### # cette fonction simule l'effet du choix d'une carte de chance def choix_chance(etat): # to do # ... return # ... la case vers laquelle aller ######################################################### # cette fonction simule l'effet du choix d'une carte de caisse commune def choix_caisse_commune(etat): # to do # ... return # ... la case vers laquelle aller </file> Vous devez pouvoir simuler cette version du jeu en complétant le code: <file python monopoly_full_test.py> # -*- coding:utf-8 -*- import numpy import random from monopoly_double import * from monopoly_full import * frequences_passage = # ... un tableau nb_pas = # ... a vous de voir etat = # ... etat de depart # on lance les des # il vous faut convenir d'une maniere de gerer la regle des doubles for i in range(nb_pas): if etat in caisse_commune: # gerer la pioche d'une carte de caisse commune elif etat in chance: # gerer la pioche d'une carte de chance frequences_passage[etat] # ... mise a jour des = lancer_des() # il faut prevoir la gestion des doubles if est_double(des): # ... # la variable etat prend une nouvelle valeur etat = # ... else: # ... # la variable etat prend une nouvelle valeur etat = # ... print map(lambda x: x / nb_pas, frequences_passage) ######################################################### # vous indiquez ici en commentaire dans le code votre observation # sur la distribution stationnaire de cette variante du jeu # # quelle sont les cases (proprietes) qu'il vaut mieux posseder ? </file> --- [[miage:processus_stoch_simulation|Retour à la page d'accueil du cours]]

miage_epreuve/tp_note_final_b.txt · Last modified: 2017/02/24 19:03 by melancon