File size: 2,911 Bytes
9393083
6dd4090
a72668c
 
 
 
 
 
 
 
 
 
af9ac7f
9393083
 
 
3875cb1
af9ac7f
6dd4090
56f9d69
 
a72668c
56f9d69
 
 
 
a72668c
56f9d69
 
37e3cfc
7854635
 
7a57da1
6dd4090
37e3cfc
 
 
7a57da1
6dd4090
 
 
6ac050e
37e3cfc
 
a72668c
37e3cfc
 
 
 
 
 
 
 
 
 
af5a9e0
56f9d69
a72668c
07e6790
a72668c
7a57da1
9393083
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import io
import logging
from datasets import (
    GeneratorBasedBuilder,
    DatasetInfo,
    SplitGenerator,
    Split,
    DownloadManager,
    Features,
    Value,
    Array2D,
)
from adversarial_gym.chess_env import ChessEnv
import zstandard as zstd


class ChessPGNDataset(GeneratorBasedBuilder):
    VERSION = "0.0.1"

    def _info(self):
        return DatasetInfo(
            description="Chess positions + moves + results, streamed from PGN shards",
            features=Features({
                "state":  Array2D((8,8), dtype="int8"),
                "action": Value("int16"),
                "result": Value("int8"),
            })
        )

    def _split_generators(self, dl_manager: DownloadManager):
        from pathlib import Path
        import os

        if self.config.data_dir:
            repo_root = Path(self.config.data_dir)
            train_files = [repo_root / 'train' / f for f in os.listdir(repo_root / 'train')]
            test_files  = [repo_root / 'test'  / f for f in os.listdir(repo_root / 'test')]

        elif self.config.data_files:
            train_files = self.config.data_files["train"]
            test_files  = self.config.data_files["test"]

        train_paths = dl_manager.download(train_files)
        test_paths  = dl_manager.download(test_files)

        return [
            SplitGenerator(
                name=Split.TRAIN,
                gen_kwargs={"shards": train_paths},
            ),
            SplitGenerator(
                name=Split.TEST,
                gen_kwargs={"shards": test_paths},
            ),
        ]
    
    def _generate_examples(self, shards):
        import chess.pgn
        uid = 0

        for path in shards:
            decompressor = zstd.ZstdDecompressor()
            with open(path, "rb") as compressed:
                with decompressor.stream_reader(compressed) as reader:
                    text_stream = io.TextIOWrapper(reader, encoding='utf-8')
                    while (game := chess.pgn.read_game(text_stream)) is not None:
                    # while (game := chess.pgn.read_game(f)) is not None:
                        board = game.board()
                        base = {"1-0":1,"0-1":-1}.get(game.headers["Result"], 0)
                        for move in game.mainline_moves():
                            state  = ChessEnv.get_piece_configuration(board)
                            state  = state if board.turn else -state
                            action = ChessEnv.move_to_action(move)
                            result = base * (-1 if board.turn == 0 else 1)
                            yield uid, {
                                "state":  state.astype("int8"),
                                "action": int(action),
                                "result": int(result),
                            }
                            uid += 1
                            board.push(move)