Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (② Enregistrer l'environnement dans le gymnase)

introduction

J'ai essayé de faire une stratégie de blackjack tout en étudiant Python et en renforçant l'apprentissage. Il existe une stratégie basée sur la probabilité d'une stratégie de base, mais je vais essayer de la rattraper.

Je vais procéder comme ça

  1. Implémentation du Blackjack
  2. Inscrivez-vous dans l'environnement de gym OpenAI ← Cette fois ici
  3. Apprenez la stratégie de Blackjack avec un apprentissage amélioré

Qu'est-ce que la gym OpenAI?

C'est une plateforme utilisée comme environnement de recherche pour un apprentissage intensif. Les environnements (jeux) tels que CartPole et labyrinthe sont préparés et vous pouvez facilement essayer un apprentissage amélioré. L'environnement OpenAI Gym a une interface commune qui reçoit les actions des agents et, par conséquent, renvoie l'état et la récompense suivants. L'installation peut être effectuée facilement comme suit, mais veuillez vous référer aux autres pages pour la méthode détaillée. Dans ce qui suit, on suppose que l'installation est terminée.

pip install gym

Cette fois, je vais enregistrer mon propre blackjack dans cet environnement Open AI Gym afin de pouvoir faire un apprentissage amélioré.

Examen de l'apprentissage par renforcement

Tout d'abord, un bref aperçu de l'apprentissage par renforcement. L '«état» est observé à partir de «l'environnement», et «l'agent» prend «une action» en réponse à cela. «Environnement» renvoie le «Statut» et la «Récompense» mis à jour à «Agent». Le but de l'apprentissage par renforcement est d'acquérir une méthode «d'action» (= politique) qui maximise le montant total de «récompenses» qui seront obtenues à l'avenir.

Appliquer les éléments d'un apprentissage amélioré au blackjack

Dans ce Blackjack, nous considérerons l'apprentissage par renforcement comme suit.

--Environnement: Blackjack --Agent: Joueur --Statut: carte de joueur, carte de croupier, etc. --Action: sélection du joueur. Frapper, se tenir debout, etc.

image.png

Procédure d'enregistrement de l'environnement dans OpenAI Gym

Suivez les étapes ci-dessous pour enregistrer votre propre environnement dans OpenAI Gym.

  1. Créez une classe d'environnement de blackjack "BlackJackEnv" qui hérite de gym.Env d'OpenAI Gym
  2. Enregistrez l'environnement à l'aide de la fonction gym.envs.registration.register afin qu'il puisse être appelé avec l'ID BlackJack-v0.

Environnement de développement

organisation des fichiers

La structure des fichiers est la suivante. Veuillez noter qu'il existe deux fichiers nommés \ _ \ _ init \ _ \ _. Py.

└─ myenv
    ├─ __init__.py  --->Appeler BlacJackEnv
    └─env
       ├─ __init__.py  --->Indique où se trouve le BlackJack Env
       ├─ blackjack.py  --->Jeu BlackJack lui-même
       └─ blackjack_env.py  --->Gymnase OpenAI Gym.Créer une classe BlackJackEnv qui hérite d'Env

Ensuite, suivez la procédure pour enregistrer l'environnement.

Créez une classe d'environnement de blackjack "BlackJackEnv" qui hérite du gym.Env d'OpenAI Gym

myenv/env/blackjack.py Laissez le code de Blackjack créé la dernière fois tel quel. Importez-le avec blackjack_env.py ci-dessous et utilisez-le.

myenv/env/blackjack_env.py Créez la classe "BlackJackEnv" de l'environnement de jeu BlackJack que vous souhaitez enregistrer dans OpenAI Gym. Héritez de gym.Env et implémentez les 3 propriétés et 5 méthodes suivantes.

Propriété

--action_space: indique quelle action le joueur (l'agent) peut sélectionner. --observation_space: informations sur l'environnement de jeu que le joueur (agent) peut observer --reward_range: Plage de récompense minimale à maximale

Méthode

--reset: méthode de réinitialisation de l'environnement. --step: méthode qui exécute une action dans l'environnement et renvoie le résultat. --render: une méthode pour visualiser l'environnement. --close: une méthode pour fermer l'environnement. Il est utilisé en fin d'apprentissage. --Seed: Une méthode pour fixer une graine aléatoire.

propriété action_space

Cela montre que vous pouvez effectuer quatre actions: se tenir debout, frapper, doubler et se rendre.

action_space


self.action_space = gym.spaces.Discrete(4)
propriété observation_space

Observez les quatre états du score total de la main du joueur, le score de la main révélée par le croupier, le drapeau indiquant la main douce (A est inclus dans la main du joueur) et le drapeau indiquant si le joueur a été touché. Déterminez les valeurs maximum et minimum pour chacun.

observation_space


high = np.array([
            30,  # player max
            30,  # dealer max
            1,   # is_soft_hand
            1,   # hit flag true
        ])
        low = np.array([
            2,  # player min
            1,  # dealer min
            0,  # is_soft_hand false
            0,  # hit flag false
        ])
        self.observation_space = gym.spaces.Box(low=low, high=high)
Propriété de récompense_range

Déterminez la gamme de récompenses. Ici, il est décidé d'inclure les valeurs minimales et maximales des puces pouvant être obtenues.

reward_range


        self.reward_range = [-10000, 10000]
méthode de réinitialisation

Initialisez self.done, initialisez la main du joueur et du croupier avec self.game.reset_game (), pariez des jetons (Bet) et distribuez des cartes (Deal). Comme mentionné dans la méthode par étapes, self.done est une valeur booléenne qui indique s'il y a ou non gain ou perte. Observez et renvoyez 4 états avec self.observe (). Cependant, cette fois, nous avons décidé de former le joueur en supposant que le nombre de jetons possédés par le joueur ne diminue pas.

reset()


    def reset(self):
        #Initialise l'état et retourne l'observation initiale
        #Initialiser diverses variables
        self.done = False

        self.game.reset_game()
        self.game.bet(bet=100)
        self.game.player.chip.balance = 1000  #Le montant d'argent dont vous disposez ne sera jamais nul pendant vos études
        self.game.deal()
        # self.bet_done = True

        return self.observe()
méthode par étapes

Le joueur prend soit Stand, Hit, Double down ou Surrender par rapport à l'environnement. Si le tour du joueur est terminé, le jeton sera réglé. Enfin, les quatre informations suivantes sont renvoyées.

--observation: l'état de l'environnement observé. --Reward: le montant de la récompense gagnée par l'action. --done: valeur booléenne indiquant si l'environnement doit être réinitialisé à nouveau. Dans BlackJack, une valeur booléenne qui indique s'il y a ou non une victoire ou une perte. --info: un dictionnaire qui peut définir des informations utiles pour le débogage.

De plus, dans cet environnement d'apprentissage, si vous doublez ou abandonnez après avoir frappé, vous serez pénalisé pour avoir enfreint les règles.

step()


    def step(self, action):
        #Exécuter l'action et renvoyer le résultat
        #Décrivez le processus pour avancer d'une étape. La valeur de retour est observation, reward,fait (le jeu est-il terminé), info(Dictionnaire d'informations complémentaires)

        if action == 0:
            action_str = 's'  # Stand
        elif action == 1:
            action_str = 'h'  # Hit
        elif action == 2:
            action_str = 'd'  # Double down
        elif action == 3:
            action_str = 'r'  # Surrender
        else:
            print(action)
            print("Action non définie")
            print(self.observe())

        hit_flag_before_step = self.game.player.hit_flag
        self.game.player_step(action=action_str)

        if self.game.player.done:
            #À la fin du tour du joueur
            self.game.dealer_turn()
            self.game.judge()
            reward = self.get_reward()
            self.game.check_deck()
            print(str(self.game.judgment) + " : " + str(reward))


        elif action >= 2 and hit_flag_before_step is True:
            reward = -1e3  #Donnez une pénalité si vous enfreignez les règles

        else:
            #Lors de la poursuite du tour d'un joueur
            reward = 0

        observation = self.observe()
        self.done = self.is_done()
        return observation, reward, self.done, {}

Cette fois, les méthodes render, close et seed ne sont pas utilisées.

Le code complet de blackjack_env.py ressemble à ceci:

myenv/env/blackjack_env.py


import gym
import gym.spaces
import numpy as np

from myenv.env.blackjack import Game


class BlackJackEnv(gym.Env):
    metadata = {'render.mode': ['human', 'ansi']}

    def __init__(self):
        super().__init__()

        self.game = Game()
        self.game.start()

        # action_space, observation_space, reward_Définir la plage
        self.action_space = gym.spaces.Discrete(4)  # hit, stand, double down, surrender

        high = np.array([
            30,  # player max
            30,  # dealer max
            1,   # is_soft_hand
            1,   # hit flag true
        ])
        low = np.array([
            2,  # player min
            1,  # dealer min
            0,  # is_soft_hand false
            0,  # hit flag false
        ])
        self.observation_space = gym.spaces.Box(low=low, high=high)
        self.reward_range = [-10000, 10000]  #Liste des récompenses minimales et maximales

        self.done = False
        self.reset()

    def reset(self):
        #Initialise l'état et retourne l'observation initiale
        #Initialiser diverses variables
        self.done = False

        self.game.reset_game()
        self.game.bet(bet=100)
        self.game.player.chip.balance = 1000  #Le montant d'argent dont vous disposez ne sera jamais nul pendant vos études
        self.game.deal()
        # self.bet_done = True

        return self.observe()

    def step(self, action):
        #Exécuter l'action et renvoyer le résultat
        #Décrivez le processus pour avancer d'une étape. La valeur de retour est observation, reward,fait (le jeu est-il terminé), info(Dictionnaire d'informations complémentaires)

        if action == 0:
            action_str = 's'  # Stand
        elif action == 1:
            action_str = 'h'  # Hit
        elif action == 2:
            action_str = 'd'  # Double down
        elif action == 3:
            action_str = 'r'  # Surrender
        else:
            print(action)
            print("Action non définie")
            print(self.observe())

        hit_flag_before_step = self.game.player.hit_flag
        self.game.player_step(action=action_str)

        if self.game.player.done:
            #À la fin du tour du joueur
            self.game.dealer_turn()
            self.game.judge()
            reward = self.get_reward()
            self.game.check_deck()
            print(str(self.game.judgment) + " : " + str(reward))


        elif action >= 2 and hit_flag_before_step is True:
            reward = -1e3  #Donnez une pénalité si vous enfreignez les règles

        else:
            #Lors de la poursuite du tour d'un joueur
            reward = 0

        observation = self.observe()
        self.done = self.is_done()
        return observation, reward, self.done, {}

    def render(self, mode='human', close=False):
        #Visualisez l'environnement
        #Dans le cas de l'humain, il est émis vers la console. Renvoie StringIO pour ansi
        pass

    def close(self):
        #Fermez l'environnement et effectuez un post-traitement
        pass

    def seed(self, seed=None):
        #Réparer les graines aléatoires
        pass

    def get_reward(self):
        #Récompense de retour
        reward = self.game.pay_chip() - self.game.player.chip.bet
        return reward

    def is_done(self):
        if self.game.player.done:
            return True
        else:
            return False

    def observe(self):
        if self.game.player.done:
            observation = tuple([
                self.game.player.hand.calc_final_point(),
                self.game.dealer.hand.calc_final_point(),  #Score total de la carte du concessionnaire
                int(self.game.player.hand.is_soft_hand),
                int(self.game.player.hit_flag)])
        else:
            observation = tuple([
                self.game.player.hand.calc_final_point(),
                self.game.dealer.hand.hand[0].point,  #Carte du concessionnaire uniquement
                int(self.game.player.hand.is_soft_hand),
                int(self.game.player.hit_flag)])

        return observation

Enregistrez l'environnement à l'aide de la fonction gym.envs.registration.register afin qu'il puisse être appelé avec l'ID BlackJack-v0.

myenv/__init__.py Enregistrez BlackJackEnv avec gym en utilisant la fonction gym.envs.registration.register. Ici, nous déclarons que nous appellerons la classe BlackJackEnv sous le répertoire env sous le répertoire myenv avec l'ID BlackJack-v0.

myenv/__init__.py


from gym.envs.registration import register

register(
    id='BlackJack-v0',
    entry_point='myenv.env:BlackJackEnv',
)

myenv/env/__init__.py Ici, nous déclarons que la classe BlakcJackEnv est dans blackjack_env.py sous le répertoire env sous le répertoire myenv.

myenv/env/__init__.py


from myenv.env.blackjack_env import BlackJackEnv

Pour renforcer l'apprentissage

Dans le code d'entraînement, vous pouvez utiliser l'environnement en définissant ʻenv = gym.make ('BlackJack-v0') `.

Cette fois, l'enregistrement de l'environnement est le principal, je vais donc l'omettre, mais le prochain article le créera.

À la fin

J'ai enregistré mon propre jeu de blackjack dans l'environnement OpenAI Gym. J'ai réalisé que je devais réfléchir attentivement à ce qu'il fallait faire, à ce qu'il fallait observer en tant qu'état, à ce qu'il fallait récompenser et à l'endroit où passer d'une étape à l'environnement que j'avais créé. .. Au début, la longueur d'un pas était considérée comme ridiculement longue. .. ..

Ensuite, j'aimerais utiliser cet environnement pour apprendre la stratégie du Blackjack.

Sites / livres auxquels j'ai fait référence

Recommended Posts

Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (② Enregistrer l'environnement dans le gymnase)
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (③ Renforcer l'apprentissage dans votre propre environnement OpenAI Gym))
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage ((1) Implémentation du blackjack)
Essayez de créer un module Python en langage C
Les débutants en apprentissage automatique essaient de créer un arbre de décision
J'ai essayé de créer un environnement d'apprentissage amélioré pour Othello avec Open AI gym
Faisons un saut dans l'industrie manufacturière en utilisant le Web en plus de Python
Un mémorandum pour enregistrer la bibliothèque écrit en Hy dans PyPI
Combinez des listes dans un DataFrame avec des pandas
[Apprentissage de renforcement d'introduction] Renforcement de l'apprentissage pour bouger pour le moment
Essayez l'apprentissage Q dans une bataille de style Drakue [Introduction au renforcement de l'apprentissage]
Effectuer une analyse morphologique dans l'environnement d'apprentissage automatique lancé par GCE
Essayez Cython dans les plus brefs délais
Essayez de prédire le triplet de la course de bateaux en classant l'apprentissage
J'ai essayé de créer un système pour acquérir automatiquement le guide des programmes → l'enregistrer dans le calendrier en un jour
Ajout d'une fonction pour enregistrer les décalages souhaités dans la table des décalages Django
Un script qui enregistre l'adresse IP utilisée par wercker dans le groupe de sécurité
[Python] Essayez de créer vous-même un programme de tri. (Tri sélectif, tri par insertion, tri par bulle)
Comment trier en spécifiant une colonne dans le tableau Python Numpy.
Essayez de faire face à la somme partielle
Faisons un noyau jupyter
Utilisez Cloud Composer pour accéder régulièrement à l'API Youtube afin de créer un pipeline afin de stocker les résultats dans Bigquery
Même un nouvel ingénieur diplômé peut le faire! Conseils pour faire une différence dans la synchronisation en commentant
De rien sur Ubuntu 18.04 à la configuration d'un environnement Deep Learning sur Tensor
9 étapes pour devenir un expert en apprentissage automatique dans les plus brefs délais [Entièrement gratuit]
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur les données météorologiques (3)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (1)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (4)
Créez un environnement python pour apprendre la théorie et la mise en œuvre de l'apprentissage profond
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (2)
J'ai essayé de prédire l'évolution de la quantité de neige pendant 2 ans par apprentissage automatique
Instructions pour connecter Google Colab. À l'environnement d'exécution local dans un environnement Windows
Comment installer le framework d'apprentissage en profondeur Tensorflow 1.0 dans l'environnement Windows Anaconda
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Essayez de prédire la demande de puissance par l'apprentissage automatique
Utilisez le dernier pip dans un environnement virtualenv
Copiez la liste en Python
Essayez de créer un code de "décryptage" en Python
Définir une adresse IP fixe dans l'environnement Linux
L'explication la plus simple au monde sur la création de LINE BOT (2) [Préparation de l'application Bot dans un environnement local avec Django de Python]
Essayez de créer un groupe de dièdre avec Python
Essayez le livre «Introduction au développement d'applications de traitement du langage naturel en 15 étapes» --Chapitre 2 Étape 01 Mémo «Créer un agent de dialogue»
Faisons un outil de veille de commande avec python
Enregistrer une tâche dans cron pour la première fois
Je veux escalader une montagne avec l'apprentissage par renforcement
Essayez de charger l'image dans un thread séparé (OpenCV-Python)
Essayez de déchiffrer les données de connexion stockées dans Firefox
Notez ce que vous voulez faire à l'avenir avec Razpai
J'ai créé une classe pour obtenir le résultat de l'analyse par MeCab dans ndarray avec python
Comment créer un enregistrement en collant une relation au modèle source d'héritage dans le modèle hérité par Django
Je veux voir le graphique en 3D! Je peux réaliser un tel rêve.
Une histoire qui rend le débogage de modèle plus facile à voir dans l'environnement Django + SQLAlchemy