AkaMiru/lc0-eval-sampled

Lc0 eval-sampled root-move labels

Positions drawn from the distribution an lc0 network is actually queried on during MCTS, then re-searched as roots so every legal move has a label: visit count, search Q, policy prior, raw network eval, and terminal flags.

This is not standard lc0 selfplay training data (one record per played move). Standard data never trains on the lines search looked at and rejected. This set does.

It is a bootstrap dataset. Teacher strength was not the goal. The intended student should play reasonable chess (~1500 Elo), not beat lc0.

Quick start

# pip install datasets pyarrow torch
from datasets import load_dataset

ds = load_dataset("AkaMiru/lc0-eval-sampled")  # after you upload
# or locally:
# ds = load_dataset("parquet", data_files={
#     "train": "data/train-*.parquet",
#     "validation": "data/validation-*.parquet",
# })

row = ds["train"][0]
print(row["fen"])
print(list(zip(row["uci"], row["n"], row["q"], row["p"]))[:5])

PyTorch, padded batches (from this folder):

import sys
from pathlib import Path
from torch.utils.data import DataLoader

sys.path.insert(0, str(Path(".").resolve()))  # hf-dataset/
from lc0_eval import EvalRootDataset, collate_padded, scatter_policy

train = EvalRootDataset("data", split="train", encode_board=True)

loader = DataLoader(train, batch_size=64, shuffle=True, collate_fn=collate_padded)
batch = next(iter(loader))
# batch["board"]      [B, 19, 8, 8]  starter planes (not lc0's 112)
# batch["q"]          [B, L]         search Q, side-to-move at the root
# batch["n"]          [B, L]         visit count; 0 = unvisited NN fallback
# batch["p"]          [B, L]         root policy prior (softmax-temp already applied)
# batch["move_idx"]   [B, L]         lc0 1858-policy index
# batch["move_mask"]  [B, L]         True on real legal moves

q_1858 = scatter_policy(batch["move_idx"], batch["q"], batch["move_mask"], fill=0.0)

A slightly fuller loop is in examples/quickstart.py.

What's in a row

One row = one chess position (FEN) + one list entry per legal move.

column	type	meaning
fen	string	Board. History-free; encode however you like.
stm_white	bool	Side to move is White.
root_n	uint32	Root visit count after the labelling search (~1024 playouts + root eval).
root_q, root_d	f32	Root search Q and draw fraction, side-to-move at the root. Q=+1 is a win for that player.
root_nn_q, root_nn_d	f32	Root network eval (same sign convention).
n_moves	uint8	Number of legal moves (= list lengths).
move_idx	list[uint16]	MoveToNNIndex(move, 0) into lc0's 1858-policy. STM-board, white at bottom.
uci	list[string]	Standard UCI for the same move (ranks flipped when Black to move).
n	list[uint32]	Child visits. n=0 is not missing data — it is an unvisited child labelled with a raw NN eval (never FPU).
q, d	list[f32]	Child search Q / D, parent / root-STM perspective. For n=0, q == nn_q.
p	list[f32]	Root policy prior, already policy-softmax-temp applied, sums to ~1.
nn_q, nn_d	list[f32]	Child network eval, same sign as q. NaN on terminal children.
terminal	list[bool]	Proven mate/draw at the child.
lower_bound, upper_bound	list[uint8]	0=undecided, 1=black_won, 2=draw, 3=white_won. Child-node convention: white_won means the player who moved to that child won.
flags	list[uint8]	Packed: bit0 terminal, bits1–2 lower, bits3–4 upper.

Do not treat n as a sample count for a well-behaved mean of q. q and n are jointly produced by PUCT. nn_q is the child's own network, recorded so you can see the drift.

Splits

split	rows	unique FENs	legal-move labels
train	969,051	946,730	22,802,225
validation	77,014	77,014	1,807,030

Validation is a fresh selfplay sample (same teacher and N), not a carve-out of train. Exact-FEN collisions with train (1,669 labeled positions, ~2%) are kept: two independent draws from the same search-query distribution are supposed to overlap on common boards. One overlapping FEN had no label in either split (terminal / one-legal-move skip).

Train keeps exact duplicate FENs (22,321 extra rows). They encode sampling frequency; shuffle them like any other row. Adjacent duplicates share labels (searched once).

Parquet on disk is about 755 MB (8 train shards + 1 val shard, zstd).

How it was generated

1. Stage 1 (sample). Teacher selfplay at 512 playouts/move, --max-prefetch=0. Every time search submitted a non-terminal node to the network, the FEN was kept with probability 1/512 (Bernoulli, not a stride).
2. Stage 2 (label). Each unique FEN was searched as a new root at 1024 playouts. Unvisited non-terminal children got one batched NN eval (n=0, q=nn_q). Terminal / one-legal-move positions were skipped.

Teacher: t3-512x15x16h-distill2-swa-03477500 (T3 distill2, 1 Aug 2026). Stage 2 used --history-fill=always so the teacher saw a filled, history-free encoding.

Hardware: RTX 4070 Super 12 GB. Stage 1 ~5.1 h for 1M FENs; stage 2 ~15.7 h. Val set ~1.8 h extra.

Starter board encoder

lc0_eval.encode_fen returns (19, 8, 8) float32 planes: 12 piece types, side-to-move, 4 castling, en passant square, fifty-move clock, constant plane. This is not lc0's 112-plane input. Use it to stand up a student; swap in a real lc0 encoder if you need teacher-compatible features.

Upload this folder

Do not upload .venv/. From hf-dataset/:

hf auth login
hf repos create AkaMiru/lc0-eval-sampled --type dataset --exist-ok
hf upload AkaMiru/lc0-eval-sampled . --type dataset --exclude ".venv/**" --exclude "**/__pycache__/**"

Then load_dataset("AkaMiru/lc0-eval-sampled") works for everyone.

To use the PyTorch helper from the same repo:

pip install -e .[torch]

Reconstruct from the original gzip (optional)

python convert_to_parquet.py \
  --train ../datagen/t3d2-1m/stage2/records.bin.gz \
  --validation ../datagen/t3d2-1m/val/stage2/records.bin.gz \
  --out data

License

Dataset: CC BY 4.0. Helper code in lc0_eval/: MIT. Teacher weights remain under their lc0/network terms; this repo does not redistribute them.