Comments/Ratings for a Single Item

By the way, details about programming are not clear for most people. How to deal with it?

I don't think there is any "fix" to this issue.  I am not sure there is any issue at all.  Some conversations are going to involve things other people don't understand.  That said, the talkchess forums are the usual place for these kinds of discussions, but I am happy to have some discussion here as well.  Some people who are not chess programmers may still be interested in whether the new neural-network techniques being applied to orthodox chess can be applied to chess variants.

I did not meant the typo!

What is not understandable? Typo! What else.
By the way, details about programming are not clear for most people. How to deal with it?

I'm not sure I understand what you say, HG!

Indeed. Hard to avoid typos on these virtual keyboards of Android devices... I corrected it.

I do not understand "tgat". You probably meant that.

That describes the 'policy head' of the NN, which is used to bias the move choice (which is otherwise based  on the number of visits of the move and that of the total for the node, and the move scores) when walking the tree from root to leaf for finding the next  leaf to expand. But my understanding was that when the leaf is chosen and expanded, all daughters should receive a score from the 'evaluation head' of the NN in the position after the move, rather than just inheriting their policy weight from the position before the move. These scores are then back-propagated towards the root, by including them in the average score of all nodes in the path to the expanded leaf.

The NN outputs a probability distribution over all the possible moves (illegal moves are set to 0 and the probabilities sum to 1). The MTCS call for this distribution, combine it with an exploration coefficient and Dirichlet noise, to form a score, and choses a move to expand until a certain number (in chess is 6000) of nodes have been visited. Nodes are expanded until leaf nodes are explored. This link explains it better than I:

https://joshvarty.github.io/AlphaZero/

I thought AlphaZero used the output of its NN for evaluating leaf nodes. That makes it different from 'normal' MCTS, which would randomly play out games until they satisfy a win or draw condition, and uses the statistics of such 'rollouts' as a measure for the winning probability in the leaf.

Thanks Greg, My conundrum comes from the definition of leaf nodes. In the traditional way you apply the evaluation function, but in the MCTS of Alpha zero are only when the endgame conditions apply.

A quick overview for those who are interested ... A traditional Chess program has 3 parts:

Move Generation - Given a position, find all legal moves for the side on the move.

Search - Recursively play out moves and counter-moves to find the best sequence (called the PV or Principal Variation.)

Evaluation - At the leaf nodes on the end of each search path, evaluate the position. This function returns a number - the more positive, the better for player 1, the more negative, the better for player 2.

Chess variants. To program a chess variant, you definitely need to change Move Generation. You probably also need to change the Evaluation function. If nothing else, at least give material values to the new piece types. This is the most pronounced of all the evaluation terms. But other things may need to be altered -- for example, pawn structure is important, but should not apply to Berolina Chess.

The Search is typically extended by something called a Quiescent Search. The Evaluation function cannot reliably detect pins, forks, hanging material, etc., which would all affect the evaluation a lot. So, the Evaluation function can only be used on "quiet" ("quiescent") positions. So after the search function searches all legal moves to the desired depth, it then hands off to Quiescent Search, which continues searching recursively, but searches only captures (and, in some programs, checking moves too, but this isn't common in chess variant engines.) This way, all exchanges in progress are played out and hanging pieces are captured before the position is evaluated.

So, with that background on Quiescent Search ... Remember how I said the Search function doesn't need to change for different variants? Well, that's not entirely true. For some variants, like Shogi (or other variants with drops), or double-move variants, there are no "quiet" positions. So traditional Quiescent Search doesn't work. Other approaches must be taken. ChessV doesn't modify the Search function for different variants at all. That's why it doesn't play Shogi. It does play Marseillais Chess, but I haven't modified the Search, I'm basically just sweeping the issues under the rug... I don't know how Zillions-of-Games works for certain, but I believe it has no Quiescent Search function at all. It modifies the Move Generator to support different games, but there is no variant-specific Search or Evaluation.

ChessV handles the Evaluation by building it from various elements that can be turned on, off, or configured. (Pawn structure, king safety, outposts, colorbinding, open file bonuses, castling rights, etc.) You can find out basically everything ChessV does for every game it plays by looking at the Game Reference: http://www.chessv.org/reference/games/

Well, it is a bit more subtle than that, because you would not know what line B leads to without searching it first. And after you have done that, it is too late to prune it. So what really happens if that after you have found the single reply to the first move of line B that leaves you stuck with the doubled Pawns, you consider the first move of B refuted, and you prune the remaining replies to it.

But you are right in the sense that positional characteristics can also be sufficient reason to reject a move. This is purely a matter of evaluation, though. Whatever search method you would use, it should in the end give you the line to the position with the best evaluation that you can force (the 'principle variation'). If there is no mate in view the evaluation of positions must be based on heuristics. Piece values are one such heuristic. In general one should base the evaluation only on features that are not easily changed. Otherwise it would be pretty meaningless, as you know the game must go on from there (even though it is beyond your capability to take into account what will happen then), and if the feature would in general not persist after the next move it is pointless to optimize it. But next to material composition pawn structure is definitely a persistent feature (with FIDE or Shatranj Pawns!). King safety as well, when the King is a slowly moving piece.

What you will have to consider in evaluation can indeed depend very much on the rules of the variant. Using a neural network for evaluation (as both AlphaZero and NNUE do) and training that on positions from games is a method to avoid having to think about that yourself; you hope the NN is clever enough to recognize the important features, and quantify their importance. Whether this leads to different pruning in alpha-beta search is of no importance; this kind of pruning is guaranteed to have no effect on the principal variation that will be found. With or without pruning this would be the same. The pruning is just an optimization to get that same result, which was fully specified by the evaluation of the tree leaves, without wasting time on lines that neither of the players would want to play.

From conventional chess engines it is known that pawns on the forelast rank, and king safety can have values comparable to the material value of a minor.

Hi H.G.

My memory/understanding may be off, but I thought if for a chess engine line A is at least = and line B results in doubled isolated pawns without compensation, then line B would be pruned out. It's not due to material loss (e.g. a pawn for nothing) but rather due to chess-specific knowledge (that doubled isolated pawns are bad if not compensated for). I could imagine a CV where the opposite might be true, depending on the rules of movement or topology of the board, i.e. where doubled pawns might be good (e.g. in a game of Berolina's Pawns).

The only moves that are pruned in an alpha-beta search are those whose score could not possibly affect the move choice at the root, because they are in a branch that has already been refuted. E.g. if you find that in a position that is at least equal (i.e. you have already searched a move that does not lose anything), and an alternative move has a reply that loses a pawn without compensation, you would consider that alternative move refuted. It would be a waste of time to continue searching other replies to the move, in order to determine whether these make you lose even more. Because losing a Pawn is already bad enough to dissuade you from playing that alternative move.

This is purely determined from the scores of the moves; you don't need any variant-specific knowledge for it.

Ok, HG, I could have misconstrued something. But from what I understand I'd have to cut some moves while doing the alpha beta search. For example, after a certain number of plies. And then do the classification learning. Have you said something else? Anyway, I was saying that I can use handcrafted features at input to the neural network.

What pruning? Alpha-beta search only prunes after a beta cutoff, and this does not require any knowledge about the variant.

I meant the pruning!

What do you mean? Alpha-beta search is always the same, no matter what variant it is used for. It does not even have to be a chess variant. As long as it is a deterministic 2-player game with perfect information it should work the same.

Actually, when programming a new game it is not easy to do alpha beta search. I was thinking to add some positional features (like moving the central pawns) to the input of the neural network. This should speed thinks up a bit.

A NNUE with an alpha-beta search is fine: Stockfish 15 is stronger than any other chess player in the world, either human or computer.

The main thing that is interesting with Alpha Zero is that it can play a super human game of chess with no human chess knowledge except the game's rules. So, for example, any opening or midgame strategy is has is not based on human play.

@HG, Thanks for not discouraging me. That matters a lot, thrust me. I'll then slowly train weak bots but stronger every time. Maybe in time hardware will become available. And also, who knows, better software ideas. Good luck!

Indeed such questions are more suitable for talkchess.com.

But the fact that the AlphaZero NN also has a 'policy head' next to the evaluation is not the largest difference. IIRC this is only a matter of the final layer, which calculates a preference for each possible move in the same way as the score of the position is calculated. (I.e. each move output is fully connected to the previous layer.)

The main difference is the size. The AlphaZero net is so large that even using a Google TPU or a fast GPU to calculate it slows down the engine by a factor 100-1000, in terms of positions/sec searched. The NNUE only slows the engine by a modest factor, even on a CPU, because it is so small.

@HG,

Yes, in my previous comment I was referring to the difference between neural net and the NNUE approach. Alpha Zero's neural net has 2 parts. A CNN feature extraction part and a fully connected classification part. In the NNUE, from what I understand, you keep only the second part. I have said that I did not fully understand how the CNN part works. I'm not sure what filters it uses. But I do not think this is a question for here anyway.

You will be already 5000 times slower by the fact alone that Google used 5000 servers, (if I recall correctly), and you only have a single PC. And each Google server contained 4 TPU boards, each capable of performing 256 (or was it 1024) multiplications per clock cycle, while a single core in a PC can do only 8. So I think you are way too optimistic.

I am not sure what your latest comment refers to. If it is the difference between AlphaZero and NNUE: the main point there is that the NNUE net uses 5 layers of 32 cells, plus an initial layer that can be calculated incrementally, (so that the size matters little). While the AlphaZero net typically has 32 layers of 8 x 8 x 256 cells.

I don't want to discourage you, but the task you want to tackle is gigantic, and not very suitable as an introductory exercise in chess programming. A faster approach would be to start with something simple (at the level of Fairy-Max or King Slayer, simple alpha-beta searchers with a hand-crafted evaluation) to get some experience with programming search, then replace its evaluation by NNUE, to get some experience programming neural nets. The experience you gain in the simpler preliminary tasks will speed up your progress on the more complex final goal by more than the simple tasks take. Also note that you will have the disadvantage compared to people who do this for orthodox chess of not having high-quality games available to train the networks.