leela-zero VS alpha-zero-boosted

https://github.com/leela-zero/leela-zero but it is not user friendly imo

Yeah, see https://github.com/leela-zero/leela-zero/pull/883 for the discussions near the origin of this idea, which Leela Zero was the first to use many years ago. KataGo's implementation is a bit different in minor ways, but still based on the same mathematical idea. https://github.com/lightvector/KataGo/blob/master/cpp/search/searchhelpers.cpp#L482

Totally agree. I don't even know what benefit they'd get at this point from keeping some parts locked up.

Anyway if you want something runnable Leela has a nice reimplementation: https://github.com/leela-zero/leela-zero

See https://github.com/leela-zero/leela-zero/issues/2445 for an example with Leela Zero failing to see an atari, even *with* tons of search. This is a similar issue - neural nets have a hard time perceiving things that depend sensitively on large areas when unusual shapes are involved.

(https://github.com/leela-zero/leela-zero/issues/2273)

I think it's Leela https://github.com/leela-zero/leela-zero

There is Leela Zero

Yeah, it looks like I need to recompile Leela Zero with a 9x9 board size? https://github.com/leela-zero/leela-zero/pull/928 (and https://github.com/leela-zero/leela-zero/issues/2613)

> I came up with a nifty implementation in Python that outperforms the naive impl by 30x, allowing a pure python MCTS/NN interop implementation. See https://www.moderndescartes.com/essays/deep_dive_mcts/

Great post!

Chasing pointers in the MCTS tree is definitely a slow approach. Although typically there are < 900 "considerations" per move for alphazero. I've found getting value/policy predictions from a neural network (or GBDT[1]) for the node expansions during those considerations is at least an order of magnitude slower than the MCTS tree-hopping logic.

[1] https://github.com/cgreer/alpha-zero-boosted

What you can do is checkout the algorithm at a particular stages of development. AlphaZero&Friends start out not being very good at the game, then over time they learn and become super human. You typically checkpoint the weights for the model at various stages. So early on, the algo would be like a 600 elo player for chess and then eventually get to superhuman elo levels. So if you wanted to train you can gradually play against versions of the algo until you can beat them by loading up the weights at various difficulty stages.

I implemented AlphaZero (but not Mu yet) using GBDTs instead of NNs here if you're curious about how it would work: https://github.com/cgreer/alpha-zero-boosted. Instead of saving the "weights" for a GBDT, you save the splitpoints for the value/policy models, but the concept is the same.