Bonjour

Je suis les cours data scientist. Habitué des logiciels user friendly style unscrambler, je me trouver fort dépourvu avec Python.

Voulant effectuer le 1er exercice, je me trouve devant un cas insoluble :

- np.random.rand(0,2) me fait planter le script.

- je ne sais pas réunir play_game et play.

- je cours n'explique pas comment convertir une liste en matrice (car il faut bien utiliser un script de type sommes = np.sum(matrice_aleatoire,0) pour remplacer la boucle for, non ?)

Merci d'avance.

Cordialement

Note : voici mon code.

%matplotlib inline
import numpy as np
from random import randint, seed
from enum import Enum
import matplotlib.pyplot as plt

# Ici nous définissons une sous-classe de Enum, qui contiendra
# les stratégies possibles.
class Strategie(Enum):
    CHANGER = 1
    GARDER = 2

# Utilise l'horloge système pour initialiser le générateur de
# nombres pseudo-aléatoires.
seed()


def play_game(strategie):
    portes = [0, 1, 2]
    bonne_porte = np.random.rand(0,2)

    # Choix du joueur
    premier_choix = np.random.rand(0,2)

    # Il nous reste deux portes
    portes.remove(premier_choix)

    # Le présentateur élimine une porte
    if premier_choix == bonne_porte:
        portes.remove(portes[np.random.rand(0,1)])
    else:
        portes = [bonne_porte]

    deuxieme_choix = 0

    # Le deuxieme choix depend de la strategie
    if strategie == Strategie.CHANGER:
        deuxieme_choix = portes[0]
    elif strategie == Strategie.GARDER:
        deuxieme_choix = premier_choix
    else:
        raise ValueError("Stratégie non reconnue!")

    return deuxieme_choix == bonne_porte
   

def play(strategie, nb_tours):
     # ma conversion foireuse de liste vers une matrice.
    matrice_a_grapher = 1 if play_game(strategie) else 0 for i in range(nb_tours)
    fig = plt.figure()
    plot1 = plt.scatter(matrice_a_grapher[0,:])
    plot2 = plt.scatter(matrice_a_grapher[1,:])
 
print("En changeant de porte, le joueur a gagné {} sur 10000 parties."
      .format(sum(play(Strategie.CHANGER, 10000))))

print("En gardant son choix initial, le joueur a gagné {} sur 10000 parties."
      .format(sum(play(Strategie.GARDER, 10000))))
     
plot = plt.bar([1,2],[sum(play(Strategie.CHANGER, 10000)),
               sum(play(Strategie.GARDER, 10000))],
        tick_label=["Changer","Garder"])
       

# NUAGE DE POINTS POUR VOIR LES GAINS (
gains_changer = []
gains_garder = []
samples =  [1000, 10000, 20000, 50000, 80000, 100000]
   
figure = plt.figure(samples)
plot = plt.scatter(samples, [np.sum(matrice_a_grapher,0)])
plot = plt.scatter(samples, [np.sum(matrice_a_grapher,1)])

-
Edité par RichardChazal1 22 octobre 2018 à 20:02:07

Hello,

Pareil pour moi....Avez vous trouvé des réponses ?  Je galère un petit peu. 

Merci, Laurent

1°) Vous avez besoin de générer aléatoirement des nombres entiers compris entre 0 et 2 (inclus).
Utilisez np.random.randint. La fonction np.random.rand utilisée dans le cours sert à générer des nombres décimaux.

2°) Oubliez les fonctions play et play_game.
Dites-vous bien que le grand intérêt avec Numpy est de pouvoir faire des calculs de masse avec une librairie codée en C.
Si vous parcourez toutes les valeurs possibles avec une boucle en Python, vous mettez 100 à 1000 fois plus de temps à l'exécution.

L'idée, ici, est de faire deux matrices Numpy : une avec les numéros des bonnes portes, une avec le 1er choix. Ensuite on fait une (et une seule !) opération Numpy sur ces deux matrices en fonction de la stratégie choisie, et on fait la somme de la matrice résultat pour savoir combien de fois le joueur a gagné.

C'est à la fois infiniment plus simple et plus rapide que le script du cours. C'est le but.