Publish high-variance 1.5M chess position Parquet dataset

Adds six train/test and game-phase Parquet partitions, checksums, variance audit, documentation, and reproducibility scripts.

FORMAT.md

@@ -0,0 +1,101 @@
+# VPD1: Vex Position Dataset
+
+VPD1 is an indexed SQLite container for independent chess positions. Its file
+extension is `.vpd`. It is designed for static teacher labeling, where a
+consumer needs one complete board immediately without replaying a game.
+
+## Position identity
+
+Each row stores a legal six-field FEN. The fullmove number is normalized to
+`1`; it does not affect board state or lc0 evaluation. The halfmove clock is
+preserved because it affects draw rules. En-passant state and castling rights
+are preserved.
+
+The `fen` column is unique, so duplicate positions from different games are
+removed.
+
+## Tables
+
+`metadata(key, value)` records provenance, format version, sampling seed,
+target size, quotas, progress, and completion information.
+
+`positions` contains:
+
+| Column | Meaning |
+| --- | --- |
+| `id` | Integer row identifier |
+| `random_key` | Indexed deterministic 63-bit key for fast random sampling |
+| `fen` | Normalized six-field FEN |
+| `source_split` | Original train/test split if present |
+| `source_member` | PGN member inside the source archive |
+| `game_number` | Sequential source-game number |
+| `ply` | Ply at which the position was sampled |
+| `result` | Source game result; metadata, not a static WDL label |
+| `side_to_move` | `1` for White, `0` for Black |
+| `phase` | `0` opening, `1` middlegame, `2` endgame |
+| `piece_count` | Occupied squares |
+| `non_pawn_material` | Combined N/B/R/Q material in pawn units |
+| `material_balance` | White material minus Black material |
+| `legal_moves` | Legal move count |
+| `in_check` | Whether the side to move is in check |
+| `castling_mask` | KQkq availability as four bits |
+| `halfmove_clock` | Fifty-move-rule clock |
+
+## Immediate access
+
+By row identifier:
+
+```sql
+SELECT fen FROM positions WHERE id = 12345;
+```
+
+Near-constant-time random access uses the indexed `random_key`:
+
+```sql
+SELECT fen
+FROM positions
+WHERE random_key >= :random_63_bit_integer
+ORDER BY random_key
+LIMIT 1;
+```
+
+The supplied `vpd.py sample` command implements wraparound when the random key
+is above the largest stored key.
+
+## Parquet derivative
+
+`vpd_to_parquet.py` converts the same rows into a columnar training dataset.
+The output uses Hive directories for `source_split` and `phase`; those two
+columns are therefore encoded in paths instead of duplicated inside each
+file. Each remaining VPD1 column retains its meaning, except `phase` is exposed
+as the strings `opening`, `middlegame`, and `endgame`.
+
+Files use Zstandard compression and 65,536-row groups. `_manifest.json`
+contains the source database checksum plus per-file row counts, sizes, row
+groups, ID bounds, and checksums. This representation is optimized for batch
+and filtered scans; retain VPD1 SQLite for indexed single-position lookup.
+
+## Sampling policy
+
+At most one position per game and phase is selected with reservoir sampling.
+The default 1.5-million-position build uses fixed phase quotas:
+
+- 15% opening
+- 60% middlegame
+- 25% endgame
+
+This reduces correlation between adjacent plies and prevents ordinary
+middlegames from overwhelming openings and endgames.
+
+Phase classification is deterministic:
+
+- opening: ply 20 or earlier with at least 50 combined non-pawn material;
+- endgame: at most 20 combined non-pawn material or at most 12 pieces;
+- middlegame: everything else.
+
+## Variance contract
+
+A database is marked `high_variance=true` only if every declared threshold in
+the JSON report passes. The checks cover corpus size, phase entropy, minimum
+phase and result shares, side-to-move balance, legal-move spread, piece-count
+spread, material imbalance, castling-state coverage, and positions in check.

README.md

@@ -1,8 +1,106 @@
 ---
 license: mit
+pretty_name: Zero Evaluator High-Variance Chess Positions
+language:
+- en
+tags:
+- chess
+- leela-chess-zero
+- 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
 ---
 
-The dataset consist of millions of chess games, with high variance.
-suitable for engine training. 
+# Zero Evaluator High-Variance Chess Positions
 
-Additionally it may conssit the depth zero wdl evaluation by lc0. depth zero imply no tree search and a immediate evaluation of board.
+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`.
+
+## 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.
+
+## Load the dataset
+
+Hugging Face Datasets:
+
+```python
+from datasets import load_dataset
+
+positions = load_dataset("Pawitt/zero-evaluator")
+print(positions["train"][0]["fen"])
+```
+
+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. Static WDL values can be added by running the positions
+through an lc0 zero-search evaluation pass.
+
+## 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.
+
+## 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.

RESULTS.md

@@ -0,0 +1,85 @@
+# Completed Dataset Results
+
+## Artifacts
+
+- Dataset: `data/ccrl-high-variance-1p5m.vpd`
+- Training dataset: `data/ccrl-high-variance-1p5m.parquet/`
+- Parquet manifest: `data/ccrl-high-variance-1p5m.parquet/_manifest.json`
+- Variance report: `data/variance-report.json`
+- Source archive: `source/ccrl-pgn.tar.bz2`
+- Extractor and reader: `vpd.py`
+- Format specification: `FORMAT.md`
+
+## Provenance
+
+The source is Leela Chess Zero's published CCRL standard dataset: 2.5 million
+CCRL 40/40 and 40/4 engine games with an 80/20 train/test split. Extraction
+used 910,462 source games and completed with zero PGN parse errors.
+
+The final VPD1 database contains 1,509,201 unique normalized FEN positions and
+is 438,558,720 bytes.
+
+The Parquet derivative contains the same 1,509,201 rows in six Hive-style
+`source_split`/`phase` partitions. It is 52 MiB on disk, uses Zstandard level 6
+compression, and has 26 row groups capped at 65,536 rows.
+
+## Variance result
+
+Overall result: **HIGH VARIANCE — PASS**
+
+Every declared threshold in `data/variance-report.json` passed.
+
+| Dimension | Result |
+| --- | ---: |
+| Opening | 234,201 (15.52%) |
+| Middlegame | 900,000 (59.63%) |
+| Endgame | 375,000 (24.85%) |
+| Normalized phase entropy | 0.858704 |
+| White wins | 570,602 (37.81%) |
+| Draws | 481,726 (31.92%) |
+| Black wins | 456,873 (30.27%) |
+| White to move | 758,019 (50.23%) |
+| Black to move | 751,182 (49.77%) |
+| Positions in check | 103,519 (6.86%) |
+| Positions with castling rights | 289,814 (19.20%) |
+| Positions without castling rights | 1,219,387 (80.80%) |
+| Material imbalance of at least 3 | 234,018 (15.51%) |
+
+Legal move counts span 0–87, with p10 12, median 33, p90 44, and standard
+deviation 12.064. Piece counts span 2–32, with p10 10, median 21, p90 30, and
+standard deviation 7.5146.
+
+## Validation
+
+- SQLite `PRAGMA integrity_check`: `ok`
+- Random FEN validation: 1,000/1,000 valid
+- Indexed random retrieval: 1,000 queries in 4.404 ms
+- Mean in-process lookup latency: 0.004404 ms per board
+- Parquet row-count validation: 1,509,201/1,509,201
+- Parquet partition-count validation: 6/6 exact matches
+- Parquet FEN validation sample: 6,000/6,000 valid
+- Parquet file checksums: 6/6 match `_manifest.json`
+- Parquet compression audit: all 26 row groups use Zstandard
+- Source archive SHA-256:
+  `5f4d7ec86a99ba56fd3e46b1eb35f3ae109890bc77fecc3e605a6174ea717e76`
+- Dataset SHA-256:
+  `2f3af2973d1e4cb2d7e0d54e7e7a0f12def44d982915df0c9cab1735f6b138cc`
+- Report SHA-256:
+  `759699d7bc704fd265524a6df320c1a0c925f902e29a60b83366d987d3ab507e`
+
+## Retrieve one board
+
+```bash
+cd /Users/pawit/Documents/vexilon/tmp/vex-position-dataset
+PYTHONDONTWRITEBYTECODE=1 .venv/bin/python vpd.py sample \
+  data/ccrl-high-variance-1p5m.vpd
+```
+
+Example output:
+
+```json
+{"id":257499,"fen":"8/4p3/p6p/1p3k1K/1n3P2/1P4P1/r3RN2/8 w - - 0 1","phase":"endgame","result":"1-0"}
+```
+
+The source `result` is provenance metadata. It is not the depth-zero static WDL
+label; lc0 can add that label in a subsequent pass.

data/_manifest.json

@@ -0,0 +1,82 @@
+{
+  "compression": "zstd",
+  "compression_level": 6,
+  "elapsed_seconds": 4.922,
+  "format": "VPD1-Parquet",
+  "partitioning": [
+    "source_split",
+    "phase"
+  ],
+  "partitions": [
+    {
+      "bytes": 1585824,
+      "file": "source_split=test/phase=opening/positions.parquet",
+      "max_id": 1406490,
+      "min_id": 1,
+      "phase": "opening",
+      "row_groups": 1,
+      "rows": 51510,
+      "sha256": "57fb6ae73a7b001f845032e833efcba73724d6cb13336ee73e75d2f22fcdff51",
+      "source_split": "test"
+    },
+    {
+      "bytes": 6721156,
+      "file": "source_split=test/phase=middlegame/positions.parquet",
+      "max_id": 1506802,
+      "min_id": 2,
+      "phase": "middlegame",
+      "row_groups": 3,
+      "rows": 176159,
+      "sha256": "8499cd54cecf657a5fc7569d45f2dabf9385a2526f47030d39e9499e47e7e0ad",
+      "source_split": "test"
+    },
+    {
+      "bytes": 2606046,
+      "file": "source_split=test/phase=endgame/positions.parquet",
+      "max_id": 969894,
+      "min_id": 3,
+      "phase": "endgame",
+      "row_groups": 2,
+      "rows": 79804,
+      "sha256": "29996caf5229cf0ef9bb860c1495061047c03084da627f3d8343a8f827f12e86",
+      "source_split": "test"
+    },
+    {
+      "bytes": 5593410,
+      "file": "source_split=train/phase=opening/positions.parquet",
+      "max_id": 1430066,
+      "min_id": 5230,
+      "phase": "opening",
+      "row_groups": 3,
+      "rows": 182691,
+      "sha256": "51fe5555204e9802a738dfcb89b8b0ffa409afdfcb2d825d1a5fd11dfcc2e536",
+      "source_split": "train"
+    },
+    {
+      "bytes": 27538546,
+      "file": "source_split=train/phase=middlegame/positions.parquet",
+      "max_id": 1509201,
+      "min_id": 5228,
+      "phase": "middlegame",
+      "row_groups": 12,
+      "rows": 723841,
+      "sha256": "3bcc0554d9ff4d5bde9de114e76b6c44c9e15864e87c9e52111890058a43f356",
+      "source_split": "train"
+    },
+    {
+      "bytes": 9598882,
+      "file": "source_split=train/phase=endgame/positions.parquet",
+      "max_id": 978071,
+      "min_id": 5229,
+      "phase": "endgame",
+      "row_groups": 5,
+      "rows": 295196,
+      "sha256": "752da7ca0dc00288b564926f89413678101dff90ee1be8c24f37c24d44df0020",
+      "source_split": "train"
+    }
+  ],
+  "row_group_size": 65536,
+  "rows": 1509201,
+  "source": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/ccrl-high-variance-1p5m.vpd",
+  "source_sha256": "2f3af2973d1e4cb2d7e0d54e7e7a0f12def44d982915df0c9cab1735f6b138cc"
+}

data/source_split=test/phase=endgame/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29996caf5229cf0ef9bb860c1495061047c03084da627f3d8343a8f827f12e86
+size 2606046

data/source_split=test/phase=middlegame/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8499cd54cecf657a5fc7569d45f2dabf9385a2526f47030d39e9499e47e7e0ad
+size 6721156

data/source_split=test/phase=opening/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57fb6ae73a7b001f845032e833efcba73724d6cb13336ee73e75d2f22fcdff51
+size 1585824

data/source_split=train/phase=endgame/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:752da7ca0dc00288b564926f89413678101dff90ee1be8c24f37c24d44df0020
+size 9598882

data/source_split=train/phase=middlegame/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bcc0554d9ff4d5bde9de114e76b6c44c9e15864e87c9e52111890058a43f356
+size 27538546

data/source_split=train/phase=opening/positions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51fe5555204e9802a738dfcb89b8b0ffa409afdfcb2d825d1a5fd11dfcc2e536
+size 5593410

requirements.txt

@@ -0,0 +1,2 @@
+python-chess==1.999
+pyarrow==25.0.1

scripts/vpd.py

@@ -0,0 +1,559 @@
+#!/usr/bin/env python3
+"""Build, analyze, and sample a Vex Position Dataset (VPD1) database."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import math
+import random
+import sqlite3
+import statistics
+import sys
+import tarfile
+import time
+from pathlib import Path
+
+import chess
+import chess.pgn
+
+
+FORMAT_VERSION = "VPD1"
+DEFAULT_TARGET = 1_500_000
+PHASE_NAMES = {0: "opening", 1: "middlegame", 2: "endgame"}
+PHASE_IDS = {name: value for value, name in PHASE_NAMES.items()}
+PIECE_VALUES = {
+    chess.PAWN: 1,
+    chess.KNIGHT: 3,
+    chess.BISHOP: 3,
+    chess.ROOK: 5,
+    chess.QUEEN: 9,
+}
+
+
+class NonSeekableReader(io.RawIOBase):
+    """Adapt tarfile's streaming member object for TextIOWrapper on Python 3.14."""
+
+    def __init__(self, source: object) -> None:
+        self.source = source
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def readinto(self, buffer: bytearray) -> int:
+        chunk = self.source.read(len(buffer))
+        if not chunk:
+            return 0
+        buffer[: len(chunk)] = chunk
+        return len(chunk)
+
+
+def connect(path: Path) -> sqlite3.Connection:
+    db = sqlite3.connect(path)
+    db.execute("PRAGMA journal_mode=WAL")
+    db.execute("PRAGMA synchronous=NORMAL")
+    db.execute("PRAGMA temp_store=MEMORY")
+    db.execute("PRAGMA cache_size=-262144")
+    db.execute("PRAGMA foreign_keys=ON")
+    return db
+
+
+def initialize(db: sqlite3.Connection) -> None:
+    db.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        ) WITHOUT ROWID;
+
+        CREATE TABLE IF NOT EXISTS positions (
+          id INTEGER PRIMARY KEY,
+          random_key INTEGER NOT NULL UNIQUE,
+          fen TEXT NOT NULL UNIQUE,
+          source_split TEXT NOT NULL,
+          source_member TEXT NOT NULL,
+          game_number INTEGER NOT NULL,
+          ply INTEGER NOT NULL,
+          result TEXT NOT NULL,
+          side_to_move INTEGER NOT NULL CHECK(side_to_move IN (0, 1)),
+          phase INTEGER NOT NULL CHECK(phase BETWEEN 0 AND 2),
+          piece_count INTEGER NOT NULL,
+          non_pawn_material INTEGER NOT NULL,
+          material_balance INTEGER NOT NULL,
+          legal_moves INTEGER NOT NULL,
+          in_check INTEGER NOT NULL CHECK(in_check IN (0, 1)),
+          castling_mask INTEGER NOT NULL CHECK(castling_mask BETWEEN 0 AND 15),
+          halfmove_clock INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS positions_phase ON positions(phase);
+        CREATE INDEX IF NOT EXISTS positions_result ON positions(result);
+        CREATE INDEX IF NOT EXISTS positions_legal_moves ON positions(legal_moves);
+        CREATE INDEX IF NOT EXISTS positions_piece_count ON positions(piece_count);
+        CREATE INDEX IF NOT EXISTS positions_material_balance
+          ON positions(material_balance);
+        CREATE INDEX IF NOT EXISTS positions_split ON positions(source_split);
+        """
+    )
+    set_metadata(db, "format", FORMAT_VERSION)
+    set_metadata(db, "fen_fullmove_normalization", "1")
+
+
+def set_metadata(db: sqlite3.Connection, key: str, value: object) -> None:
+    db.execute(
+        "INSERT INTO metadata(key, value) VALUES (?, ?) "
+        "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+        (key, str(value)),
+    )
+
+
+def normalized_fen(board: chess.Board) -> str:
+    fields = board.fen(en_passant="fen").split()
+    fields[5] = "1"
+    return " ".join(fields)
+
+
+def phase_of(board: chess.Board, ply: int) -> int:
+    non_pawn = sum(
+        PIECE_VALUES[piece_type]
+        * (
+            len(board.pieces(piece_type, chess.WHITE))
+            + len(board.pieces(piece_type, chess.BLACK))
+        )
+        for piece_type in (chess.KNIGHT, chess.BISHOP, chess.ROOK, chess.QUEEN)
+    )
+    piece_count = chess.popcount(board.occupied)
+    if ply <= 20 and non_pawn >= 50:
+        return PHASE_IDS["opening"]
+    if non_pawn <= 20 or piece_count <= 12:
+        return PHASE_IDS["endgame"]
+    return PHASE_IDS["middlegame"]
+
+
+def castling_mask(board: chess.Board) -> int:
+    return (
+        int(board.has_kingside_castling_rights(chess.WHITE))
+        | (int(board.has_queenside_castling_rights(chess.WHITE)) << 1)
+        | (int(board.has_kingside_castling_rights(chess.BLACK)) << 2)
+        | (int(board.has_queenside_castling_rights(chess.BLACK)) << 3)
+    )
+
+
+def material(board: chess.Board) -> tuple[int, int]:
+    white = sum(
+        PIECE_VALUES[piece_type] * len(board.pieces(piece_type, chess.WHITE))
+        for piece_type in PIECE_VALUES
+    )
+    black = sum(
+        PIECE_VALUES[piece_type] * len(board.pieces(piece_type, chess.BLACK))
+        for piece_type in PIECE_VALUES
+    )
+    non_pawn = sum(
+        PIECE_VALUES[piece_type]
+        * (
+            len(board.pieces(piece_type, chess.WHITE))
+            + len(board.pieces(piece_type, chess.BLACK))
+        )
+        for piece_type in (chess.KNIGHT, chess.BISHOP, chess.ROOK, chess.QUEEN)
+    )
+    return white - black, non_pawn
+
+
+def random_key(fen: str) -> int:
+    raw = hashlib.blake2b(fen.encode("ascii"), digest_size=8).digest()
+    return int.from_bytes(raw, "big") & ((1 << 63) - 1)
+
+
+def position_record(
+    board: chess.Board,
+    source_split: str,
+    source_member: str,
+    game_number: int,
+    ply: int,
+    result: str,
+    phase: int,
+) -> tuple[object, ...]:
+    fen = normalized_fen(board)
+    balance, non_pawn = material(board)
+    return (
+        random_key(fen),
+        fen,
+        source_split,
+        source_member,
+        game_number,
+        ply,
+        result,
+        int(board.turn == chess.WHITE),
+        phase,
+        chess.popcount(board.occupied),
+        non_pawn,
+        balance,
+        board.legal_moves.count(),
+        int(board.is_check()),
+        castling_mask(board),
+        board.halfmove_clock,
+    )
+
+
+def split_for(member_name: str) -> str:
+    lowered = member_name.lower()
+    if "test" in lowered:
+        return "test"
+    if "train" in lowered:
+        return "train"
+    return "unspecified"
+
+
+def make_quotas(target: int) -> dict[int, int]:
+    opening = round(target * 0.15)
+    endgame = round(target * 0.25)
+    return {0: opening, 1: target - opening - endgame, 2: endgame}
+
+
+def current_counts(db: sqlite3.Connection) -> dict[int, int]:
+    counts = {phase: 0 for phase in PHASE_NAMES}
+    counts.update(dict(db.execute("SELECT phase, COUNT(*) FROM positions GROUP BY phase")))
+    return counts
+
+
+def extract(args: argparse.Namespace) -> None:
+    source = Path(args.source).resolve()
+    output = Path(args.output).resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    db = connect(output)
+    initialize(db)
+    quotas = make_quotas(args.target)
+    counts = current_counts(db)
+    resume_row = db.execute(
+        "SELECT source_member FROM positions ORDER BY id DESC LIMIT 1"
+    ).fetchone()
+    resume_member = resume_row[0] if resume_row else None
+    games_seen = int(
+        db.execute("SELECT COALESCE(value, '0') FROM metadata WHERE key='games_seen'")
+        .fetchone()[0]
+        if db.execute("SELECT 1 FROM metadata WHERE key='games_seen'").fetchone()
+        else 0
+    )
+    candidates_attempted = int(
+        db.execute(
+            "SELECT COALESCE(value, '0') FROM metadata "
+            "WHERE key='candidates_attempted'"
+        ).fetchone()[0]
+        if db.execute(
+            "SELECT 1 FROM metadata WHERE key='candidates_attempted'"
+        ).fetchone()
+        else 0
+    )
+    parse_errors = 0
+    inserted_since_commit = 0
+    started = time.monotonic()
+
+    set_metadata(db, "source", str(source))
+    set_metadata(db, "target_positions", args.target)
+    set_metadata(db, "seed", args.seed)
+    set_metadata(db, "phase_quotas", json.dumps(quotas, sort_keys=True))
+    db.commit()
+
+    insert_sql = """
+        INSERT OR IGNORE INTO positions(
+          random_key, fen, source_split, source_member, game_number, ply,
+          result, side_to_move, phase, piece_count, non_pawn_material,
+          material_balance, legal_moves, in_check, castling_mask, halfmove_clock
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """
+
+    with tarfile.open(source, mode="r|bz2") as archive:
+        corpus_game_number = 0
+        finished = False
+        reached_resume_member = resume_member is None
+        for member in archive:
+            if finished:
+                break
+            if not member.isfile() or not member.name.lower().endswith(".pgn"):
+                continue
+            if not reached_resume_member:
+                if member.name != resume_member:
+                    continue
+                reached_resume_member = True
+            raw = archive.extractfile(member)
+            if raw is None:
+                continue
+            split = split_for(member.name)
+            buffered = io.BufferedReader(NonSeekableReader(raw))
+            with io.TextIOWrapper(buffered, encoding="utf-8", errors="replace") as pgn:
+                member_game_number = 0
+                while True:
+                    try:
+                        game = chess.pgn.read_game(pgn)
+                    except Exception as exc:  # Keep streaming past isolated bad games.
+                        parse_errors += 1
+                        print(f"PGN parse error in {member.name}: {exc}", file=sys.stderr)
+                        continue
+                    if game is None:
+                        break
+                    corpus_game_number += 1
+                    member_game_number += 1
+                    games_seen += 1
+                    board = game.board()
+                    result = game.headers.get("Result", "*")
+                    reservoirs: dict[int, tuple[chess.Board, int]] = {}
+                    phase_seen = {phase: 0 for phase in PHASE_NAMES}
+                    game_seed = int.from_bytes(
+                        hashlib.blake2b(
+                            f"{args.seed}:{member.name}:{member_game_number}".encode(),
+                            digest_size=8,
+                        ).digest(),
+                        "big",
+                    )
+                    game_rng = random.Random(game_seed)
+
+                    try:
+                        for ply, move in enumerate(game.mainline_moves(), start=1):
+                            board.push(move)
+                            phase = phase_of(board, ply)
+                            if counts[phase] >= quotas[phase]:
+                                continue
+                            phase_seen[phase] += 1
+                            if game_rng.randrange(phase_seen[phase]) == 0:
+                                reservoirs[phase] = (board.copy(stack=False), ply)
+                    except Exception:
+                        parse_errors += 1
+                        continue
+
+                    for phase, (candidate, ply) in reservoirs.items():
+                        if counts[phase] >= quotas[phase]:
+                            continue
+                        candidates_attempted += 1
+                        cursor = db.execute(
+                            insert_sql,
+                            position_record(
+                                candidate,
+                                split,
+                                member.name,
+                                corpus_game_number,
+                                ply,
+                                result,
+                                phase,
+                            ),
+                        )
+                        if cursor.rowcount:
+                            counts[phase] += 1
+                            inserted_since_commit += 1
+
+                    if inserted_since_commit >= args.commit_every:
+                        set_metadata(db, "games_seen", games_seen)
+                        set_metadata(db, "candidates_attempted", candidates_attempted)
+                        set_metadata(db, "parse_errors", parse_errors)
+                        db.commit()
+                        inserted_since_commit = 0
+
+                    if games_seen % args.progress_every == 0:
+                        elapsed = max(time.monotonic() - started, 0.001)
+                        total = sum(counts.values())
+                        print(
+                            f"games={games_seen:,} positions={total:,}/{args.target:,} "
+                            f"opening={counts[0]:,} middle={counts[1]:,} "
+                            f"endgame={counts[2]:,} rate={total / elapsed:,.0f} pos/s",
+                            flush=True,
+                        )
+
+                    if all(counts[p] >= quotas[p] for p in quotas):
+                        finished = True
+                        break
+
+    set_metadata(db, "games_seen", games_seen)
+    set_metadata(db, "candidates_attempted", candidates_attempted)
+    set_metadata(db, "parse_errors", parse_errors)
+    set_metadata(db, "completed_unix", int(time.time()))
+    set_metadata(db, "position_count", sum(counts.values()))
+    db.commit()
+    db.execute("PRAGMA optimize")
+    db.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+    db.close()
+    print(json.dumps(analyze_database(output), indent=2, sort_keys=True))
+
+
+def grouped(db: sqlite3.Connection, column: str) -> dict[str, int]:
+    return {
+        str(key): count
+        for key, count in db.execute(
+            f"SELECT {column}, COUNT(*) FROM positions GROUP BY {column}"
+        )
+    }
+
+
+def quantile(db: sqlite3.Connection, column: str, q: float, total: int) -> int:
+    offset = max(0, min(total - 1, round((total - 1) * q)))
+    return db.execute(
+        f"SELECT {column} FROM positions ORDER BY {column} LIMIT 1 OFFSET ?",
+        (offset,),
+    ).fetchone()[0]
+
+
+def numeric_stats(db: sqlite3.Connection, column: str, total: int) -> dict[str, float]:
+    mean, mean_square, minimum, maximum = db.execute(
+        f"SELECT AVG({column}), AVG({column} * {column}), "
+        f"MIN({column}), MAX({column}) FROM positions"
+    ).fetchone()
+    variance = max(0.0, mean_square - mean * mean)
+    return {
+        "min": minimum,
+        "p10": quantile(db, column, 0.10, total),
+        "median": quantile(db, column, 0.50, total),
+        "p90": quantile(db, column, 0.90, total),
+        "max": maximum,
+        "mean": round(mean, 4),
+        "stdev": round(math.sqrt(variance), 4),
+    }
+
+
+def normalized_entropy(counts: list[int]) -> float:
+    total = sum(counts)
+    probabilities = [count / total for count in counts if count]
+    entropy = -sum(value * math.log(value) for value in probabilities)
+    return entropy / math.log(len(counts))
+
+
+def analyze_database(path: Path) -> dict[str, object]:
+    db = sqlite3.connect(f"file:{path}?mode=ro&immutable=1", uri=True)
+    total = db.execute("SELECT COUNT(*) FROM positions").fetchone()[0]
+    if total == 0:
+        raise RuntimeError("dataset is empty")
+    phases_raw = grouped(db, "phase")
+    phases = {PHASE_NAMES[int(key)]: value for key, value in phases_raw.items()}
+    results = grouped(db, "result")
+    sides = grouped(db, "side_to_move")
+    splits = grouped(db, "source_split")
+    legal = numeric_stats(db, "legal_moves", total)
+    pieces = numeric_stats(db, "piece_count", total)
+    balance = numeric_stats(db, "material_balance", total)
+    no_castling = db.execute(
+        "SELECT COUNT(*) FROM positions WHERE castling_mask=0"
+    ).fetchone()[0]
+    with_castling = total - no_castling
+    checks = db.execute("SELECT COUNT(*) FROM positions WHERE in_check=1").fetchone()[0]
+    imbalanced = db.execute(
+        "SELECT COUNT(*) FROM positions WHERE ABS(material_balance)>=3"
+    ).fetchone()[0]
+    min_phase_share = min(phases.values()) / total
+    known_results = [results.get(key, 0) for key in ("1-0", "1/2-1/2", "0-1")]
+    min_result_share = min(known_results) / max(1, sum(known_results))
+    white_share = int(sides.get("1", 0)) / total
+
+    checks_map = {
+        "at_least_1_5m_positions": total >= 1_500_000,
+        "phase_min_share_at_least_15pct": min_phase_share >= 0.15,
+        "phase_entropy_at_least_0_85": normalized_entropy(list(phases.values())) >= 0.85,
+        "result_min_share_at_least_20pct": min_result_share >= 0.20,
+        "side_to_move_between_47_and_53pct_white": 0.47 <= white_share <= 0.53,
+        "legal_move_stdev_at_least_8": legal["stdev"] >= 8,
+        "legal_move_p10_at_most_22": legal["p10"] <= 22,
+        "legal_move_p90_at_least_38": legal["p90"] >= 38,
+        "piece_count_stdev_at_least_5": pieces["stdev"] >= 5,
+        "material_imbalance_at_least_15pct": imbalanced / total >= 0.15,
+        "both_castling_states_at_least_10pct": min(no_castling, with_castling) / total
+        >= 0.10,
+        "checks_at_least_1pct": checks / total >= 0.01,
+    }
+    metadata = dict(db.execute("SELECT key, value FROM metadata"))
+    report = {
+        "format": metadata.get("format"),
+        "database": str(path),
+        "positions": total,
+        "database_bytes": path.stat().st_size,
+        "distributions": {
+            "phase": phases,
+            "result": results,
+            "side_to_move": {"black": sides.get("0", 0), "white": sides.get("1", 0)},
+            "source_split": splits,
+            "with_castling_rights": with_castling,
+            "without_castling_rights": no_castling,
+            "in_check": checks,
+            "material_imbalance_abs_ge_3": imbalanced,
+        },
+        "numeric": {
+            "legal_moves": legal,
+            "piece_count": pieces,
+            "material_balance_white_minus_black": balance,
+        },
+        "normalized_phase_entropy": round(
+            normalized_entropy(list(phases.values())), 6
+        ),
+        "thresholds": checks_map,
+        "high_variance": all(checks_map.values()),
+        "metadata": metadata,
+    }
+    db.close()
+    return report
+
+
+def analyze(args: argparse.Namespace) -> None:
+    report = analyze_database(Path(args.database).resolve())
+    rendered = json.dumps(report, indent=2, sort_keys=True)
+    print(rendered)
+    if args.report:
+        Path(args.report).write_text(rendered + "\n", encoding="utf-8")
+
+
+def sample(args: argparse.Namespace) -> None:
+    path = Path(args.database).resolve()
+    db = sqlite3.connect(f"file:{path}?mode=ro&immutable=1", uri=True)
+    if args.id is not None:
+        row = db.execute(
+            "SELECT id, fen, phase, result FROM positions WHERE id=?", (args.id,)
+        ).fetchone()
+    else:
+        key = random.SystemRandom().randrange(1 << 63)
+        row = db.execute(
+            "SELECT id, fen, phase, result FROM positions "
+            "WHERE random_key>=? ORDER BY random_key LIMIT 1",
+            (key,),
+        ).fetchone()
+        if row is None:
+            row = db.execute(
+                "SELECT id, fen, phase, result FROM positions ORDER BY random_key LIMIT 1"
+            ).fetchone()
+    db.close()
+    if row is None:
+        raise RuntimeError("position not found")
+    print(
+        json.dumps(
+            {"id": row[0], "fen": row[1], "phase": PHASE_NAMES[row[2]], "result": row[3]},
+            separators=(",", ":"),
+        )
+    )
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(description=__doc__)
+    commands = root.add_subparsers(dest="command", required=True)
+
+    extract_cmd = commands.add_parser("extract", help="stream PGNs into VPD1")
+    extract_cmd.add_argument("--source", required=True)
+    extract_cmd.add_argument("--output", required=True)
+    extract_cmd.add_argument("--target", type=int, default=DEFAULT_TARGET)
+    extract_cmd.add_argument("--seed", type=int, default=91)
+    extract_cmd.add_argument("--commit-every", type=int, default=10_000)
+    extract_cmd.add_argument("--progress-every", type=int, default=10_000)
+    extract_cmd.set_defaults(func=extract)
+
+    analyze_cmd = commands.add_parser("analyze", help="calculate variance")
+    analyze_cmd.add_argument("database")
+    analyze_cmd.add_argument("--report")
+    analyze_cmd.set_defaults(func=analyze)
+
+    sample_cmd = commands.add_parser("sample", help="return one board immediately")
+    sample_cmd.add_argument("database")
+    sample_cmd.add_argument("--id", type=int)
+    sample_cmd.set_defaults(func=sample)
+    return root
+
+
+if __name__ == "__main__":
+    arguments = parser().parse_args()
+    arguments.func(arguments)

scripts/vpd_to_parquet.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Convert a VPD1 SQLite database to a partitioned Parquet dataset."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sqlite3
+import time
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.dataset as pads
+import pyarrow.parquet as pq
+
+
+PHASE_NAMES = {0: "opening", 1: "middlegame", 2: "endgame"}
+COLUMNS = [
+    "id",
+    "random_key",
+    "fen",
+    "source_member",
+    "game_number",
+    "ply",
+    "result",
+    "side_to_move",
+    "piece_count",
+    "non_pawn_material",
+    "material_balance",
+    "legal_moves",
+    "in_check",
+    "castling_mask",
+    "halfmove_clock",
+]
+SCHEMA = pa.schema(
+    [
+        ("id", pa.int64()),
+        ("random_key", pa.int64()),
+        ("fen", pa.string()),
+        ("source_member", pa.string()),
+        ("game_number", pa.int64()),
+        ("ply", pa.int16()),
+        ("result", pa.string()),
+        ("side_to_move", pa.int8()),
+        ("piece_count", pa.int8()),
+        ("non_pawn_material", pa.int16()),
+        ("material_balance", pa.int16()),
+        ("legal_moves", pa.int16()),
+        ("in_check", pa.bool_()),
+        ("castling_mask", pa.int8()),
+        ("halfmove_clock", pa.int16()),
+    ]
+)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        while chunk := source.read(8 * 1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def table_from_rows(rows: list[tuple[object, ...]], schema: pa.Schema) -> pa.Table:
+    arrays = []
+    for index, field in enumerate(schema):
+        values = [row[index] for row in rows]
+        if pa.types.is_boolean(field.type):
+            values = [bool(value) for value in values]
+        arrays.append(pa.array(values, type=field.type))
+    return pa.Table.from_arrays(arrays, schema=schema)
+
+
+def convert(args: argparse.Namespace) -> None:
+    source = Path(args.input).resolve()
+    output = Path(args.output).resolve()
+    if output.exists() and any(output.iterdir()):
+        raise RuntimeError(f"output directory is not empty: {output}")
+    output.mkdir(parents=True, exist_ok=True)
+
+    db = sqlite3.connect(f"file:{source}?mode=ro&immutable=1", uri=True)
+    metadata = dict(db.execute("SELECT key, value FROM metadata"))
+    schema = SCHEMA.with_metadata(
+        {
+            b"vpd_format": metadata.get("format", "unknown").encode(),
+            b"source_sha256": sha256(source).encode(),
+            b"fen_fullmove_normalization": metadata.get(
+                "fen_fullmove_normalization", "unknown"
+            ).encode(),
+        }
+    )
+    source_total = db.execute("SELECT COUNT(*) FROM positions").fetchone()[0]
+    splits = [
+        row[0]
+        for row in db.execute(
+            "SELECT DISTINCT source_split FROM positions ORDER BY source_split"
+        )
+    ]
+    manifest: dict[str, object] = {
+        "format": "VPD1-Parquet",
+        "source": str(source),
+        "source_sha256": sha256(source),
+        "compression": args.compression,
+        "compression_level": args.compression_level,
+        "row_group_size": args.row_group_size,
+        "partitioning": ["source_split", "phase"],
+        "rows": 0,
+        "partitions": [],
+    }
+    started = time.monotonic()
+
+    for split in splits:
+        for phase_id, phase_name in PHASE_NAMES.items():
+            count = db.execute(
+                "SELECT COUNT(*) FROM positions WHERE source_split=? AND phase=?",
+                (split, phase_id),
+            ).fetchone()[0]
+            if not count:
+                continue
+            partition_dir = output / f"source_split={split}" / f"phase={phase_name}"
+            partition_dir.mkdir(parents=True, exist_ok=True)
+            parquet_path = partition_dir / "positions.parquet"
+            query = (
+                f"SELECT {', '.join(COLUMNS)} FROM positions "
+                "WHERE source_split=? AND phase=? ORDER BY id"
+            )
+            cursor = db.execute(query, (split, phase_id))
+            written = 0
+            row_groups = 0
+            min_id = None
+            max_id = None
+            with pq.ParquetWriter(
+                parquet_path,
+                schema,
+                compression=args.compression,
+                compression_level=args.compression_level,
+                use_dictionary=["source_member", "result"],
+                write_statistics=True,
+            ) as writer:
+                while rows := cursor.fetchmany(args.row_group_size):
+                    table = table_from_rows(rows, schema)
+                    writer.write_table(table, row_group_size=len(rows))
+                    written += len(rows)
+                    row_groups += 1
+                    min_id = rows[0][0] if min_id is None else min_id
+                    max_id = rows[-1][0]
+            if written != count:
+                raise RuntimeError(
+                    f"partition count mismatch for {split}/{phase_name}: "
+                    f"expected {count}, wrote {written}"
+                )
+            manifest["rows"] += written
+            manifest["partitions"].append(
+                {
+                    "source_split": split,
+                    "phase": phase_name,
+                    "rows": written,
+                    "row_groups": row_groups,
+                    "min_id": min_id,
+                    "max_id": max_id,
+                    "bytes": parquet_path.stat().st_size,
+                    "file": str(parquet_path.relative_to(output)),
+                    "sha256": sha256(parquet_path),
+                }
+            )
+            print(
+                f"wrote {split}/{phase_name}: {written:,} rows, "
+                f"{parquet_path.stat().st_size / (1024 * 1024):.1f} MiB",
+                flush=True,
+            )
+
+    db.close()
+    if manifest["rows"] != source_total:
+        raise RuntimeError(
+            f"total mismatch: source has {source_total}, wrote {manifest['rows']}"
+        )
+    manifest["elapsed_seconds"] = round(time.monotonic() - started, 3)
+    # Leading underscore keeps the JSON sidecar out of PyArrow's default
+    # Parquet dataset discovery while leaving it next to the data it describes.
+    manifest_path = output / "_manifest.json"
+    manifest_path.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+
+    dataset = pads.dataset(output, format="parquet", partitioning="hive")
+    parquet_total = dataset.count_rows()
+    if parquet_total != source_total:
+        raise RuntimeError(
+            f"PyArrow validation mismatch: expected {source_total}, got {parquet_total}"
+        )
+    print(
+        json.dumps(
+            {
+                "rows": parquet_total,
+                "files": len(dataset.files),
+                "manifest": str(manifest_path),
+                "elapsed_seconds": manifest["elapsed_seconds"],
+            },
+            indent=2,
+        )
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--row-group-size", type=int, default=65_536)
+    parser.add_argument("--compression", default="zstd")
+    parser.add_argument("--compression-level", type=int, default=6)
+    convert(parser.parse_args())
+
+
+if __name__ == "__main__":
+    main()

variance-report.json

@@ -0,0 +1,88 @@
+{
+  "database": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/ccrl-high-variance-1p5m.vpd",
+  "database_bytes": 438558720,
+  "distributions": {
+    "in_check": 103519,
+    "material_imbalance_abs_ge_3": 234018,
+    "phase": {
+      "endgame": 375000,
+      "middlegame": 900000,
+      "opening": 234201
+    },
+    "result": {
+      "0-1": 456873,
+      "1-0": 570602,
+      "1/2-1/2": 481726
+    },
+    "side_to_move": {
+      "black": 751182,
+      "white": 758019
+    },
+    "source_split": {
+      "test": 307473,
+      "train": 1201728
+    },
+    "with_castling_rights": 289814,
+    "without_castling_rights": 1219387
+  },
+  "format": "VPD1",
+  "high_variance": true,
+  "metadata": {
+    "candidates_attempted": "2115584",
+    "completed_unix": "1787309415",
+    "fen_fullmove_normalization": "1",
+    "format": "VPD1",
+    "games_seen": "910462",
+    "parse_errors": "0",
+    "phase_quotas": "{\"0\": 225000, \"1\": 900000, \"2\": 375000}",
+    "position_count": "1509201",
+    "seed": "91",
+    "source": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/source/ccrl-pgn.tar.bz2",
+    "target_positions": "1500000"
+  },
+  "normalized_phase_entropy": 0.858704,
+  "numeric": {
+    "legal_moves": {
+      "max": 87,
+      "mean": 30.5172,
+      "median": 33,
+      "min": 0,
+      "p10": 12,
+      "p90": 44,
+      "stdev": 12.064
+    },
+    "material_balance_white_minus_black": {
+      "max": 75,
+      "mean": 0.0943,
+      "median": 0,
+      "min": -51,
+      "p10": -2,
+      "p90": 2,
+      "stdev": 2.6234
+    },
+    "piece_count": {
+      "max": 32,
+      "mean": 20.713,
+      "median": 21,
+      "min": 2,
+      "p10": 10,
+      "p90": 30,
+      "stdev": 7.5146
+    }
+  },
+  "positions": 1509201,
+  "thresholds": {
+    "at_least_1_5m_positions": true,
+    "both_castling_states_at_least_10pct": true,
+    "checks_at_least_1pct": true,
+    "legal_move_p10_at_most_22": true,
+    "legal_move_p90_at_least_38": true,
+    "legal_move_stdev_at_least_8": true,
+    "material_imbalance_at_least_15pct": true,
+    "phase_entropy_at_least_0_85": true,
+    "phase_min_share_at_least_15pct": true,
+    "piece_count_stdev_at_least_5": true,
+    "result_min_share_at_least_20pct": true,
+    "side_to_move_between_47_and_53pct_white": true
+  }
+}