fast & dumb versus slow & smart

[Warren D Smith]

LcZero is the ultimate so far "slow & smart" chess program.

In the other direction, "pesto" by Ronald Friederichs uses a tapered "piece square table" 

(and tempo) as its only evaluation knowledge (basically equivalent to a "single neuron")

and astonishingly is now over 3000 elo strength.  (Secret code.)

This is not enough to challenge stockfish and LcZero, but it is pretty damn impressive

testimony to the power of alphabeta search heuristics combined with speed.

Or perhaps to the triviality of chess compared with, say, go.

[glbchess64]

You point out the big problem of alpha beta : to be efficient you have to simplify the evaluation function so to neglect knowledge for pure and deep calculus. But chess is too complex to be solved in that way and strategy is necessary.

This was the way I played chess before I came to the chess club and begin to read good chess books and discovered strategy at chess. This is what Leela is doing : playing chess based on strategical principle with a few tactic (like human).

Leela showed that it is possible to play very good chess with no tactic at all : the strength of Leela + SV-30x384-T60-3010 is simply incredible at 1 node per move (FIDE master level).

In fact chess is a very well balanced game between strategy and tactic and GM (and good correspondence player) are both positional and tactical player like Leela with the MCTS. Leela + MCTS or Alpha zero is the best compromise,  between strategy and tactic, between chess knowledge and analysis, we found for computer now.

[Dietrich Kappe]

Cue Warren’s “leela is an opening book” rant.

[Warren D Smith]

I used to think (and probably most chess programmers thought) that
with piece-square tables only, a chess program could never get above
about 2000 elo.
Such tables know nothing about mobility, king safety, pawn structure,
passed pawns, rooks on 7th, bad bishops etc. However pesto shows that
is incorrect. It is over 3000 elo
and uses only tapers piece-square tables and "tempo."

Pesto competed in Tcec 17 and finished ahead of such well known
engines as Gull (3121), Texel (3142), Wasp (3055), Demolito (3073),
Fizbo (3198), and iCE (3061).

Glbchess64 is incorrect that with alphabeta search one must use a
simplified "dumb" evaluation. One could combine leela's eval with
alphabeta search for example.
Stockfish and Komodo have quite smart evaluators, certainly far superior to
a mere piece-square table, and also quite fast. I do not believe it
is necessary to be dumb if you want to be fast. Stockfish has faster
node rate than my piece-square-only program, because I was
concentrating on code-simplicity rather than speed.

Pesto's speed on TCEC 17 hardware was 260-360 million nodes/sec.
Stockfish and Komodo got 110-320 Mnodes/sec. So of course these,
probably the two smartest top alphabeta programs, are slower than
pesto, but they are only a factor 3 (or less!) slower.

In the other direction, I also used to think (and probably most chess
programmers thought) that no matter how smart your evaluator was, if
you did no search you'd never be able to be strong enough to beat,
e.g. even me (a fairly weak human player). LcZero shows that is
incorrect. No-lookahead leela (see https://lichess.org/@/leela_policy
) currently
is rated 1715 to 2184 on lichess depending on time control
(1715=classical, 2184=blitz)
although many of these ratings are preliminary since based on too-few
games. This is strong enough to give me a good battle, with the odds
in its favor although not overwhelming. Another no-lookahead leela, I
think using an older/weaker net, is
https://lichess.org/@/LeelaInstinct rated 1442 to 1923.

--
Warren D. Smith
http://RangeVoting.org <-- add your endorsement (by clicking
"endorse" as 1st step)

[Dietrich Kappe]

Check Leela1Node

[DBg]

This comment feltlike an inside.  Could you explain to me.  I don't think any pro-self-learning engine advocate would deny that the impossible brute force algorithm run by the ultimate computer to the universe, that we might all actually be part of (%-) would be able to win all games of chess, having figured out the opening book of non-truncated pgns for all possible chess games (even those random ones).

then AB pruning, getting into the nooks and crannies of all combinatorial possibilities that stick close to game theory, would eventually be covering the whole Nash manifold or what ever we could hope for as perfect chess, and close all its blind spots (from not seeing far enough yet) by teaming with humans (the heuristic astuce tweakers, wiser as depth increases and new heuristic caveats tinier and tinier in state space) to scout the horizon.

My current fantasy (and hunch) at the same level as the op (I think).  Is that AB is approaching the perfect chess supspace (manifold,sub-set) for all game lengths from the "inside", while the self-learning engines are doing it from the "outside".  The not yet explicit assumption is that one could talk about inside and outside in some state space, or representation transformation of it.

I want to find various transformations of the state space as currently used at first layers, the input encoding, that could vary what inside and outside mean. This may be a fantasy, or a conciliating perspective between engines.  We could develop metrics under various transformations to characterize what each engines strategy are currently exploring as sub-sets of target sub-space, or bounds (uppper and lower confidence types if you want).   

sorry for the dreaming.

[DBg]

I just looked at "pesto". nice experiment. good that another basic approach, revising architectural and state space representation is in play.

I wonder how this fits in my dream.

[Warren D Smith]

On 3/18/20, Dietrich Kappe <dka...@gmail.com> wrote:
> Check Leela1Node

--I found https://lichess.org/@/MiniHuman
which says it is "mean girl 8" searching about 25 nodes plus a gambit
book, which I assume is roughly
equivalent (at least in terms of node count) to 1 ply search. Ratings 2209-2504.

https://lichess.org/@/Leela1Node has ratings 1772-2360.

[Dietrich Kappe]

Leela1Node is a 384x30 net trained on t60 games. It, as the name implies, looks at 1 node. Mean girl 8 is a 32x4 looking at a few more. Stronger than leela1node. Leela2200 is a 16x2 looking at 4000 nodes. Weaker than 1 node.