https://lc0.org/slides

2008

October 2017

January 2018

Leela

Leela Zero

Leela Chess Zero

AlphaGo

AlphaGo Zero

AlphaZero

AlphaZero (?)

Stockfish 10

Stockfish 9

Stockfish 8

Grandmasters

Me

TCEC12 – 32th (last)

CCC 1
– 3rd

CCC 2
– 3rd

TCEC 15
– 1st

CCC 8
– 2nd

TCEC CUP 3
– winner

CCC 7
– 1st

CCC 6
– 2nd

TCEC 14
– 2nd

TCEC CUP 2
– winner

CCC 5
– 2nd

CCC 4
– 2nd

CCC 3
– 2nd

TCEC CUP 1
– semifinals

June 2018

January 2019

June 2019

Chess
Game Tree

10¹²³ nodes

0.64

0.01

-8.93

0.39

Traditional Engines:

Eval function

Search algorithm

Move ordering

1.14

0.28

1.14

0.28

0.64

0.01

-8.93

0.39

Traditional Engines:

Eval function

MiniMax (Search algorithm)

Move ordering

Eval function

Search algorithm

Move ordering

-8.93

?.??

Min:

0.28

Traditional Engines:

Eval function

Search algorithm

Move ordering

Max:

0.28

Min: -8.93

Already worse than 0.28,

prune remaining subtrees.

?.??

?.??

α/β pruning

Eval function

Search algorithm

Move ordering

Monte Carlo Tree Search

(kind of)

• Start with only root node

• Route visits to subtrees, prefer more "promising" subtrees

• Results in very unbalanced trees

• Best move is the subtree with most visits

• Most "promising" subtree is combination of:
  • Initial "guess" of what the best move will be
    (when a subtree doesn't yet have many visits)
  • The subtree with the highest average eval of its nodes (when subtree already have many nodes)
  • Underexplored subtrees (much less visits than siblings)

Q = average value of eval in a subtree

N = number of nodes in subtree

V = eval of a single node

C = a constant to balance Q and U

P = initial guess of move strength

Grows when sibling subtrees get visits, shrinks when own subtree gets visits

U starts high when subtree is small, then gives way to Q when subtree grows

Nxf6

Qe3

Qe2

Subtree size (N)

vs Total visits

Subtree eval (Q)

vs Total visits

Subtree eval (Q)
vs Subtree size (N)

Initial guess of move

strength (P)

• Faster
  tens of millions nodes per second

• Slower
  hundreds of thousands nodes per second

• Doesn't keep tree in memory
  Searches of 100 000 000 000s nodes are usual

• Keeps tree in memory
  only searches up to 100 000 000s nodes are realistic

• Tree is balanced

• Tree is very unbalanced
  focuses much more on promising variants

• Final eval is taken from a leaf node
  unstable when eval function is noisy

• Final eval is average of all nodes
  stable when eval function is noisy

• Only runs eval function for leaf nodes
  at certain depth

• Runs eval function for all visited nodes

Eval function

Search algorithm

Move ordering

Q

-1

1

Position eval
(-1 .. 1)

Input Planes
(chess position)

Residual
Neural Network
(40 convolutional layers)

• For every [from→to] square pair, probability that the move will the best.
  (+some more for promotion moves)

Value head

• Requires human chess expertise

• Can learn all by itself (no humans!)

• Faster
  typically tens of millions of evals per second

• Slower
  typically tens of thousands of evals per second

• Typically superficial
  doesn't recognize patterns, relies on deeper counting

• Insightful
  sees positional patterns and even basic tactics

• Works on CPU

• Benefits from GPU

• Evaluates one position at a time

• Needs batches of hundreds of positions to be fast

• Computes eval in pawns
  e.g. knight=3.1 pawns, bad bishop -0.4 pawns penalty

• Computes expected outcome
  -1 – certain loss, 1 – win, 0.4 – win is likely

110 input planes

isRep

⇈⇈ Current position ⇈⇈

⇊⇊ 7 previous board positions ⇊⇊

= 0.0

= 1.0

= 0.06

=

=

white can 0-0

white can 0-0-0

black can 0-0

black can 0-0-0

is black's move

Moves without capture

(3/50) = 0.06

Legend

Neural Network output

1859 numbers:

• Position value (expected game outcome) (-1.0 .. 1.0)
• For each of the 1858 moves, probability that it will end up being chosen (0.0 .. 1.0)

Initially NN parameters are random

Contributors generate
Lc0 vs Lc0
games

NN training:

Old network + training data = 

new network

Neural
Network

NN parameters

Training data

new NN
parameters

latest NN parameters

old NN
parameters

Training
data
100 000 positions per minute

Training

Training data

checkmate

0-1
black wins

V=1

V=-1

V=1

V=-1

P

P

P

P

Self play, 800 visits (≈25ms) per move

NN doesn't know rules of chess

NN is trained:

• whether position is winning
• move probabilities per index

V=1

Training Server

• Noisy GPUs
• Slow Internet

Web server

lzero.org

• Silent
• Fast Internet

Data backup server (data.lczero.org)

• Large disk

Contributors

• Generate 100 000 chess moves per minute

- training data (positions with P and V)

- neural network weights

Jul 2018

Sep 2018

Nov 2018

Jan 2019

Mar 2019

May 2019

1.0M

0.5M

1.5M

2.0M

2.5M

Generated games per day

 - test10

 - test20

 - test30

 - test40

https://lc0.org/contributions

Openings preference (test30)

https://lc0.org/openings

Neural Network

• Larger network

• Trying ideas from research papers

• Better opening variety
  (opening book, chess960)

• Different network versions play vs each other

Search

What's next?

• Support transpositions

• Improve scalability

• Analysis support

• Fix known weaknesses:

  • ​Time management

  • Sudden blunders

  • Better endgame

  • Non-standard openings

https://lczero.org/

https://lc0.org/start
https://lc0.org/play
https://lc0.org/watch

https://lc0.org/github
https://lc0.org/chat
https://lc0.org/forum
https://lc0.org/blog
https://lc0.org/downloads

https://lc0.org/slides

 – how to start with Lc0
– where to play Lc0 online
   – where to watch Lc0 playing

   – our code at Github
– our Discord chat
   – our forum
– our blog
            – download Lc0

  – these slides