Upload folder using huggingface_hub

add_mating_data.py

@@ -0,0 +1,93 @@
+"""Annotate a .bag file that stores (FEN, move, win-probability) triples with mate-in-N information produced by Stockfish.
+
+Mate labels:
+    "#"   – the move itself gives immediate checkmate
+    +N    – mover can force mate in N plies
+    -N    – mover will be mated in N plies
+    "-"   – no forced mate detected within engine depth / time limit
+"""
+
+import argparse
+import os
+from multiprocessing import Pool, cpu_count
+
+import chess
+import chess.engine
+from tqdm import tqdm
+
+from athena.datasets.chessbenchmate.utils.bagz import BagReader, BagWriter
+from athena.datasets.chessbenchmate.utils.constants import CODERS
+
+ENGINE_PATH = "models/stockfish"
+ENGINE_LIMIT = chess.engine.Limit(time=0.05)
+
+
+def annotate_single_record(record: bytes) -> bytes:
+    """Annotate a single record with mate-in-N information."""
+    fen, move_str, win_prob = CODERS["action_value"].decode(record)
+    board = chess.Board(fen)
+    mover = board.turn
+    move = chess.Move.from_uci(move_str)
+    board.push(move)
+
+    mate_label: str | int
+
+    if board.is_checkmate():
+        mate_label = "#"
+    elif win_prob in (1.0, 0.0):
+        with chess.engine.SimpleEngine.popen_uci(ENGINE_PATH) as engine:
+            info = engine.analyse(board, ENGINE_LIMIT)
+            score = info.get("score")
+            if score and score.is_mate():
+                mate = score.pov(mover).mate()
+                mate_label = mate if mate is not None else "-"
+            else:
+                mate_label = "-"
+    else:
+        mate_label = "-"
+
+    return CODERS["action_value_with_mate"].encode((fen, move_str, win_prob, mate_label))
+
+
+def add_mate_annotations(
+    input_bag: str, output_bag: str, max_datapoints: int | None = None
+) -> None:
+    """Annotate a .bag file with mate-in-N information."""
+    reader = BagReader(input_bag)
+    writer = BagWriter(output_bag)
+
+    records = list(reader)[:max_datapoints] if max_datapoints else list(reader)
+
+    print(cpu_count(), flush=True)
+    with Pool(processes=cpu_count()) as pool:
+        for annotated_record in tqdm(
+            pool.imap(annotate_single_record, records),
+            total=len(records),
+            unit="record",
+        ):
+            writer.write(annotated_record)
+
+    writer.close()
+
+
+def main():
+    """Main entry point to parse command line arguments to add mating data to chessbench."""
+    parser = argparse.ArgumentParser(description="Annotate a .bag file with mate-in-N information.")
+    parser.add_argument("--input_bag", required=True, help="Path to input .bag file")
+    parser.add_argument("--output_bag", required=True, help="Path to output annotated .bag file")
+    parser.add_argument(
+        "--max_datapoints",
+        type=int,
+        default=None,
+        help="Maximum number of positions to analyse",
+    )
+    args = parser.parse_args()
+
+    # Ensure output directory exists
+    os.makedirs(os.path.dirname(args.output_bag), exist_ok=True)
+
+    add_mate_annotations(args.input_bag, args.output_bag, max_datapoints=args.max_datapoints)
+
+
+if __name__ == "__main__":
+    main()

dataset.py

@@ -0,0 +1,97 @@
+"""Chessbench dataset of records with a fen board position, a uci move, a win probability after the uci move is made, and a checkmate status."""
+
+import bisect
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from torch.utils.data import Dataset
+
+from athena.datasets.chessbenchmate.utils import constants
+from athena.datasets.chessbenchmate.utils.bagz import BagReader
+
+
+class ChessbenchDataset(Dataset):
+    """Chessbench dataset of records with a fen board position, a uci move, a win probability after the uci move is made, and a checkmate status."""
+
+    def __init__(self, dir: str, mode: str = "train"):
+        """Initialize the ChessbenchDataset.
+
+        Args:
+            dir: Root directory containing train/test subdirectories
+            mode: Either "train" or "test"
+        """
+        self.dir = Path(dir)
+        self.mode = mode
+        self.data_dir = self.dir / mode
+
+        # Collect and cache all bags with their lengths
+        self.bags: List[Tuple[Path, int]] = []
+        self._cumulative_lengths: List[int] = []
+        self._open_readers: Dict[Path, BagReader] = {}  # Cache for open readers
+        total_records = 0
+
+        # Find all bag files in the specified directory
+        for bag_path in sorted(self.data_dir.glob("*.bag")):
+            bag_reader = BagReader(str(bag_path))
+            bag_length = len(bag_reader)
+            self.bags.append((bag_path, bag_length))
+            total_records += bag_length
+            self._cumulative_lengths.append(total_records)
+            self._open_readers[bag_path] = bag_reader
+
+        self._total_length = total_records
+
+        if len(self.bags) == 0:
+            raise ValueError(f"No .bag files found in {self.data_dir}")
+
+    def __len__(self):
+        """Returns the total number of records in the dataset."""
+        return self._total_length
+
+    def __getitem__(self, idx) -> Tuple[str, str, float, str | int]:
+        """Gets a record from the dataset.
+
+        Args:
+            idx: The index of the record to retrieve.
+
+        Returns:
+            tuple: (fen_string, move_uci, win_probability)
+                   win_probability will be None for training data
+        """
+        if idx < 0 or idx >= len(self):
+            raise IndexError(f"Index {idx} out of range [0, {len(self)})")
+
+        # Find which bag contains this index
+        bag_idx = bisect.bisect_right(self._cumulative_lengths, idx)
+
+        # Calculate index within the specific bag
+        if bag_idx > 0:
+            idx_in_bag = idx - self._cumulative_lengths[bag_idx - 1]
+        else:
+            idx_in_bag = idx
+
+        # Get or create the reader
+        bag_path, _ = self.bags[bag_idx]
+        if bag_path not in self._open_readers:
+            self._open_readers[bag_path] = BagReader(str(bag_path))
+
+        # Get and parse the record
+        record = self._open_readers[bag_path][idx_in_bag]
+        fen, move, win_prob, mate = constants.CODERS["action_value_with_mate"].decode(record)
+        return fen, move, win_prob, mate
+
+    @property
+    def num_bags(self) -> int:
+        """Return the number of bag files in this dataset."""
+        return len(self.bags)
+
+
+if __name__ == "__main__":
+    # Example usage
+    dataset = ChessbenchDataset(dir="src/athena/datasets/chessbenchmate/data", mode="train")
+    print(f"Total records: {len(dataset)}")
+    print(f"Number of bags: {dataset.num_bags}")
+
+    for i in range(len(dataset)):
+        fen, move, win_prob, mate = dataset[i]
+        print(f"Record {i}: {fen}, {move}, {win_prob}, {mate}")

download.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+BASE_URL="https://huggingface.co/datasets/joshuakgao/chessbenchmate/resolve/main"
+
+# Download parts 000 through 117
+for i in $(seq -w 038 117); do
+    URL="${BASE_URL}/chessbenchmate.tar.part${i}"
+    echo "Downloading ${URL}"
+    wget "${URL}"
+done
+
+# Merge parts into one tar file
+cat chessbenchmate.tar.part* > chessbenchmate.tar
+
+# Extract the merged tar
+tar -xvf chessbenchmate.tar

utils/bagz.py

@@ -0,0 +1,281 @@
+"""Bagz file reader/writer and PyGrain-compatible data source for POSIX systems.
+
+Bagz is a file format for storing a sequence of string records, typically
+serialised protocol buffers. It supports fast index based look-up.
+"""
+
+import bisect
+import itertools
+import mmap
+import os
+import re
+import shutil
+import struct
+from collections.abc import Sequence
+from typing import Any, SupportsIndex
+
+import zstandard as zstd
+from typing_extensions import Self
+
+
+class BagFileReader(Sequence[bytes]):
+    """Reader for single Bagz files."""
+
+    def __init__(
+        self,
+        filename: str,
+        *,
+        separate_limits: bool = False,
+        decompress: bool | None = None,
+    ) -> None:
+        """Creates a BagFileReader.
+
+        Args:
+          filename: The name of the single Bagz file to read.
+          separate_limits: Whether the limits are stored in a separate file.
+          decompress: Whether to decompress the records. If None, uses the file
+            extension to determine whether to decompress.
+        """
+        if decompress or (decompress is None and filename.endswith(".bagz")):
+            self._process = lambda x: zstd.decompress(x) if x else x
+        else:
+            self._process = lambda x: x
+        self._filename = filename
+        fd = os.open(filename, os.O_RDONLY)
+        try:
+            self._records = mmap.mmap(fd, 0, access=mmap.ACCESS_READ)
+            file_size = self._records.size()
+        except ValueError:
+            self._records = b""
+            file_size = 0
+        finally:
+            os.close(fd)
+        if separate_limits:
+            directory, name = os.path.split(filename)
+            fd = os.open(os.path.join(directory, "limits." + name), os.O_RDONLY)
+            try:
+                self._limits = mmap.mmap(fd, 0, access=mmap.ACCESS_READ)
+                index_size = self._limits.size()
+            except ValueError:
+                self._limits = b""
+                index_size = 0
+            finally:
+                os.close(fd)
+            index_start = 0
+        else:
+            if 0 < file_size < 8:
+                raise ValueError("Bagz file too small")
+            self._limits = self._records
+            if file_size:
+                (index_start,) = struct.unpack("<Q", self._records[-8:])
+            else:
+                index_start = 0
+            assert file_size >= index_start
+            index_size = file_size - index_start
+        assert index_size % 8 == 0
+        self._num_records = index_size // 8
+        self._limits_start = index_start
+
+    def __len__(self) -> int:
+        """Returns the number of records in the Bagz file."""
+        return self._num_records
+
+    def __getitem__(self, index: SupportsIndex) -> bytes:
+        """Returns a record from the Bagz file."""
+        i = index.__index__()
+        if not 0 <= i < self._num_records:
+            raise IndexError("bagz.BragReader index out of range")
+        end = i * 8 + self._limits_start
+        if i:
+            rec_range = struct.unpack("<2q", self._limits[end - 8 : end + 8])
+        else:
+            rec_range = (0, *struct.unpack("<q", self._limits[end : end + 8]))
+        return self._process(self._records[slice(*rec_range)])
+
+
+class BagShardReader(Sequence[bytes]):
+    """Reader for sharded Bagz files."""
+
+    def __init__(
+        self,
+        filename: str,
+        *,
+        separate_limits: bool = False,
+        decompress: bool | None = None,
+    ) -> None:
+        """Creates a BagShardReader.
+
+        Args:
+          filename: The name of the sharded Bagz file to read.
+          separate_limits: Whether the limits are stored in a separate file.
+          decompress: Whether to decompress the records. If None, uses the file
+            extension to determine whether to decompress.
+        """
+        matches = re.findall(r"@(\d+)", filename)
+        assert len(matches) == 1
+        num_files = int(matches[0])
+        assert num_files < 100_000
+        self._bags = tuple(
+            BagFileReader(
+                filename=re.sub(r"@(\d+)", f"-{idx:05d}-of-{num_files:05d}", filename),
+                separate_limits=separate_limits,
+                decompress=decompress,
+            )
+            for idx in range(num_files)
+        )
+        self._accum = tuple(itertools.accumulate(map(len, self._bags)))
+
+    def __len__(self) -> int:
+        """Returns the number of records in the Bagz file."""
+        return self._accum[-1]
+
+    def __getitem__(self, index: int) -> bytes:
+        """Returns a record from the Bagz file."""
+        if index < 0:
+            index += self._accum[-1]
+        if seqn := bisect.bisect_left(self._accum, index + 1):
+            index -= self._accum[seqn - 1]
+        return self._bags[seqn][index]
+
+
+class BagReader(Sequence[bytes]):
+    """Reader for Bagz files."""
+
+    def __init__(
+        self,
+        filename: str,
+        *,
+        separate_limits: bool = False,
+        decompress: bool | None = None,
+    ) -> None:
+        """Creates a BagReader.
+
+        Args:
+          filename: The name of the Bagz file to read. Supports the @N shard syntax
+            (where @0 corresponds to the single file case). If the shard syntax does
+            not parse, then `filename` is treated as a single file.
+          separate_limits: Whether the limits are stored in a separate file.
+          decompress: Whether to decompress the records. If None, uses the file
+            extension to determine whether to decompress.
+        """
+        if matches := re.findall(r"@(\d+)", filename):
+            assert len(matches) == 1
+            if int(matches[0]) != "0":
+                reader_class = BagShardReader
+            else:
+                filename = filename.replace(matches[0], "")
+                reader_class = BagFileReader
+        else:
+            reader_class = BagFileReader
+
+        self._reader = reader_class(
+            filename=filename,
+            separate_limits=separate_limits,
+            decompress=decompress,
+        )
+
+    def __len__(self) -> int:
+        """Returns the number of records in the Bagz file."""
+        return len(self._reader)
+
+    def __getitem__(self, index: SupportsIndex) -> bytes:
+        """Returns a record from the Bagz file."""
+        return self._reader[index]
+
+
+class BagWriter:
+    """Writer for Bagz files."""
+
+    def __init__(
+        self,
+        filename: str,
+        *,
+        separate_limits: bool = False,
+        compress: bool | None = None,
+        compression_level: int = 0,
+    ) -> None:
+        """Creates a BagWriter.
+
+        Args:
+          filename: The name of the Bagz file to write.
+          separate_limits: Whether to keep the limits in a separate file.
+          compress: Whether to compress the records. If None, uses the file
+            extension to determine whether to compress.
+          compression_level: The compression level to use when compressing.
+        """
+        if compress or (compress is None and filename.endswith(".bagz")):
+            self._process = zstd.ZstdCompressor(level=compression_level).compress
+        else:
+            self._process = lambda x: x
+        self._separate_limits = separate_limits
+        directory, name = os.path.split(filename)
+        self._records = open(filename, "wb")
+        self._limits = open(os.path.join(directory, "limits." + name), "wb+")
+
+    def write(self, data: bytes) -> None:
+        """Writes a record to the Bagz file."""
+        if data:
+            self._records.write(self._process(data))
+        self._limits.write(struct.pack("<q", self._records.tell()))
+
+    def flush(self) -> None:
+        """Flushes the Bagz file."""
+        self._records.flush()
+        self._limits.flush()
+
+    def __enter__(self) -> Self:
+        """Enters the runtime context related to this object."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        """Ensures the Bagz file is closed when exiting a context."""
+        self.close()
+
+    def close(self) -> None:
+        """Concatenates the limits file to the end of the data file."""
+        if self._separate_limits:
+            self._records.close()
+            self._limits.close()
+        else:
+            self._limits.seek(0)
+            shutil.copyfileobj(self._limits, self._records)
+            self._records.close()
+            os.unlink(self._limits.name)
+            self._limits.close()
+
+
+class BagDataSource:
+    """PyGrain-compatible data source for bagz files."""
+
+    def __init__(self, path) -> None:
+        """Creates a new BagDataSource object.
+
+        Args:
+          path: The path to the bag file.
+        """
+        self._path = os.fspath(path)
+        self._reader = BagReader(self._path)
+        self._num_records = len(self._reader)
+
+    def __len__(self) -> int:
+        """Returns the number of records in the Bagz file."""
+        return self._num_records
+
+    def __getitem__(self, record_key: SupportsIndex) -> bytes:
+        """Returns a record from the Bagz file."""
+        return self._reader[record_key]
+
+    def __getstate__(self) -> dict[str, Any]:
+        """Returns the state of the BagDataSource."""
+        state = self.__dict__.copy()
+        del state["_reader"]
+        return state
+
+    def __setstate__(self, state) -> None:
+        """Restores the state of the BagDataSource."""
+        self.__dict__.update(state)
+        self._reader = BagReader(self._path)
+
+    def __repr__(self) -> str:
+        """Returns a string representation of the BagDataSource."""
+        return f"BagDataSource(path={self._path!r})"

utils/constants.py

@@ -0,0 +1,66 @@
+"""Coder that can encode an int or a char."""
+
+from apache_beam import coders
+
+
+class IntOrCharCoder(coders.Coder):
+    """A coder that can encode either an integer or a single character string."""
+
+    def encode(self, value):
+        """Encode the given value."""
+        if isinstance(value, int):
+            return b"\x00" + coders.VarIntCoder().encode(value)
+        elif isinstance(value, str) and len(value) == 1:
+            return b"\x01" + value.encode("utf-8")
+        else:
+            raise ValueError("Value must be an int or a single character string.")
+
+    def decode(self, encoded):
+        """Decode the given encoded value."""
+        if encoded[0:1] == b"\x00":
+            return coders.VarIntCoder().decode(encoded[1:])
+        elif encoded[0:1] == b"\x01":
+            return encoded[1:].decode("utf-8")
+        else:
+            raise ValueError("Invalid encoding prefix.")
+
+    def is_deterministic(self):
+        """Check if the coder is deterministic."""
+        return True
+
+
+CODERS = {
+    "fen": coders.StrUtf8Coder(),
+    "move": coders.StrUtf8Coder(),
+    "count": coders.BigIntegerCoder(),
+    "win_prob": coders.FloatCoder(),
+    "mate": IntOrCharCoder(),  # Use the custom coder here
+}
+
+CODERS["state_value"] = coders.TupleCoder(
+    (
+        CODERS["fen"],
+        CODERS["win_prob"],
+    )
+)
+CODERS["action_value"] = coders.TupleCoder(
+    (
+        CODERS["fen"],
+        CODERS["move"],
+        CODERS["win_prob"],
+    )
+)
+CODERS["action_value_with_mate"] = coders.TupleCoder(
+    (
+        CODERS["fen"],
+        CODERS["move"],
+        CODERS["win_prob"],
+        CODERS["mate"],
+    )
+)
+CODERS["behavioral_cloning"] = coders.TupleCoder(
+    (
+        CODERS["fen"],
+        CODERS["move"],
+    )
+)