| |
| """Encode the parquet shards into arrays for fast GPU training.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import glob |
| from pathlib import Path |
|
|
| import chess |
| import numpy as np |
| import pandas as pd |
| from tqdm import tqdm |
|
|
| PIECES = [chess.PAWN, chess.KNIGHT, chess.BISHOP, chess.ROOK, chess.QUEEN, chess.KING] |
|
|
|
|
| def encode_board(board: chess.Board) -> np.ndarray: |
| x = np.zeros((20, 8, 8), dtype=np.uint8) |
| for square, piece in board.piece_map().items(): |
| rank = chess.square_rank(square) |
| file = chess.square_file(square) |
| base = 0 if piece.color == chess.WHITE else 6 |
| x[base + piece.piece_type - 1, rank, file] = 1 |
|
|
| if board.turn == chess.WHITE: |
| x[12, :, :] = 1 |
|
|
| if board.has_kingside_castling_rights(chess.WHITE): |
| x[13, :, :] = 1 |
| if board.has_queenside_castling_rights(chess.WHITE): |
| x[14, :, :] = 1 |
| if board.has_kingside_castling_rights(chess.BLACK): |
| x[15, :, :] = 1 |
| if board.has_queenside_castling_rights(chess.BLACK): |
| x[16, :, :] = 1 |
|
|
| if board.ep_square is not None: |
| x[17, chess.square_rank(board.ep_square), chess.square_file(board.ep_square)] = 1 |
|
|
| x[18, :, :] = min(100, board.halfmove_clock) |
| |
| return x |
|
|
|
|
| def legal_bits(board: chess.Board) -> np.ndarray: |
| mask = np.zeros(4096, dtype=np.uint8) |
| for move in board.legal_moves: |
| mask[move.from_square * 64 + move.to_square] = 1 |
| return np.packbits(mask) |
|
|
|
|
| def value_target(cp, mate) -> float: |
| if mate is not None and not pd.isna(mate): |
| return 1.0 if float(mate) > 0 else -1.0 |
| if cp is not None and not pd.isna(cp): |
| return float(np.tanh(float(cp) / 400.0)) |
| return 0.0 |
|
|
|
|
| def build_split(paths: list[str], out_dir: Path, name: str) -> None: |
| frames = [pd.read_parquet(path) for path in paths] |
| df = pd.concat(frames, ignore_index=True) |
| n = len(df) |
| planes = np.empty((n, 20, 8, 8), dtype=np.uint8) |
| legal = np.empty((n, 512), dtype=np.uint8) |
| moves = np.empty(n, dtype=np.int32) |
| values = np.empty(n, dtype=np.float16) |
| wdls = np.empty(n, dtype=np.int8) |
|
|
| kept = 0 |
| for _, row in tqdm(df.iterrows(), total=n, desc=name): |
| try: |
| board = chess.Board(row["fen"]) |
| move = chess.Move.from_uci(row["move_uci"]) |
| except Exception: |
| continue |
| if move not in board.legal_moves: |
| continue |
| planes[kept] = encode_board(board) |
| legal[kept] = legal_bits(board) |
| moves[kept] = move.from_square * 64 + move.to_square |
| values[kept] = value_target(row.get("cp"), row.get("mate")) |
| wdls[kept] = int(row.get("wdl", 1)) |
| kept += 1 |
|
|
| planes = planes[:kept] |
| legal = legal[:kept] |
| moves = moves[:kept] |
| values = values[:kept] |
| wdls = wdls[:kept] |
|
|
| out_dir.mkdir(parents=True, exist_ok=True) |
| np.save(out_dir / f"{name}_planes.npy", planes) |
| np.save(out_dir / f"{name}_legal.npy", legal) |
| np.save(out_dir / f"{name}_move.npy", moves) |
| np.save(out_dir / f"{name}_value.npy", values) |
| np.save(out_dir / f"{name}_wdl.npy", wdls) |
| print(f"{name}: {kept:,} rows -> {out_dir}") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--data", default="data") |
| parser.add_argument("--val", default="val") |
| parser.add_argument("--out", default="prepared") |
| args = parser.parse_args() |
|
|
| out_dir = Path(args.out) |
| train_files = sorted(glob.glob(str(Path(args.data) / "*.parquet"))) |
| val_files = sorted(glob.glob(str(Path(args.val) / "*.parquet"))) |
| if not train_files: |
| raise SystemExit("no train parquet files") |
| build_split(train_files, out_dir, "train") |
| if val_files: |
| build_split(val_files, out_dir, "val") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
