""" raw2dataset.py — Convert raw PGN data into sharded train/test .pgn.zst files. Each worker gets a subset of input files and writes its own output shards directly — no serialization bottleneck. Games are distributed round-robin across each worker's shards for variety within files. Input files are shuffled and distributed round-robin across workers so each worker gets a mix of sources. Each shard targets ~POSITIONS_PER_SHARD positions. Usage: python raw2dataset.py """ import io import time import random from pathlib import Path from multiprocessing import Pool, Value import chess.pgn import zstandard as zstd from tqdm import tqdm # ── Configuration ── RAW_DATA_DIR = Path("/home/kage/chess_workspace/chess-drive2/pgn-data/raw_data") OUTPUT_DIR = Path("/home/kage/chess_workspace/chess-drive2/ChessBot-Dataset") TRAIN_DIR = OUTPUT_DIR / "train" TEST_DIR = OUTPUT_DIR / "test" POSITIONS_PER_SHARD = 2_000_000 TEST_RATIO = 0.005 # 0.5% of games go to test ZSTD_LEVEL = 10 NUM_WORKERS = 32 def find_input_files(raw_dir: Path) -> list[Path]: """Find all .pgn and .pgn.zst files recursively.""" files = [] for pattern in ("**/*.pgn", "**/*.pgn.zst"): files.extend(raw_dir.glob(pattern)) return sorted(files) def open_pgn_reader(path: Path): """Open a .pgn or .pgn.zst file and return a text stream.""" if path.suffixes == [".pgn", ".zst"] or (path.suffix == ".zst" and ".pgn" in path.name): fb = path.open("rb") dctx = zstd.ZstdDecompressor() return io.TextIOWrapper(dctx.stream_reader(fb), encoding="utf-8", errors="replace") elif path.suffix == ".pgn": return path.open("r", encoding="utf-8", errors="replace") else: raise ValueError(f"Unsupported file: {path}") def count_positions(game) -> int: """Count positions (moves) in a game's mainline.""" return sum(1 for _ in game.mainline()) class ShardWriter: """Writes games to numbered .pgn.zst shard files, creating new ones as needed. Uses a shared counter so all workers produce sequentially numbered files.""" def __init__(self, output_dir: Path, prefix: str, positions_per_shard: int, counter): self.output_dir = output_dir self.prefix = prefix self.positions_per_shard = positions_per_shard self.counter = counter self.positions_in_shard = 0 self.writer = None self.total_positions = 0 self.total_games = 0 self.num_shards = 0 self._open_new_shard() def _next_shard_id(self) -> int: with self.counter.get_lock(): shard_id = self.counter.value self.counter.value += 1 return shard_id def _open_new_shard(self): if self.writer is not None: self.writer.close() shard_id = self._next_shard_id() path = self.output_dir / f"{self.prefix}_{shard_id:04d}.pgn.zst" fb = path.open("wb") cctx = zstd.ZstdCompressor(level=ZSTD_LEVEL) self.writer = io.TextIOWrapper(cctx.stream_writer(fb), encoding="utf-8") self.positions_in_shard = 0 self.num_shards += 1 def write_game(self, pgn_text: str, num_positions: int): if self.positions_in_shard >= self.positions_per_shard: self._open_new_shard() self.writer.write(pgn_text) self.writer.write("\n\n") self.positions_in_shard += num_positions self.total_positions += num_positions self.total_games += 1 def close(self): if self.writer is not None: self.writer.close() self.writer = None def _init_worker(train_ctr, test_ctr, file_ctr): """Store shared counters in each worker process.""" global _train_counter, _test_counter, _file_counter _train_counter = train_ctr _test_counter = test_ctr _file_counter = file_ctr def worker_process(args): """ Each worker reads its assigned input files and writes directly to its own train/test shard files. Returns stats dict. """ worker_id, input_files = args train_writer = ShardWriter(TRAIN_DIR, "train", POSITIONS_PER_SHARD, _train_counter) test_writer = ShardWriter(TEST_DIR, "test", POSITIONS_PER_SHARD, _test_counter) for path in input_files: try: with open_pgn_reader(path) as f: while (game := chess.pgn.read_game(f)) is not None: positions = count_positions(game) if positions == 0: continue exporter = chess.pgn.StringExporter(headers=True, variations=True, comments=True) pgn_text = game.accept(exporter) if random.random() < TEST_RATIO: test_writer.write_game(pgn_text, positions) else: train_writer.write_game(pgn_text, positions) except Exception as e: print(f"Worker {worker_id} error reading {path}: {e}") with _file_counter.get_lock(): _file_counter.value += 1 train_writer.close() test_writer.close() return { "worker_id": worker_id, "train_games": train_writer.total_games, "train_positions": train_writer.total_positions, "train_shards": train_writer.num_shards, "test_games": test_writer.total_games, "test_positions": test_writer.total_positions, "test_shards": test_writer.num_shards, "files_processed": len(input_files), } def main(): TRAIN_DIR.mkdir(parents=True, exist_ok=True) TEST_DIR.mkdir(parents=True, exist_ok=True) input_files = find_input_files(RAW_DATA_DIR) random.shuffle(input_files) print(f"Found {len(input_files)} input files") # Distribute input files round-robin across workers worker_files: list[list[Path]] = [[] for _ in range(NUM_WORKERS)] for i, f in enumerate(input_files): worker_files[i % NUM_WORKERS].append(f) tasks = [(wid, files) for wid, files in enumerate(worker_files) if files] print(f"Distributing across {len(tasks)} workers...") train_counter = Value('i', 0) test_counter = Value('i', 0) file_counter = Value('i', 0) total_files = len(input_files) total_train_games = total_train_positions = total_train_shards = 0 total_test_games = total_test_positions = total_test_shards = 0 with Pool(processes=len(tasks), initializer=_init_worker, initargs=(train_counter, test_counter, file_counter)) as pool: results = pool.map_async(worker_process, tasks) pbar = tqdm(total=total_files, desc="Processing files", unit="file") while not results.ready(): done = file_counter.value pbar.n = done pbar.refresh() time.sleep(0.5) pbar.n = total_files pbar.refresh() pbar.close() for stats in results.get(): total_train_games += stats["train_games"] total_train_positions += stats["train_positions"] total_train_shards += stats["train_shards"] total_test_games += stats["test_games"] total_test_positions += stats["test_positions"] total_test_shards += stats["test_shards"] print(f"\nDone!") print(f" Train: {total_train_games:,} games, {total_train_positions:,} positions, {total_train_shards} shards") print(f" Test: {total_test_games:,} games, {total_test_positions:,} positions, {total_test_shards} shards") if __name__ == "__main__": main()