|
--- |
|
dataset_info: |
|
features: |
|
- name: fen |
|
dtype: string |
|
- name: n_moves |
|
sequence: int64 |
|
- name: term_n_moves |
|
sequence: int64 |
|
- name: term_reason |
|
sequence: int64 |
|
- name: term_white_wins |
|
sequence: bool |
|
splits: |
|
- name: train |
|
num_bytes: 9224260318 |
|
num_examples: 100000054 |
|
download_size: 4539320801 |
|
dataset_size: 9224260318 |
|
configs: |
|
- config_name: default |
|
data_files: |
|
- split: train |
|
path: data/train-* |
|
--- |
|
|
|
# 100M Random Chess Boards |
|
|
|
This dataset contains 100 million randomly sampled chess board positions. The process to generate each board state is as follows: |
|
|
|
1. **Game Simulation** |
|
- 100 million games were played, with each move being randomly determined until the game ended (i.e., until checkmate, stalemate, or draw). |
|
2. **Board Sampling** |
|
- From each game, a single random board state was selected at some point in the game. |
|
|
|
Columns other than **fen** represent statistics for the sample. Most boards are sampled only once, however for example, the most common board, the initial board, is sampled 378,310 times. This comprises a single row with each column other than **fen** being 378,310 long. |
|
|
|
# Columns |
|
|
|
- **fen**: The FEN (Forsyth-Edwards Notation) representing the randomly sampled board position. |
|
- **n_moves**: The number of moves made from the start of the game to reach the sampled FEN position. |
|
- **term_n_moves**: The total number of moves in the random game before it terminated. |
|
- **term_reason**: The reason the game ended. ([Codes](https://python-chess.readthedocs.io/en/latest/core.html#chess.Termination)) |
|
- **term_white_wins**: Indicates whether white won the game (true/false). null indicates a tie. Note that all games are complete, but the sampled board position is from an intermediate point. |
|
|
|
# Code |
|
|
|
```python3 |
|
from tqdm import tqdm |
|
import collections |
|
import chess |
|
import random |
|
from datasets import Dataset |
|
|
|
import os |
|
from multiprocessing import Process, Queue |
|
|
|
|
|
def random_fen(): |
|
""" |
|
Play random game to completion |
|
backtrack random uniform number of moves |
|
""" |
|
board = chess.Board() |
|
num_moves = 0 |
|
while True: |
|
board.push(random.choice(list(board.legal_moves))) |
|
num_moves += 1 |
|
if board.is_game_over(): |
|
outcome = board.outcome() |
|
revert_moves = random.randint(0, num_moves) |
|
for _ in range(revert_moves): |
|
board.pop() |
|
fen_num_moves = num_moves - revert_moves |
|
termination_reason = outcome.termination.value |
|
white_is_winner = outcome.winner |
|
return board.fen(), fen_num_moves, num_moves, termination_reason, white_is_winner |
|
|
|
|
|
def batched_random_fen(queue, batch_size=100): |
|
while True: |
|
fens = [] |
|
while len(fens) < batch_size: |
|
fens.append(random_fen()) |
|
queue.put(fens) |
|
|
|
|
|
def generate_fens_parallel(N): |
|
all_fens = collections.defaultdict( |
|
lambda: {"n_moves": [], "term_n_moves": [], "term_reason": [], "term_white_wins": []} |
|
) |
|
queue = Queue() |
|
num_workers = os.cpu_count() // 2 |
|
|
|
# Start worker processes in advance |
|
workers = [] |
|
for _ in range(num_workers): |
|
worker = Process(target=batched_random_fen, args=(queue,)) |
|
worker.daemon = True # Ensures the process terminates with the main process |
|
workers.append(worker) |
|
worker.start() |
|
|
|
with tqdm(total=N, desc="FENs Captured") as pbar: |
|
for i in range(1_000_000_000_000): |
|
for fen, board_num_moves, final_state_num_moves, final_result, final_is_white_winner in queue.get(): |
|
all_fens[fen]["n_moves"].append(board_num_moves) |
|
all_fens[fen]["term_n_moves"].append(final_state_num_moves) |
|
all_fens[fen]["term_reason"].append(final_result) |
|
all_fens[fen]["term_white_wins"].append(final_is_white_winner) |
|
|
|
if i % 100 == 0: |
|
pbar.n = len(all_fens) |
|
pbar.last_print_n = len(all_fens) |
|
pbar.refresh() |
|
|
|
if len(all_fens) >= N: |
|
break |
|
|
|
# Terminate workers |
|
for worker in workers: |
|
worker.terminate() |
|
|
|
# flatten |
|
return [{"fen": k, **v} for k, v in all_fens.items()] |
|
|
|
|
|
if __name__ == "__main__": |
|
board_dicts = list(generate_fens_parallel(100_000_000)) |
|
ds = Dataset.from_dict({key: [dic[key] for dic in board_dicts] for key in board_dicts[0]}) |
|
ds.save_to_disk("random_uniform_chess_boards.hf") |
|
# ds = datasets.load_from_disk("random_uniform_chess_boards.hf") |
|
# ds.push_to_hub(...) |
|
``` |
|
|
