Comment gérer les mouvements invalides dans l'apprentissage par renforcement?

Je veux créer une IA qui peut jouer à cinq dans une rangée / gomoku. Comme je l'ai mentionné dans le titre, je veux utiliser l'apprentissage par renforcement pour cela.

J'utilise la méthode du gradient de politique , à savoir REINFORCE, avec la ligne de base. Pour l'approximation de la valeur et de la fonction politique, j'utilise un réseau neuronal . Il a des couches convolutives et entièrement connectées. Toutes les couches, à l'exception de la sortie, sont partagées. La couche de sortie de la stratégie a $8 \times 8=64$ (la taille de la carte) et un softmax sur eux. C'est donc stochastique. Mais que se passe-t-il si le réseau produit une probabilité très élevée pour un mouvement invalide? Un déplacement invalide se produit lorsque l'agent veut vérifier un carré contenant un "X" ou un "O". Je pense qu'il peut rester dans cet état de jeu.

Pourriez-vous recommander une solution à ce problème?

Ma conjecture est d'utiliser la méthode acteur-critique . Pour un coup invalide, nous devons donner une récompense négative et passer le tour à l'adversaire.

Ignorez simplement les mouvements invalides.

Pour l'exploration, il est probable que vous n'exécuterez pas simplement le mouvement avec la probabilité la plus élevée, mais que vous choisissiez plutôt des mouvements au hasard en fonction de la probabilité émise. Si vous ne punissez que des mouvements illégaux, ils conserveront une certaine probabilité (même faible) et seront donc exécutés de temps en temps (mais rarement). Ainsi, vous garderez toujours un agent qui effectue occasionnellement des mouvements illégaux.

Pour moi, il est plus logique de simplement mettre à zéro les probabilités de tous les mouvements illégaux et de renormaliser le vecteur de sortie avant de choisir votre mouvement.

Habituellement, les méthodes softmax dans les méthodes de gradient de politique utilisant une approximation de fonction linéaire utilisent la formule suivante pour calculer la probabilité de choisir l'action $a$ . Ici, les poids sont $\theta$ , et les caractéristiques $\phi$ est fonction de l'état actuel $s$ et une action de l'ensemble des actions $A$ .

$Legal(A)$

In pseudocode the formula may look like this:

action_probs = Agent.getActionProbs(state)
legal_actions = filterLegalActions(state, action_probs)
best_legal_action = softmax(legal_actions)

Whether using linear or non-linear function approximation (your neural network), the idea is to only use the legal moves when computing your softmax. This method means that only valid moves will be given by the agent, which is good if you wanted to change your game later on, and that the difference in value between the limited choice in actions will be easier to discriminate by the agent. It will also be faster as the number of possible actions decreases.

IMHO the idea of invalid moves is itself invalid. Imagine placing an "X" at coordinates (9, 9). You could consider it to be an invalid move and give it a negative reward. Absurd? Sure!

But in fact your invalid moves are just a relic of the representation (which itself is straightforward and fine). The best treatment of them is to exclude them completely from any computation.

This gets more apparent in chess:

• In a positional representation, you might consider the move a1-a8, which only belongs in the game if there's a Rook or a Queen at a1 (and some other conditions hold).

• In a different representation, you might consider the move Qb2. Again, this may or may not belong to the game. When the current player has no Queen, then it surely does not.

As the invalid moves are related to the representation rather than to the game, they should not be considered at all.

J'ai récemment rencontré un problème similaire avec Démineur.

J'ai résolu le problème en ignorant complètement les mouvements illégaux / invalides.

1. Use the Q-network to predict the Q-values for all of your actions (valid and invalid)
2. Pre-process the Q-values by setting all of the invalid moves to a Q-value of zero/negative number (depends on your scenario)
3. Use a policy of your choice to select an action from the refined Q-values (i.e. greedy or Boltzmann)
4. Execute the selected action and resume your DQN logic

Hope this helps.