J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Implémentation ~

Table des matières de la série

Dernière fois suite ... Dans ce domaine, moi, un étranger, je n'ai pas du tout étudié «la théorie de l'apprentissage automatique». Je vais faire l'IA d'Othello. Cliquez ici pour le site référencé

Bases de l'apprentissage par renforcement

J'ai fait l'IA d'Othello sans étudier du tout "la théorie de l'apprentissage automatique". Je résumerai les connaissances minimales requises pour la mettre en œuvre.

Structure du fichier et rôle

La structure et le rôle du fichier sont comme ça. 構成.png --train.py --- Formation AI --Reversi.py --- Gestion du jeu Othello --dqn_agent.py --- Gestion de la formation en IA --FightWithAI.py --- Bataille avec les utilisateurs

Algorithme global

L'algorithme DQN implémenté cette fois ressemble à ceci.

algorithm.png Si vous gardez ce flux à l'esprit, vous comprendrez de quoi vous parlez et ce que vous allez expliquer.

Spécifications du jeu Othello

Le plateau utilisé pour les jeux Othello et l'entraînement à l'IA Cela se fait en utilisant un tableau à deux dimensions avec Non dans la figure ci-dessous. screen.png

Reversi.py


self.screen[0~7][0~7]

L'opération que AI peut sélectionner est de sélectionner le nombre de 0 à 63 dans la figure ci-dessus.

Reversi.py


self.enable_actions[0~63]

Formation en IA

Dans l'entraînement à l'IA, les joueurs [0] et les joueurs [1] ont joué des batailles d'Othello n_epochs = 1000 fois. Enfin, sauvegardez l'IA du deuxième joueur [1].

Récompense pour l'IA

--Si vous gagnez le jeu, définissez la récompense = 1 --Autre que cela, récompense = 0

Méthode de formation

Je jouerai avec deux IA, mais je dois agir même au tour de l'adversaire Parce que l'histoire jusqu'à la fin n'est pas connectée (la valeur Q n'est pas transmise)

8151b82b-2d1a-7b02-4282-1e98a5a9a265.png

Les deux agissent à chaque tour Cette fois, j'ai décidé de "sauvegarder la transition en D" pour tous les nombres qui peuvent être réglés séparément de la progression du jeu.

train.py



#cibles contient tous les nombres que vous pouvez mettre ce tour
for tr in targets:
    #Dupliquer le statu quo
    tmp = copy.deepcopy(env)
    #action
    tmp.update(tr, playerID[i])
    #Fin du jugement
    win = tmp.winner()
    end = tmp.isEnd()
    #Conseil après avoir agi
    state_X = tmp.screen
    #Un numéro que vous pouvez laisser après avoir agi
    target_X = tmp.get_enables(playerID[i+1])
                       
    #Les deux actions
    for j in range(0, len(players)):
        reword = 0
        if end == True:
            if win == playerID[j]:
                #Obtenez 1 récompense si vous gagnez
                reword = 1
        #Les deux "Enregistrer la transition en D"
        players[j].store_experience(state, targets, tr, reword, state_X, target_X, end)
        players[j].experience_replay()

La partie suivante de l'algorithme DQN est réalisée par dqn_agent.py.

--Save transition to D (, ai, ri, si + 1, terminal)

Je ne sais pas pourquoi c'est tout un pakuri du site auquel je fais référence

dqn_agent.py


    def store_experience(self, state, targets, action, reward, state_1, targets_1, terminal):
        self.D.append((state, targets, action, reward, state_1, targets_1, terminal))
>>
    def experience_replay(self):
        state_minibatch = []
        y_minibatch = []
>>
        # sample random minibatch
        minibatch_size = min(len(self.D), self.minibatch_size)
        minibatch_indexes = np.random.randint(0, len(self.D), minibatch_size)
>>
        for j in minibatch_indexes:
            state_j, targets_j, action_j, reward_j, state_j_1, targets_j_1, terminal = self.D[j]
            action_j_index = self.enable_actions.index(action_j)
>>
            y_j = self.Q_values(state_j)
>>
            if terminal:
                y_j[action_j_index] = reward_j
            else:
                # reward_j + gamma * max_action' Q(state', action')
                qvalue, action = self.select_enable_action(state_j_1, targets_j_1)
                y_j[action_j_index] = reward_j + self.discount_factor * qvalue
>>
            state_minibatch.append(state_j)
            y_minibatch.append(y_j)
>>
        # training
        self.sess.run(self.training, feed_dict={self.x: state_minibatch, self.y_: y_minibatch})
>>
        # for log
        self.current_loss = self.sess.run(self.loss, feed_dict={self.x: state_minibatch, self.y_: y_minibatch})
>>
Nom de variable Contenu
state Surface de la planche( = Reversi.screen[0~7][0~7] )
targets Numéro que vous pouvez laisser
action Action sélectionnée
reward Récompense pour l'action 0-1
state_1 Conseil après avoir agi
targets_1 Un numéro que vous pouvez laisser après avoir agi
terminal Fin du jeu = Vrai

la mise en oeuvre

Dans l'entraînement à l'IA, les joueurs [0] et les joueurs [1] ont joué des batailles d'Othello n_epochs = 1000 fois. Enfin, sauvegardez l'IA du deuxième joueur [1].

train.py


   # parameters
    n_epochs = 1000
    # environment, agent
    env = Reversi()
 
    # playerID    
    playerID = [env.Black, env.White, env.Black]

    # player agent    
    players = []
    # player[0]= env.Black
    players.append(DQNAgent(env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols))
    # player[1]= env.White
    players.append(DQNAgent(env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols))

Cette partie DQNAgent (env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols) est

  • Initialiser la mémoire de relecture D --Q NetworkQ est initialisé avec un poids aléatoire θ --Initialiser le réseau cibleQ θ ^ = θ

, Dqn_agent.py le fait.

dqn_agent.py


class DQNAgent:
>>
    def __init__(self, enable_actions, environment_name, rows, cols):
        ...réduction...
        #Initialisation de la mémoire de relecture D
        self.D = deque(maxlen=self.replay_memory_size)
        ...réduction...
>>
    def init_model(self):
        # input layer (rows x cols)
        self.x = tf.placeholder(tf.float32, [None, self.rows, self.cols])
>>
        # flatten (rows x cols)
        size = self.rows * self.cols
        x_flat = tf.reshape(self.x, [-1, size])
>>
        #Initialiser Q NetworkQ avec un poids aléatoire θ
        W_fc1 = tf.Variable(tf.truncated_normal([size, size], stddev=0.01))
        b_fc1 = tf.Variable(tf.zeros([size]))
        h_fc1 = tf.nn.relu(tf.matmul(x_flat, W_fc1) + b_fc1)
>>
        #Initialiser le réseau cible Q θ^=θ
        W_out = tf.Variable(tf.truncated_normal([size, self.n_actions], stddev=0.01))
        b_out = tf.Variable(tf.zeros([self.n_actions]))
        self.y = tf.matmul(h_fc1, W_out) + b_out
>>
        # loss function
        self.y_ = tf.placeholder(tf.float32, [None, self.n_actions])
        self.loss = tf.reduce_mean(tf.square(self.y_ - self.y))
>>
        # train operation
        optimizer = tf.train.RMSPropOptimizer(self.learning_rate)
        self.training = optimizer.minimize(self.loss)
>>
        # saver
        self.saver = tf.train.Saver()
>>
        # session
        self.sess = tf.Session()
        self.sess.run(tf.initialize_all_variables())

python


    for e in range(n_epochs):
        # reset
        env.reset()
        terminal = False
  • for episode =1, M do

python


        while terminal == False: #Boucle jusqu'à la fin d'un épisode

            for i in range(0, len(players)): 
                
                state = env.screen
                targets = env.get_enables(playerID[i])
                
                if len(targets) > 0:
                    #S'il y a un endroit pour le mettre quelque part

#← Ici, toutes les mains mentionnées ci-dessus sont "sauvegardées en D"

                    #Choisissez une action
                    action = players[i].select_action(state, targets, players[i].exploration)
                    #Passer à l'action
                    env.update(action, playerID[i])
  • while not terminal --Sélection d'action

La sélection d'action ʻagent.select_action (state_t, cibles, agent.exploration) `est Ceci est fait par dqn_agent.py.

  • Sélection des actions

dqn_agent.py


    def Q_values(self, state):
        # Q(state, action) of all actions
        return self.sess.run(self.y, feed_dict={self.x: [state]})[0]
>>
    def select_action(self, state, targets, epsilon):
>>    
        if np.random.rand() <= epsilon:
            # random
            return np.random.choice(targets)
        else:
            # max_action Q(state, action)
            qvalue, action = self.select_enable_action(state, targets)
            return action
>>  
    #Le tableau(state)alors,Endroit pour mettre(targets)Renvoie la valeur Q et le nombre qui maximise la valeur Q de
    def select_enable_action(self, state, targets):
        Qs = self.Q_values(state)
        #descend = np.sort(Qs)
        index = np.argsort(Qs)
        for action in reversed(index):
            if action in targets:
                break 
        # max_action Q(state, action)
        qvalue = Qs[action]       
>>
        return qvalue, action          

-Exécuter l'action ai et observer la récompense ri, l'écran suivant xi + 1 et terminer le jugement tarminal --Pré-traiter et créer l'état suivant si + 1

Enfin, enregistrez cette dernière IA



                #Le résultat de l'exécution de l'action
                terminal = env.isEnd()     
                              
        w = env.winner()                    
        print("EPOCH: {:03d}/{:03d} | WIN: player{:1d}".format(
                         e, n_epochs, w))


    #Enregistrer sauve le deuxième joueur player2.
    players[1].save_model()

La source est ici. $ git clone https://github.com/sasaco/tf-dqn-reversi.git

La prochaine fois vous parlera de l'édition de combat.

Recommended Posts

J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Implémentation ~
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Introduction ~
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Battle Edition ~
[Apprentissage automatique] J'ai essayé de résumer la théorie d'Adaboost
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé de faire quelque chose comme un chatbot avec le modèle Seq2Seq de TensorFlow
J'ai essayé de faire d'Othello AI que j'ai appris 7,2 millions de mains par apprentissage profond avec Chainer
(Apprentissage automatique) J'ai essayé de comprendre attentivement la régression linéaire bayésienne avec l'implémentation
J'ai essayé de visualiser le modèle avec la bibliothèque d'apprentissage automatique low-code "PyCaret"
(Apprentissage automatique) J'ai essayé de comprendre attentivement l'algorithme EM dans la distribution gaussienne mixte avec l'implémentation.
J'ai essayé de prédire la présence ou l'absence de neige par apprentissage automatique.
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
J'ai essayé de compresser l'image en utilisant l'apprentissage automatique
J'ai essayé de comprendre attentivement la fonction d'apprentissage dans le réseau de neurones sans utiliser la bibliothèque d'apprentissage automatique (première moitié)
J'ai essayé de faire une simulation de séparation de source sonore en temps réel avec l'apprentissage automatique Python
J'ai essayé de créer un environnement d'apprentissage amélioré pour Othello avec Open AI gym
J'ai essayé de trouver l'entropie de l'image avec python
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai essayé l'apprentissage automatique avec liblinear
J'ai essayé de comparer la précision des modèles d'apprentissage automatique en utilisant kaggle comme thème.
J'ai essayé de vérifier la classification yin et yang des membres hololive par apprentissage automatique
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
J'ai essayé de bien le comprendre en implémentant l'algorithme Adaboost en machine learning (+ j'ai approfondi ma compréhension du calcul de tableaux)
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker
J'ai essayé d'agrandir la taille du volume logique avec LVM
J'ai essayé de résumer la méthode de mise en œuvre fréquemment utilisée de pytest-mock
J'ai essayé de créer un mécanisme de contrôle exclusif avec Go
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé de transformer l'image du visage en utilisant sparse_image_warp de TensorFlow Addons
J'ai essayé d'appeler l'API de prédiction du modèle d'apprentissage automatique de WordPress
J'ai essayé d'obtenir le code d'authentification de l'API Qiita avec Python.
J'ai essayé d'extraire automatiquement les mouvements des joueurs Wiire avec un logiciel
J'ai essayé d'analyser la négativité de Nono Morikubo. [Comparer avec Posipa]
J'ai essayé de rationaliser le rôle standard des nouveaux employés avec Python
J'ai essayé de visualiser le texte du roman "Weather Child" avec Word Cloud
Signifie mémo lorsque vous essayez de faire de l'apprentissage automatique avec 50 images
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
J'ai essayé de prédire le comportement du nouveau virus corona avec le modèle SEIR.
J'ai essayé de comprendre attentivement la fonction d'apprentissage dans le réseau de neurones sans utiliser la bibliothèque d'apprentissage automatique (deuxième moitié)
J'ai essayé de prédire l'année prochaine avec l'IA
J'ai essayé de sauvegarder les données avec discorde
J'ai essayé de corriger la forme trapézoïdale de l'image
J'ai essayé de faire de l'IA pour Smash Bra
J'ai essayé de vectoriser les paroles de Hinatazaka 46!
J'ai essayé d'organiser les index d'évaluation utilisés en machine learning (modèle de régression)
J'ai fait une application d'envoi de courrier simple avec tkinter de Python
[Analyse des brevets] J'ai essayé de créer une carte des brevets avec Python sans dépenser d'argent
Un débutant en apprentissage automatique a essayé de créer un modèle de prédiction de courses de chevaux avec python
J'ai essayé de visualiser facilement les tweets de JAWS DAYS 2017 avec Python + ELK
[Python] J'ai expliqué en détail la théorie et l'implémentation de la machine à vecteurs de support (SVM).
J'ai couru le tutoriel TensorFlow avec des commentaires (classification du texte des critiques de films)
J'ai essayé la détection d'objets avec YOLO v3 (TensorFlow 2.1) sur le GPU de windows!
J'ai essayé de prédire l'évolution de la quantité de neige pendant 2 ans par apprentissage automatique
Je n'ai pas compris le redimensionnement de TensorFlow, alors je l'ai résumé visuellement.
L'histoire de la fabrication de soracom_exporter (j'ai essayé de surveiller SORACOM Air avec Prometheus)
J'ai essayé de créer une API de reconnaissance d'image simple avec Fast API et Tensorflow
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker 2 Multi-host edition