Construire un agent d'échecs à l'aide de DQN

J'ai récemment essayé d'implémenter un agent d'échecs basé sur DQN.

Maintenant, quiconque sait comment fonctionnent les DQN et les échecs vous dira que c'est une idée stupide.

Et... ça l'était, mais en tant que débutant, j'ai néanmoins apprécié. Dans cet article, je partagerai les informations que j'ai apprises en travaillant là-dessus.

---

Comprendre l'environnement.

Avant de commencer à implémenter l'agent lui-même, j'ai dû me familiariser avec l'environnement que j'utiliserai et créer un wrapper personnalisé par-dessus afin qu'il puisse interagir avec l'agent pendant la formation.

• J'ai utilisé l'environnement d'échecs de la bibliothèque kaggle_environments.
  
  

   from kaggle_environments import make
   env = make("chess", debug=True)
  

• J'ai également utilisé Chessnut, qui est une bibliothèque Python légère qui permet d'analyser et de valider les jeux d'échecs.
  
  

   from Chessnut import Game
   initial_fen = env.state[0]['observation']['board']
   game=Game(env.state[0]['observation']['board'])
  

Dans cet environnement, l'état de la carte est stocké au format FEN.

Il fournit un moyen compact de représenter toutes les pièces du plateau et le joueur actuellement actif. Cependant, comme j'avais prévu d'alimenter l'entrée d'un réseau de neurones, j'ai dû modifier la représentation de l'état.

---

Conversion de FEN au format Matrix

Comme il y a 12 types de pièces différents sur un plateau, j'ai créé 12 canaux de grilles 8x8 pour représenter l'état de chacun de ces types sur le plateau.

---

Créer un emballage pour l'environnement

class EnvCust:
    def __init__(self):
        self.env = make("chess", debug=True)
        self.game=Game(env.state[0]['observation']['board'])
        print(self.env.state[0]['observation']['board'])
        self.action_space=game.get_moves();
        self.obs_space=(self.env.state[0]['observation']['board'])

    def get_action(self):
        return Game(self.env.state[0]['observation']['board']).get_moves();


    def get_obs_space(self):
        return fen_to_board(self.env.state[0]['observation']['board'])

    def step(self,action):
        reward=0
        g=Game(self.env.state[0]['observation']['board']);
        if(g.board.get_piece(Game.xy2i(action[2:4]))=='q'):
            reward=7
        elif g.board.get_piece(Game.xy2i(action[2:4]))=='n' or g.board.get_piece(Game.xy2i(action[2:4]))=='b' or g.board.get_piece(Game.xy2i(action[2:4]))=='r':
            reward=4
        elif g.board.get_piece(Game.xy2i(action[2:4]))=='P':
            reward=2
        g=Game(self.env.state[0]['observation']['board']);
        g.apply_move(action)
        done=False
        if(g.status==2):
            done=True
            reward=10
        elif g.status == 1:  
            done = True
            reward = -5 
        self.env.step([action,'None'])
        self.action_space=list(self.get_action())
        if(self.action_space==[]):
            done=True
        else:
            self.env.step(['None',random.choice(self.action_space)])
            g=Game(self.env.state[0]['observation']['board']);
            if g.status==2:
                reward=-10
                done=True

        self.action_space=list(self.get_action())
        return self.env.state[0]['observation']['board'],reward,done

Le but de ce wrapper était de fournir une politique de récompense pour l'agent et une fonction étape qui est utilisée pour interagir avec l'environnement pendant la formation.

Chessnut était utile pour obtenir des informations telles que les mouvements légaux possibles dans l'état actuel du plateau et également pour reconnaître Checkmates pendant la partie.

J'ai essayé de créer une politique de récompense pour donner des points positifs pour les échecs et mats et l'élimination des pièces ennemies tandis que des points négatifs pour la perte de la partie.

---

Création d'un tampon de relecture

Le tampon de relecture est utilisé pendant la période d'entraînement pour enregistrer la sortie (état, action, récompense, état suivant) du réseau Q et est ensuite utilisé de manière aléatoire pour la rétropropagation du réseau cible

---

Fonctions auxiliaires

Chessnut renvoie une action en justice au format UCI qui ressemble à « a2a3 », mais pour interagir avec le réseau neuronal, j'ai converti chaque action en un index distinct en utilisant un modèle de base. Il y a un total de 64 carrés, j'ai donc décidé d'avoir 64*64 index uniques pour chaque mouvement.
Je sais que tous les mouvements 64*64 ne seraient pas légaux, mais je pouvais gérer la légalité en utilisant Chessnut et le modèle était assez simple.

---

Structure du réseau neuronal

 from kaggle_environments import make
 env = make("chess", debug=True)

Ce réseau neuronal utilise les couches convolutives pour prendre en compte l'entrée à 12 canaux et utilise également les index d'action valides pour filtrer la prédiction de sortie de récompense.

---

Implémentation de l'agent

 from Chessnut import Game
 initial_fen = env.state[0]['observation']['board']
 game=Game(env.state[0]['observation']['board'])

Il s'agissait évidemment d'un modèle très basique qui n'avait aucune chance de bien fonctionner (et ce n'est pas le cas), mais cela m'a aidé à comprendre un peu mieux comment fonctionnent les DQN.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!