Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (③ Renforcer l'apprentissage dans votre propre environnement OpenAI Gym))

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
  3. Apprenez la stratégie du Blackjack avec l'apprentissage par renforcement ← Cette fois ici

Environnement de développement

Apprentissage par renforcement de codage

Cette fois, nous utiliserons Q-Learning, qui est l'un des algorithmes d'apprentissage par renforcement de base.

organisation des fichiers

La structure des fichiers est la suivante. Le code pour renforcer l'apprentissage créé cette fois est "q-learning_blackjack.py". D'autres fichiers sont créés en tant que «S'enregistrer dans l'environnement de gym OpenAI».

├─ q-learning_blackjack.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

codage

Classe d'agent

self.Q devient un tableau qui résume les valeurs Q et est mis à jour à mesure que l'apprentissage progresse. C'est ce qu'on appelle la table Q ici. Dans le tableau Q, pour ** statut (Player points, Dealer points, Player possed Ace, Player has been hit) **, Player ** Stand **, ** Hit ** ， ** Double Down ** ， ** Surrender ** Représente la valeur lorsque l'action est entreprise.

ex_Qtable.png

La méthode de politique sélectionne les actions selon la méthode ε-gourmande. Sélectionnez au hasard une action avec la probabilité «epsilon», et sélectionnez une action selon la table Q avec la probabilité «1-epsilon».

Classe d'agent


class Agent():
    def __init__(self, epsilon):
        self.Q = {}
        self.epsilon = epsilon
        self.reward_log = []

    def policy(self, state, actions):
        if np.random.random() < self.epsilon:
            return np.random.randint(len(actions))
        else:
            if state in self.Q and sum(self.Q[state]) != 0:
                return np.argmax(self.Q[state])
            else:
                return np.random.randint(len(actions))

    def init_log(self):
        self.reward_log = []

    def log(self, reward):
        self.reward_log.append(reward)

    def show_reward_log(self, interval=100, episode=-1):
        if episode > 0:
            rewards = self.reward_log[-interval:]
            mean = np.round(np.mean(rewards), 3)
            std = np.round(np.std(rewards), 3)
            print("At Episode {} average reward is {} (+/-{}).".format(episode, mean, std))
        else:
            indices = list(range(0, len(self.reward_log), interval))
            means = []
            stds = []
            for i in indices:
                rewards = self.reward_log[i:(i + interval)]
                means.append(np.mean(rewards))
                stds.append(np.std(rewards))
            means = np.array(means)
            stds = np.array(stds)
            plt.figure()
            plt.title("Reward History")
            plt.xlabel("episode")
            plt.ylabel("reward")
            plt.grid()
            plt.fill_between(indices, means - stds, means + stds, alpha=0.2, color="g")
            plt.plot(indices, means, "o-", color="g", label="Rewards for each {} episode".format(interval))
            plt.legend(loc="best")
            plt.savefig("Reward_History.png ")
            plt.show()

Classe QLearningAgent

Il hérite de la classe Agent créée ci-dessus. La méthode d'apprentissage est la principale méthode d'apprentissage. Un épisode équivaut à un jeu de blackjack. ʻA = self.policy (s, actions) sélectionne une action en fonction de l'état, et n_state, récompense, done, info = env.step (a) `montre le résultat de cette action. Observez la récompense. La fonction step est telle qu'implémentée dans "S'enregistrer dans l'environnement de gym OpenAI".

Les trois lignes de code suivantes sont la formule Q-Learning

Q(s_t, a_t)\leftarrow(1-\alpha)Q(s_t, a_t)+\alpha(r_{t+1}+\gamma \max_{a_{t+1}}Q(s_{t+1}, a_{t+1}))

Correspond à. $ \ Gamma $ (gamma) est le paramètre de combien la valeur future est actualisée au taux d'actualisation, $ \ alpha $ ( learning_rate) est le taux d'apprentissage et à quelle vitesse la valeur Q est mise à jour. C'est un paramètre à contrôler.

Q-Formule d'apprentissage


gain = reward + gamma * max(self.Q[n_state])
estimated = self.Q[s][a]
self.Q[s][a] += learning_rate * (gain - estimated)

Classe QLearningAgent


class QLearningAgent(Agent):
    def __init__(self, epsilon=0.1):
        super().__init__(epsilon)

    def learn(self, env, episode_count=1000, gamma=0.9,
              learning_rate=0.1, render=False, report_interval=5000):
        self.init_log()
        actions = list(range(env.action_space.n))
        self.Q = defaultdict(lambda: [0] * len(actions))
        for e in range(episode_count):
            s = env.reset()
            done = False
            reward_history = []
            while not done:
                if render:
                    env.render()
                a = self.policy(s, actions)
                n_state, reward, done, info = env.step(a)

                reward_history.append(reward)
                gain = reward + gamma * max(self.Q[n_state])
                estimated = self.Q[s][a]
                self.Q[s][a] += learning_rate * (gain - estimated)
                s = n_state
            else:
                self.log(sum(reward_history))

            if e != 0 and e % report_interval == 0:
                self.show_reward_log(episode=e, interval=50)
        env.close()

fonction de train

Chargez votre propre environnement de blackjack avec ʻenv = gym.make ('BlackJack-v0') `.

Pour la méthode de création, reportez-vous à Blackjack implementation et Register in OpenAI gym environment. S'il vous plaît.

J'ai créé une méthode save_Q pour enregistrer la table de valeurs Q et une méthode show_reward_log pour afficher l'historique du journal des récompenses.

fonction de train et partie d'exécution


def train():
    agent = QLearningAgent()
    env = gym.make('BlackJack-v0')
    agent.learn(env, episode_count=50000, report_interval=1000)
    agent.save_Q()
    agent.show_reward_log(interval=500)

if __name__ == "__main__":
    train()

Résultat d'apprentissage

Les résultats d'apprentissage sont les suivants. L'axe horizontal est l'épisode et l'axe vertical est la récompense. La ligne verte est la récompense moyenne pour 500 épisodes et le remplissage vert est l'écart type de la récompense pour 500 épisodes. Il a été presque plat depuis l'épisode de 20000. Et je suis triste que la récompense moyenne soit inférieure à 0, même au moment de l'apprentissage de 50 000 épisodes. .. ..

Reward_History_epi50000.png

Comparaison avec la stratégie de base

Comparez la table Q apprise avec la stratégie de base. Extrayez l'action qui maximise la valeur Q pour chaque état de la table Q et créez une table de stratégie pour chaque main dure et main douce de la même manière que la stratégie de base.

La colonne de gauche est la stratégie apprise dans Q-Learning, et la colonne de droite est la stratégie de base. La rangée supérieure est une main dure (quand A n'est pas inclus dans la main), et la rangée inférieure est une main douce (quand A est inclus dans la main). Les lignes de chaque tableau représentent les points Player et les colonnes représentent les points Dealer. Les alphabets du tableau représentent les actions que le joueur doit entreprendre.

La fonction de partage n'est pas implémentée dans ce blackjack auto-fabriqué. Par conséquent, les actions sont attribuées même lorsque le joueur à main dure a 4 points (2, 2) et que le joueur à main douce a 12 points (A, A).

strategy_table.png

En comparant les résultats appris avec la stratégie de base, la tendance de Hit lorsque le point du joueur est bas et de Stay lorsque le point du joueur est élevé sont les mêmes. J'aimerais que vous appreniez au moins ce domaine. Cependant, si vous regardez les détails, le joueur à main douce a tendance à frapper à 19 points. Même si vous le frappez, ce ne sera pas Bust, mais si vous restez silencieux, c'est un mouvement fort. C'est là que je n'ai pas bien appris. Pourquoi. .. .. De plus, il y a moins de Double Down et plus de Surrender. On voit qu'il y a une tendance à prendre des risques et à minimiser les pertes.

Je l'ai joué

J'ai essayé de jouer 100 parties x 1000 fois en fonction de la table Q apprise et de la stratégie de base. Nous parions 100 $ sur chaque jeu et calculons le nombre moyen de jetons gagnés pour 100 jeux 1000 fois. La figure ci-dessous montre l'histogramme des puces d'acquisition moyennes.

Reward_Histogram_Basic_Q.png

Plus la partie droite de la figure est répartie, meilleurs sont les résultats, mais la stratégie de base donne de meilleurs résultats. À propos, la valeur moyenne basée sur la table Q était de \ $ -8,2 et la valeur moyenne basée sur la stratégie de base était de \ $ -3,2. Bien sûr, le cas d'un jeton gagné moyen élevé était une stratégie de base, mais le cas d'un jeton gagné moyen faible était également une stratégie de base. La stratégie de base a une distribution plus large. La distribution de la table Q est plus étroite, probablement parce qu'il y a moins de doubles down et plus de rachats.

en conclusion

En trois étapes, j'ai créé mon propre environnement de blackjack et essayé de renforcer et d'apprendre la stratégie. En conséquence, je n'ai pas obtenu de résultats dépassant la stratégie de base, mais j'ai pu approfondir ma compréhension de l'apprentissage par renforcement et de la programmation. Il y a encore place à l'amélioration dans l'apprentissage. Depuis que j'ai créé mon propre environnement, je peux également observer les valeurs attendues des cartes qui sortent des decks restants. C'est un peu bâclé, mais j'aimerais expérimenter. (Bien sûr, il ne peut pas être utilisé dans les casinos ...)

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

Recommended Posts

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 (② Enregistrer l'environnement dans le gymnase)
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage ((1) Implémentation du blackjack)
Essayez de créer votre propre AWS-SDK avec bash
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
Apprentissage par renforcement dans les plus brefs délais avec Keras avec OpenAI Gym
Essayez l'apprentissage Q dans une bataille de style Drakue [Introduction au renforcement de l'apprentissage]
Introduction au Deep Learning (2) - Essayez votre propre régression non linéaire avec Chainer-
[Renforcer l'apprentissage] Comment dessiner OpenAI Gym sur Google Corab (version 2020.6)
[Python] Essayez de créer vous-même un programme de tri. (Tri sélectif, tri par insertion, tri par bulle)
[Renforcer l'apprentissage] DQN avec votre propre bibliothèque
Faisons un noyau jupyter
Créez votre propre PC pour un apprentissage en profondeur
Renforcer l'apprentissage 11 Essayez OpenAI acrobot avec ChainerRL.
De rien sur Ubuntu 18.04 à la configuration d'un environnement Deep Learning sur Tensor
Essayez de dessiner un "front de type carte météorologique" par apprentissage automatique basé sur des données météorologiques (5)
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)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (2)
[Apprentissage automatique] Créez un modèle d'apprentissage automatique en effectuant un apprentissage par transfert avec votre propre ensemble de données
Calculons en fait le problème statistique avec Python
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Essayez de prédire la demande de puissance par l'apprentissage automatique
Essayez de créer un code de "décryptage" en Python
Essayez de créer un groupe de dièdre avec Python
Utilisez un GPU gratuit dans votre environnement préféré
Faisons un saut dans l'industrie manufacturière en utilisant le Web en plus de Python
Comment utiliser Docker pour conteneuriser votre application et comment utiliser Docker Compose pour exécuter votre application dans un environnement de développement