20
$\begingroup$

I want to create an AI which can play five-in-a-row/gomoku. As I mentioned in the title, I want to use reinforcement learning for this.

I use policy gradient method, namely REINFORCE, with baseline. For the value and policy function approximation, I use a neural network. It has convolutional and fully connected layers. All of the layers, except for the output, are shared. The policy's output layer has $8 \times 8=64$ (the size of the board) output unit and softmax on them. So it is stochastic. But what if the network produces a very high probability for an invalid move? An invalid move is when the agent wants to check a square which has one "X" or "O" in it. I think it can stuck in that game state.

Could you recommend any solution for this problem?

My guess is to use the actor-critic method. For an invalid move, we should give a negative reward and pass the turn to the opponent.

$\endgroup$
10
$\begingroup$

Just ignore the invalid moves.

For exploration it is likely that you won't just execute the move with the highest probability, but instead choose moves randomly based on the outputted probability. If you only punish illegal moves they will still retain some probability (however small) and therefore will be executed from time to time (however seldom). So you will always retain an agent which occasionally makes illegal moves.

To me it makes more sense to just set the probabilities of all illegal moves to zero and renormalise the output vector before you choose your move.

$\endgroup$
  • $\begingroup$ Thank you. probably I wasn't clear but I chose the move randomly by the outputted probabilites. I will try your advice to set the probability of the illegal moves to zero and see what will hapen. Have a nice day. $\endgroup$ – Molnár István Mar 14 '17 at 17:03
8
$\begingroup$

Usually softmax methods in policy gradient methods using linear function approximation use the following formula to calculate the probability of choosing action $a$. Here, weights are $\theta$, and the features $\phi$ is a function of the current state $s$ and an action from the set of actions $A$.

$$ \pi(\theta, a) = \frac{e^{\theta \phi(s, a)}}{\sum_{b \in A} e^{\theta \phi(s, b)}} $$

To eliminate illegal moves, one would limit the set of actions to only those that were legal, hence $Legal(A)$.

$$ \pi(\theta, a) = \frac{e^{\theta \phi(s, a)}}{\sum_{b \in Legal(A)} e^{\theta \phi(s, b)}}, \, a \in 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.

$\endgroup$
  • $\begingroup$ Very useful. Thanks for posting both the equations and pseudocode! $\endgroup$ – DukeZhou Dec 22 '17 at 17:43
  • 1
    $\begingroup$ The maths and pseudocode do not match here. Softmax over the legal move probabilities will adjust the relative probabilities. E.g. (0.3, 0.4, 0.2, 0.1) filtered with first and third item removed would be (0.0, 0.8, 0.0, 0.2) with your formula, but would be (0.0, 0.57, 0.0, 0.42) using the pseudocode. The pseudocode needs to take the logits, prior to action probability calculations. $\endgroup$ – Neil Slater Mar 14 '18 at 16:09
  • 4
    $\begingroup$ How does one compute the gradient of the filtered version of Softmax? Seems like this would be necessary for backpropagation to work successfuly, yes? $\endgroup$ – brianberns Mar 22 '18 at 14:26
  • $\begingroup$ @brianberns Did you manage to find an answer? It seems like that would be the case to me but somehow in my toy example I'm only getting the right answer when using the log probabilities of the unfilitered softmax... $\endgroup$ – tryingtolearn Mar 11 at 13:04
5
$\begingroup$

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.

$\endgroup$
  • 1
    $\begingroup$ Great point. In [M] games, which are played on Sudoku, the constraints make many positions (coordinates+value) illegal after the first placement. There is no value in considering these illegal positions from the standpoint of placement, but, an important strategic layer is recognizing which placements minimize value of remaining, unplayed positions. (i.e. if I place an 8 here, it blocks my opponent from placing an 8 in that row, column or region. Essentially, "how many strategic positions does this placement remove from the gameboard?") $\endgroup$ – DukeZhou Jan 12 '18 at 18:08
5
$\begingroup$

I faced a similar issue recently with Minesweeper.

The way I solved it was by ignoring the illegal/invalid moves entirely.

  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.

$\endgroup$
  • 1
    $\begingroup$ About the only thing I would add to this is that you have to remember to do a backprop on the DQN when you set the Q values for illegal (s,a) pairs to large negative value so its trained to not pick those state,action pairs next time. $\endgroup$ – S.N. Dec 1 '18 at 20:48
  • $\begingroup$ But I do wonder what setting large -ve target Q values does to the continuity or shape of the loss/error function (thereby affecting the gradient search). What was your experience? $\endgroup$ – S.N. Dec 1 '18 at 22:10
  • 1
    $\begingroup$ @S.N. I see your point. The idea is to pick the action with the highest Q-value that is not an invalid action. Next, you execute that action and use that action in your update rule (i.e. train your DQN to favor this action in the long run). What this does is make the future Q-values of the selected action higher and thus more favorable. It will NOT make the illegal actions Q-value lower though, which doesn't matter because they are always filtered out (not considered). Let me know if you want me to elaborate more with an example. :) $\endgroup$ – Sanavesa Dec 6 '18 at 2:58
  • 1
    $\begingroup$ @Sanavesa sure makes sense, you're essentially counting on the DQN eventually learning what the correct choices are thru the school of hard knocks. But in situations where there's only one or a few legal choice you'll end up with very slow learning. The approach I'm suggesting is a way of incorporating domain K into the problem to speed up that learning. It also what I thought you were doing in your original post where you wrote of "setting invalid moves to a Q-value of zero/negative number" $\endgroup$ – S.N. Dec 8 '18 at 4:42
  • 1
    $\begingroup$ @S.N.Precisely! Both approaches have their merits. Depends on the application if its easier to learn the legal moves or just outright ignore them. For large complex applications, I feel ignoring the invalid moves is much faster for the agent to learn, but don't quote me on that. $\endgroup$ – Sanavesa Dec 8 '18 at 6:15

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.