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

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
---

# Zero Evaluator High-Variance Chess Positions

This dataset contains **1,509,201 unique chess positions** extracted from Leela
Chess Zero's published CCRL standard corpus. Positions are stored as normalized
six-field FEN records for immediate board reconstruction without replaying a
game.

The selection deliberately balances opening, middlegame, and endgame coverage
and retains the original source train/test split. The complete variance audit
is in `variance-report.json` and `RESULTS.md`.

Two configurations are available:

- `default`: the original unlabeled positions;
- `stockfish_zero_wdl`: the same positions with immediate static Stockfish
  NNUE WDL labels and per-row engine provenance.

## 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`.

## 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.

## 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 extraction and conversion scripts are included for reproducibility.