README.md

---
license: mit
pretty_name: Zero Evaluator High-Variance Chess Positions
language:
- en
tags:
- chess
- leela-chess-zero
- stockfish
- chess-game
- parquet
- fen
- lc0
- wdl
- self-play
- lichess

size_categories:
- 1M<n<10M
configs:
- config_name: default
  data_files:
  - split: train
    path: data/source_split=train/**/*.parquet
  - split: test
    path: data/source_split=test/**/*.parquet
- config_name: stockfish_zero_wdl
  data_files:
  - split: train
    path: stockfish-zero-wdl/source_split=train/**/*.parquet
  - split: test
    path: stockfish-zero-wdl/source_split=test/**/*.parquet
- config_name: consensus_wdl
  data_files:
  - split: train
    path: zero-consensus/train-*.parquet
  - split: validation
    path: zero-consensus/validation-*.parquet
  - split: test
    path: zero-consensus/test-*.parquet
- config_name: lc0_selfplay
  data_files:
  - split: strong
    path: lc0-selfplay-2m/source_split=strong/**/*.parquet
  - split: mid
    path: lc0-selfplay-2m/source_split=mid/**/*.parquet
  - split: low
    path: lc0-selfplay-2m/source_split=low/**/*.parquet
  - split: early
    path: lc0-selfplay-2m/source_split=early/**/*.parquet
- config_name: lichess_elite
  data_files:
  - split: train
    path: lichess-elite-300k/source_split=human/**/*.parquet
---

# Zero Evaluator High-Variance Chess Positions

This dataset collects **3,809,201 chess positions** from three distinct styles
of play — engine tournament games, neural-network self-play, and strong human
online games. Positions are stored as normalized six-field FEN records for
immediate board reconstruction without replaying a game, and every collection
balances opening, middlegame, and endgame coverage.

Two of the collections additionally carry static, depth-zero win/draw/loss
labels. Variance audits are in `variance-report.json`,
`lc0-selfplay-2m-variance.json`, `lichess-elite-300k-variance.json`, and
`RESULTS.md`.

Five configurations are available.

Positions with labels:

- `stockfish_zero_wdl`: 1,509,201 CCRL positions with immediate static
  Stockfish NNUE WDL labels and per-row engine provenance;
- `consensus_wdl`: a one-million-position subset carrying calibrated static WDL
  from both Lc0 and Stockfish, a blended consensus target, and a per-row
  agreement weight.

Positions without labels:

- `default`: 1,509,201 positions from CCRL engine tournament games;
- `lc0_selfplay`: 2,000,000 positions from Leela Chess Zero self-play,
  split by the generation strength of the network that produced them;
- `lichess_elite`: 300,000 positions from strong human games on Lichess.

The three unlabeled collections are near-disjoint: of 3,809,201 rows,
3,784,379 FENs are unique and 24,822 appear in more than one collection,
almost entirely common opening positions.

## Data layout

The release consists of six Zstandard-compressed Parquet files partitioned by:

- `source_split`: `train` or `test`
- `phase`: `opening`, `middlegame`, or `endgame`

| Split | Opening | Middlegame | Endgame | Total |
| --- | ---: | ---: | ---: | ---: |
| Train | 182,691 | 723,841 | 295,196 | 1,201,728 |
| Test | 51,510 | 176,159 | 79,804 | 307,473 |
| Total | 234,201 | 900,000 | 375,000 | 1,509,201 |

`data/_manifest.json` contains file sizes, row counts, ID bounds, and SHA-256
checksums.

The labeled derivative mirrors the same six partitions under
`stockfish-zero-wdl/`. Its `_manifest.json` records the source Hub revision,
engine identity, binary checksum, row counts, file sizes, and checksums.

## Load the dataset

Hugging Face Datasets:

```python
from datasets import load_dataset

positions = load_dataset("Pawitt/zero-evaluator")
print(positions["train"][0]["fen"])
```

Load the Stockfish-labeled configuration with:

```python
from datasets import load_dataset

positions = load_dataset(
    "Pawitt/zero-evaluator",
    "stockfish_zero_wdl",
)
row = positions["train"][0]
print(row["fen"], row["wdl_win"], row["wdl_draw"], row["wdl_loss"])
```

For Hive partition columns and streaming Arrow batches, use PyArrow directly:

```python
import pyarrow.dataset as ds

positions = ds.dataset(
    "data",
    format="parquet",
    partitioning="hive",
)
scanner = positions.scanner(
    filter=ds.field("source_split") == "train",
    columns=["fen", "result", "phase"],
    batch_size=8192,
)
for batch in scanner.to_batches():
    pass
```

When downloading from the Hub first, point `ds.dataset` at the downloaded
`data/` directory.

## Columns

Each record includes normalized `fen`, source-game provenance, ply and result,
side to move, piece and material statistics, legal-move count, check state,
castling mask, and halfmove clock. See `FORMAT.md` for exact semantics.

The source-game `result` is provenance metadata. It is **not** an lc0
depth-zero WDL label.

The `stockfish_zero_wdl` configuration adds:

| Column | Type | Meaning |
| --- | --- | --- |
| `wdl_win` | `uint16` | Static win probability on a 0–1000 scale |
| `wdl_draw` | `uint16` | Static draw probability on a 0–1000 scale |
| `wdl_loss` | `uint16` | Static loss probability on a 0–1000 scale |
| `wdl_engine_name` | string | Evaluating engine family |
| `wdl_engine_version` | string | Exact engine build identity |
| `wdl_engine_weights` | string | NNUE network identity |

WDL is from the perspective of the side to move and always sums to 1000.

## Stockfish zero-depth labeling

The labeled configuration was produced with a patched Stockfish command,
`go depth 0`. It performs one immediate NNUE evaluation without tree search,
then applies Stockfish's calibrated WDL conversion. This is a static evaluator
label, not a searched game-theoretic result or a native three-output neural
head.

Provenance:

- engine: `Stockfish dev-20260822-d95a3013-zero-wdl`;
- NNUE: `nn-1a298aa575a0.nnue`;
- engine binary SHA-256:
  `57ca9adcf657338ac907b3c0c667f1f705885c06865603134f23c6e6e402682d`;
- source dataset revision:
  `7e7d453311882b4b8686aeb885e1c2eb9e2911f9`;
- terminal adjudication: `python-chess outcome(claim_draw=True)`.

Across all rows, the mean WDL is `186.773 / 578.242 / 234.985`. Stockfish's
static calibration is draw-heavy: the median draw value is `875/1000`.

## Calibrated consensus WDL

The `consensus_wdl` configuration holds **1,000,000 positions** drawn from the
same corpus and labeled independently by two static evaluators, then reconciled
into a single target. It is the only configuration with a `validation` split.

Both engines are read at depth zero, so each label is one immediate network
evaluation rather than a search result. Their raw outputs disagree in scale as
well as in content, so each is temperature-calibrated before blending:

| engine | version | weights | temperature |
| --- | --- | --- | ---: |
| Lc0 | `v0.33.0-zero-wdl+git.a663361` | `BT4-332.pb.gz` (`d6e4bbf2...`) | 1.8446 |
| Stockfish | `dev-20260822-d95a3013-zero-wdl` | `nn-1a298aa575a0.nnue` | 9.3926 |

The consensus target is the equal arithmetic mean of the two calibrated
distributions. Stockfish's much larger temperature reflects how sharply its raw
static evaluation is distributed compared to Lc0's.

### Selection

Positions were admitted only where the two evaluators broadly agree, on two
independent criteria:

- absolute difference in expected score at most `0.5`;
- Jensen-Shannon divergence between the two distributions at most `0.4` bits.

That left 1,383,243 eligible positions, from which 1,000,000 were sampled to a
fixed phase balance with seed `91`.

### Sample weight

Agreement is graded rather than binary. Each row carries

```text
sample_weight = clip((1 - JS) * (1 - |delta_q| / 2), 0.4, 1.0)
```

so positions where the evaluators concur closely count fully, and marginal ones
are retained at reduced weight. No row falls below `0.4`. Consumers training on
soft targets should weight by this column.

### Splits and balance

| Split | Opening | Middlegame | Endgame | Total |
| --- | ---: | ---: | ---: | ---: |
| Train | 192,000 | 576,000 | 192,000 | 960,000 |
| Validation | 4,000 | 12,000 | 4,000 | 20,000 |
| Test | 4,000 | 12,000 | 4,000 | 20,000 |
| Total | 200,000 | 600,000 | 200,000 | 1,000,000 |

### Added columns

| Column | Type | Meaning |
| --- | --- | --- |
| `wdl_win` / `wdl_draw` / `wdl_loss` | `uint16` | Blended consensus target, 0-1000 |
| `lc0_wdl_win` / `lc0_wdl_draw` / `lc0_wdl_loss` | `uint16` | Calibrated Lc0 label, 0-1000 |
| `stockfish_wdl_win` / `stockfish_wdl_draw` / `stockfish_wdl_loss` | `uint16` | Calibrated Stockfish label, 0-1000 |
| `teacher_q_delta` | `float` | Signed difference in expected score between the two |
| `teacher_js_divergence` | `float` | Jensen-Shannon divergence in bits |
| `sample_weight` | `float` | Agreement weight in `[0.4, 1.0]` |
| `split` | string | `train`, `validation`, or `test` |

Every WDL triple is from the side to move and sums to 1000.

`zero-consensus/manifest.json` records the calibration temperatures, engine
identities, filter thresholds, sampling seed, per-split and per-phase counts,
and a SHA-256 for every shard.

Load it with:

```python
from datasets import load_dataset

positions = load_dataset("Pawitt/zero-evaluator", "consensus_wdl")
row = positions["train"][0]
print(row["fen"], row["wdl_win"], row["sample_weight"])
```

## Self-play and human position collections

Two further collections extend the corpus beyond CCRL engine games. Both hold
positions only — no evaluations — in the same schema as the `default`
configuration, so they can be read the same way and labeled independently.

### `lc0_selfplay`

2,000,000 positions sampled from Leela Chess Zero self-play training data
published at `storage.lczero.org/files/training_data`, drawn from 252,686
distinct games across 56 archives and 9 training runs spanning 2018-09 to
2026-08.

Splits correspond to the strength of the network that generated the games,
since a collection drawn only from the strongest run would be narrow in exactly
the way a varied corpus should not be:

| Split | Positions | Runs | Character |
| --- | ---: | --- | --- |
| `strong` | 1,200,000 | test80, test91 | Mature run1 and the live run2 |
| `mid` | 440,000 | test79, test75, late test60 | Transitional styles, sound but more varied |
| `low` | 260,000 | test40, early test60, test71_5 | Messier tactics, unusual structures |
| `early` | 100,000 | test30, run3 | Semi-initial play, maximum noise |

Records were decoded with the Lc0 rescorer without tablebase rescoring or
deblundering, and without the position filtering that the Stockfish NNUE
conversion path applies. Up to twelve positions were taken per game, allocated
across phases in the same 15/60/25 ratio the splits hold.

The `test71` run is excluded: it is the Chess960 run, measured at 30-36%
Chess960 against at most 1.2% in every other run. Chess960 positions are
excluded throughout, so every FEN is legal standard chess.

Source game results are 583,358 white wins, 893,297 draws, and 523,345 black
wins — a 44.7% draw rate.

### `lichess_elite`

300,000 positions from 180,510 games in the
[Lichess Elite Database](https://database.nikonoel.fr/), which filters the
Lichess standard database to games where a 2400+ player faced a 2200+ player.
Twelve months are sampled in equal share, spread across 2020-06 to 2025-10, at
three positions per game.

This is strong human **blitz**, not considered classical play: roughly 88% of
eligible games are 3+0 or 3+2, 5% rapid, and under 1% classical, with White Elo
median 2550. Bullet and ultrabullet are excluded.

Draws are 12.3% of source games here, against 44.7% in `lc0_selfplay`. Human
blitz is substantially more decisive than engine self-play, so this collection
supplies sharper and less balanced positions than the other two.

### Loading

```python
from datasets import load_dataset

selfplay = load_dataset("Pawitt/zero-evaluator", "lc0_selfplay")
print(selfplay["strong"][0]["fen"])

human = load_dataset("Pawitt/zero-evaluator", "lichess_elite")
print(human["train"][0]["fen"])
```

Both use the same columns as `default`; see `FORMAT.md`. As there, the source
game `result` is provenance metadata and not a position label.

## Validation

- All 1,509,201 source rows were reproduced in Parquet.
- All six partition counts match the source database.
- All 26 row groups use Zstandard compression.
- All six file checksums match the manifest.
- 6,000 sampled FEN records were reconstructed successfully with python-chess.
- The Stockfish derivative contains exactly 1,509,201 rows in the same six
  partitions.
- Every labeled partition matches its manifest row count, byte size, and
  SHA-256 checksum.
- Every labeled row has WDL values summing to 1000.
- All labeled files carry `zero_wdl_complete=true` and consistent engine
  provenance.
- The consensus configuration contains exactly 1,000,000 rows across six
  shards, each matching its manifest row count and SHA-256 checksum.
- Every consensus row carries three WDL triples that each sum to 1000, and a
  sample weight within `[0.4, 1.0]`.
- The self-play and human collections contain exactly 2,000,000 and 300,000
  rows, with no duplicate FEN within either.
- Their Parquet forms hold FEN sets identical to the SQLite databases they were
  built from.
- Sampled rows from both were reconstructed with python-chess: every FEN parses
  as a legal standard-chess position, and `side_to_move`, `piece_count`,
  `in_check`, and `legal_moves` were recomputed and matched.
- Every split in both holds opening, middlegame, and endgame in a 15/60/25
  ratio.

## Source

The source is the [Leela Chess Zero standard CCRL dataset](https://lczero.org/blog/2018/09/a-standard-dataset/),
published as 2.5 million CCRL 40/40 and 40/4 engine games with an original
80/20 train/test split.

The self-play collection derives from
[Lc0 training data](https://storage.lczero.org/files/training_data/), decoded
with the [Lc0 rescorer](https://github.com/Tilps/lc0/tree/rescore_tb). The human
collection derives from the
[Lichess Elite Database](https://database.nikonoel.fr/), itself filtered from
the [Lichess open database](https://database.lichess.org/).

The extraction and conversion scripts are included for reproducibility.