update for lc0 train data

ChessBot-Dataset.py

@@ -10,6 +10,7 @@ from datasets import (
     Value,
     Array2D,
 )
+import chess
 from adversarial_gym.chess_env import ChessEnv
 import zstandard as zstd
 
@@ -22,9 +23,10 @@ class ChessPGNDataset(GeneratorBasedBuilder):
         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"),
+                "state":       Array2D((8,8), dtype="int8"),
+                "action":      Value("int16"),
+                "best_action": Value("int16"),  # -1 if not available
+                "result":      Value("float32"),
             })
         )
 
@@ -54,6 +56,33 @@ class ChessPGNDataset(GeneratorBasedBuilder):
                 gen_kwargs={"shards": test_paths},
             ),
         ]
+    
+    @staticmethod
+    def _parse_comment(comment, board):
+        """Parse a move comment like '-0.2779' or '0.52 e2e4'.
+        Returns (q_val or None, best_action or -1).
+        q_val is float in [-1, 1] relative to side-to-move.
+        best_action is the action index of the best move, or -1 if absent."""
+        if not comment:
+            return None, -1
+        parts = comment.split()
+        if not parts:
+            return None, -1
+        # First token must be a number
+        first = parts[0]
+        try:
+            q_val = float(first)
+        except ValueError:
+            return None, -1
+        if len(parts) < 2:
+            return q_val, -1
+        # Second token is a UCI best move — must be legal
+        best_move = chess.Move.from_uci(parts[1])
+        assert best_move in board.legal_moves, \
+            f"best move {parts[1]} not legal in {board.fen()}"
+        best_action = int(ChessEnv.move_to_action(best_move))
+        return q_val, best_action
+
     def _generate_examples(self, shards):
         import chess.pgn
         uid = 0
@@ -64,18 +93,24 @@ class ChessPGNDataset(GeneratorBasedBuilder):
                 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():
+                        header_result = {"1-0":1,"0-1":-1}.get(game.headers.get("Result",""), 0)
+                        for node in game.mainline():
+                            move = node.move
+                            # Parse annotated Q-value and best move from comment
+                            q_val, best_action = self._parse_comment(node.comment, board)
+                            if q_val is not None:
+                                result = q_val
+                            else:
+                                result = float(header_result * (-1 if board.turn == 0 else 1))
                             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),
+                                "state":       state.astype("int8"),
+                                "action":      int(action),
+                                "best_action": int(best_action),
+                                "result":      float(result),
                             }
                             uid += 1
                             board.push(move)

raw2dataset.py

@@ -1,244 +1,213 @@
-from multiprocessing import Pool
-import os
-import shutil, random, io
+"""
+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 itertools import cycle
-import subprocess
-import tarfile
-import tempfile
+from multiprocessing import Pool, Value
+
 import chess.pgn
 import zstandard as zstd
 from tqdm import tqdm
 
-RAW_DATA_DIR   = Path("raw_data")
-LC0_TEST_DIR   = RAW_DATA_DIR / "lc0-test"
-NUM_TEST_FILES = 1
-TRAIN_DIR      = Path("train")
-TEST_DIR       = Path("test")
-ZSTD_LEVEL     = 10
-GAMES_PER_SHARD = 100000  # As requested: -#100000
-PROCESS_COUNT = 25
-
-
-def open_pgn_stream(path: Path):
-    if path.suffix == '.pgn':
-        return path.open('r', encoding='utf-8')
-    elif path.suffix == '.zst':
-        fb   = path.open('rb')
-        dctx = zstd.ZstdDecompressor()
-        return io.TextIOWrapper(dctx.stream_reader(fb), encoding='utf-8')
-    else:
-        raise ValueError(f"Unsupported extension: {path.suffix}")
-
+# ── 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"
 
-def open_append_writers(shards, level):
-    writers = []
-    for p in shards:
-        fb   = p.open('ab')
-        cctx = zstd.ZstdCompressor(level=level)
-        writers.append(io.TextIOWrapper(cctx.stream_writer(fb), encoding='utf-8'))
-    return writers
+POSITIONS_PER_SHARD = 2_000_000
+TEST_RATIO          = 0.005      # 0.5% of games go to test
+ZSTD_LEVEL          = 10
+NUM_WORKERS         = 32
 
 
-def prepare_train_test_dirs():
-    TRAIN_DIR.mkdir(exist_ok=True)
-    TEST_DIR.mkdir(exist_ok=True)
+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 _worker_split_zst_with_pgn_extract(args):
-    """
-    Worker function for the multiprocessing pool. It correctly handles pgn-extract's
-    behavior by changing the working directory for isolation.
-    """
-    input_path, games_per_shard = args
-    final_shard_paths = []
-    
-    # Each worker gets a unique temporary directory to work in.
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_dir_path = Path(temp_dir)
-        # The decompressed file will live inside this temp directory.
-        temp_pgn_path = temp_dir_path / "decompressed.pgn"
-
-        # 1. Decompress the source .zst into the temporary directory.
+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()
-        with input_path.open('rb') as f_in, temp_pgn_path.open('wb') as f_out:
-            dctx.copy_stream(f_in, f_out)
-        
-        # --- CRITICAL SECTION for correct pgn-extract usage ---
-        original_cwd = Path.cwd()
-        try:
-            # 2. Change into the temporary directory. This isolates the pgn-extract output.
-            os.chdir(temp_dir_path)
-
-            # 3. Run pgn-extract. It will create 1.pgn, 2.pgn, etc. *here*.
-            # We only need to pass the filename, as we are in its directory.
-            command = [
-                "pgn-extract",
-                f"-#{games_per_shard}",
-                temp_pgn_path.name  # "decompressed.pgn"
-            ]
-            
-            # This command is now correct according to the documentation.
-            subprocess.run(command, check=True, capture_output=True, text=True, encoding='latin-1')
-        except FileNotFoundError:
-            print("ERROR: 'pgn-extract' command not found. Please install it and ensure it is in your system's PATH.")
-            raise
-        except subprocess.CalledProcessError as e:
-            print(f"--- ERROR during pgn-extract for {input_path.name}: ---\n{e.stderr}\n---")
-            raise
-        finally:
-            os.chdir(original_cwd)
-        # --- END CRITICAL SECTION ---
-
-        split_pgn_files = sorted(
-            [p for p in temp_dir_path.glob("*.pgn") if p.stem.isdigit()],
-            key=lambda p: int(p.stem)
-        )
-        
-        # 6. Re-compress each shard to a unique .zst file in the original script directory.
+        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)
-        for pgn_shard_path in split_pgn_files:
-            final_zst_path = Path(f"{input_path.stem}_part_{pgn_shard_path.stem}.pgn.zst")
-            with pgn_shard_path.open('rb') as f_in, final_zst_path.open('wb') as f_out:
-                cctx.copy_stream(f_in, f_out)
-            final_shard_paths.append(final_zst_path)
-            
-    # The temp directory and its contents (decompressed.pgn, 1.pgn, etc.) are now deleted.
-    return final_shard_paths
-
-
-def resplit_test_files(test_files, games_per_split):
+        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):
     """
-    Re-splits each test .pgn.zst file into smaller chunks sequentially.
-
-    Args:
-        test_files (list of Path): Paths to the original test shards.
-        games_per_split (int): Number of games per new shard.
-
-    Returns:
-        List[Path]: List of newly created smaller test shard paths.
+    Each worker reads its assigned input files and writes directly to its own
+    train/test shard files. Returns stats dict.
     """
-    print(f"\nResplitting {len(test_files)} test shard(s) into smaller shards...")
+    worker_id, input_files = args
 
-    new_test_shards = []
-    for test_file in tqdm(test_files, desc="Resplitting test shards"):
-        smaller_shards = _worker_split_zst_with_pgn_extract((test_file, games_per_split))
-        new_test_shards.extend(smaller_shards)
-        test_file.unlink()  # Remove original file
+    train_writer = ShardWriter(TRAIN_DIR, "train", POSITIONS_PER_SHARD, _train_counter)
+    test_writer = ShardWriter(TEST_DIR, "test", POSITIONS_PER_SHARD, _test_counter)
 
-    return new_test_shards
+    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 split_and_distribute_files():
-    """
-    Finds all .pgn.zst files, splits them into shards of 100,000 games each,
-    and distributes the resulting .pgn.zst shards into train/ and test/ folders.
-    
-    Returns:
-        A tuple containing two lists: (train_shard_paths, test_shard_paths)
-    """
-    prepare_train_test_dirs()
-
-    all_zst_inputs = list(LC0_TEST_DIR.rglob("*.zst"))
-    if not all_zst_inputs:
-        print(f"No .zst files found in {LC0_TEST_DIR}. Cannot perform Step 1.")
-        return [], []
-        
-    print(f"Found {len(all_zst_inputs)} source .pgn.zst files. Starting split process...")
-
-    tasks = [(path, GAMES_PER_SHARD) for path in all_zst_inputs]
-    
-    all_new_shards = []
-    with Pool(processes=PROCESS_COUNT) as pool:
-        for shards in tqdm(pool.imap(_worker_split_zst_with_pgn_extract, tasks),
-                           total=len(tasks),
-                           desc="Splitting source files"):
-            all_new_shards.extend(shards)
-
-    print(f"\nCreated a total of {len(all_new_shards)} new shards.")
-
-    # --- Distribution Logic ---
-    random.shuffle(all_new_shards)
-    test_selection = all_new_shards[:NUM_TEST_FILES]
-    train_selection = all_new_shards[NUM_TEST_FILES:]
-
-    print(f"Moving {len(train_selection)} shards to train/ and {len(test_selection)} to test/...")
-
-    for shard in train_selection:
-        shutil.move(str(shard), TRAIN_DIR / shard.name)
-
-    intermediate_test_paths = []
-    for shard in test_selection:
-        final_path = TEST_DIR / shard.name
-        shutil.move(str(shard), final_path)
-        intermediate_test_paths.append(final_path)
-
-    # Final re-split of test file(s)
-    resplit_test_shards = resplit_test_files(intermediate_test_paths, GAMES_PER_SHARD // 10)
-
-    for shard in resplit_test_shards:
-        shutil.move(str(shard), TEST_DIR / shard.name)
-
-    final_train_paths = [TRAIN_DIR / s.name for s in train_selection]
-    final_test_paths = [TEST_DIR / s.name for s in resplit_test_shards]
-
-    return final_train_paths, final_test_paths
-
-
-
-def get_pgn_file_paths(input_dir):
-    return list(Path(input_dir).rglob("*.pgn"))
-
-
-def distribute_games_to_zst_shards(pgn_paths, train_shards, test_shards, split_ratio=0.01):
-    train_writers = open_append_writers(train_shards, level=ZSTD_LEVEL)
-    test_writers  = open_append_writers(test_shards, level=ZSTD_LEVEL)
-
-    train_cycle = cycle(train_writers)
-    test_cycle  = cycle(test_writers)
-
-    total_games = 0
-    for path in pgn_paths:
-        with open_pgn_stream(path) as f:
-            games_iter = iter(lambda: chess.pgn.read_game(f), None)
-            for game in tqdm(games_iter,
-                             desc=f"Distributing games from {path.name}",
-                             unit="game"):
-                total_games += 1
-                if random.random() < split_ratio:
-                    w = next(test_cycle)
-                else:
-                    w = next(train_cycle)
-                exporter = chess.pgn.FileExporter(w)
-                game.accept(exporter)
-
-    for w in train_writers + test_writers:
-        w.close()
-
-def compress_raw_data_zst():
-    """Creates raw_data.tar.zst with Zstd(level=ZSTD_LEVEL) compression."""
-    zst_path = RAW_DATA_DIR.with_suffix('.tar.zst')
-    cctx     = zstd.ZstdCompressor(level=ZSTD_LEVEL)
-
-    with cctx.stream_writer(zst_path.open('wb')) as zst_writer:
-        # Build a streaming tar over that writer
-        with tarfile.open(fileobj=zst_writer, mode='w|') as tar:
-            for path in tqdm(RAW_DATA_DIR.rglob("*"),
-                             desc="Archiving raw_data",
-                             unit="file"):
-                # Add each file/dir under raw_data into the tar
-                tar.add(path, arcname=path.relative_to(RAW_DATA_DIR.parent))
 
 def main():
-    print("Step 1: Split & distribute .pgn.zst → train/test")
-    train_shards, test_shards = split_and_distribute_files()
-
-    print("\nStep 2: Distribute remaining .pgn files")
-    all_pgns     = get_pgn_file_paths(RAW_DATA_DIR)
-   
-    print(f"Found {len(all_pgns)} .pgn files. Starting distribution process...")
-    distribute_games_to_zst_shards(all_pgns, train_shards, test_shards)
+    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")
 
-    print("\n✅ Pipeline complete.")
 
 if __name__ == "__main__":
     main()

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_1.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f4acfac23dcf2b90f8ee6d2775d303a239900ab45e318b31d21140cdf3a6d37a
-size 4494116

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_10.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d5e95577df6805d4512973f75f1486fb20407ad44cb86370eb9e51203803af1
-size 4476105

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_2.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9ac7e3f244515ab41a390d5e520505d6e89b067a18dacf1e95bdd8a8062e27aa
-size 4459504

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_3.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b02bee28b966caa5de4a7ea6fae0df06595c9861641c3dcea96f7474c60511d5
-size 4511345

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_4.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:00977ac871e4ed45612e7bfeba1b9d110c2bd1245c9a2353058784975b52e1ff
-size 4512137

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_5.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6babf98590982c9293e37f4bd396be2d0e13a4b54b3be5682f03bddd8907bb70
-size 4519850

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_6.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1093bd94cdb5eea35fd6067fdf90f30f053e8514391cb090e281694d93f8b9fc
-size 4510892

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_7.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:67dbbb7e1ae9f44e8fa69d809cfc281a70a01c74ee8175219bb296174db34159
-size 4464680

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_8.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:16c7bd6f6e40b1315d9ec8b5e9520758f226105279f7808f12952a72597c453e
-size 4466912

test/pgns-run1-test80-20220503-0054.pgn_part_2.pgn_part_9.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0ff4c35b28ca8e590a88b57764f1933cf23e092f06d998e0f9d19e6bfacec4db
-size 4474734

test/test_0000.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ecba21b52337ce054ab97a10053babc2f4d7265a06a362013301755577465a8
+size 4783995

test/test_0001.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43857857de81dfbcd482d3f86b5db958cb45feb3445cbc48256bb643ca3cfc2f
+size 5317083

test/test_0002.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0611a561f48da1fc34e04c93ad213b8a07ba6f64a3e7acc2328854f83840f641
+size 5916861

test/test_0003.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a07ac10d65e530fd572b748e44898888a2ea5d0ea8aaa9794a882176358e793
+size 5015013

test/test_0004.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2e6e1ad42f71bb80924ae2ce38de0cb22113c45ee7b5546095c74cf78c22e88
+size 5183179

test/test_0005.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:999d06d78979e6bb583178794b3ba790a59751010ba39c8375c04adf589fc5f6
+size 5190918

test/test_0006.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:004d680775b691ddf4bbaaf3f0e4919fa903ed5d6acfa9dfffcb4c0da1ad3a6a
+size 4464981

test/test_0007.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88579f00ca2b2b59dca5bdfdf9779db80307970d13b4ed344ef6789758302b0c
+size 5556966

test/test_0008.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12a452093c45679db39036771069182cdc3acf5b05a4d6bc2030e1f35af71883
+size 6260120

test/test_0009.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7dfa643ea28ebf655275ff300046147740cd1e5d7e91a9dfd2e245aea681be3
+size 5578089

test/test_0010.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9332656f3aab8afe0b39b1e985a90de0f9d41123a6630e184b65d58b3799e23
+size 5612755

test/test_0011.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b93f16b9ad83a072b368a1426bc807737eecae7238a41c479c3bbe624c758e2
+size 4179410

test/test_0012.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d48791e2438feafbe78eed7ee0806458a2b25c2efdb9b6d89c8d039e7fd7e14c
+size 5781650

test/test_0013.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a4b826470cc33293d312d999a7d39431ba13da0778d12cf0587774770ea5f79
+size 5448820

test/test_0014.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19481175dfc1d83b06a42e66331b62f2f022d33b3352551e96d6dd700fe77bf9
+size 5769669

test/test_0015.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4da2a027f329462c394eafbe98c132c6d0588a22ad278250c692defcf584df2
+size 5083758

test/test_0016.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a333a82a13b0d09105633c5bc59be930cccccac9366694f45ae6d32f4d1a4b0
+size 6065628

test/test_0017.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dcfd24d4c95f5a7d1b2ca4cffafb03cceab3a5bebc4978bd70f5a53f32f9049f
+size 4381030

test/test_0018.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e91c4019eae7449d134d6182d982a5e7156bb3289ee80c945ac524393d0f592
+size 4670719

test/test_0019.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c627d2e1f133ed517a804480fb187407bde4845e8183caf3923fc81c7de6262
+size 5576662

test/test_0020.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ee55ccde558affffc0a78490ff2b0dc2a43e3f7c78fa085c1eab52f0a871f80
+size 4216012

test/test_0021.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f14b585e67b9a7b2c91af8d445f05b43d4035c1afe0640e4f346e97aad8b34a0
+size 5905784

test/test_0022.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27ac5750bbeb690fe3991e79e8685c782755f007aef7344f0827ab1cc922f45b
+size 5412100

test/test_0023.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b40d1ddde5189d7f14d682a32da4ee81251905d9e49f76d535d7c5218e7c8a0d
+size 5297789

test/test_0024.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c639343e1b3e7d2f53b0ea7ffa9c31a760d7208c2d08e9027eab54fd2bfa73e
+size 5243005

test/test_0025.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9114745499efe64d3cfdb15fdd1d4762bd60f69a0e76b67e98befbdab33f7e4
+size 4995279

test/test_0026.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15ac91a88ea0310c260d99f880fb74ed99b5dfe978b53463275ccf7a8908b5a8
+size 5797037

test/test_0027.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9daa5eb9d4a25cc16595b7f21b70f688429dca1e95682d7aa08c7e8af3d908f0
+size 4805686

test/test_0028.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdedb88f9d9a359669c9a39896352e4dcbab4b797c301d19ff4b4a019c4e7973
+size 5087590

test/test_0029.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90f727cc9b8924e7648abac260f36a74dabe736d46e9992c55eaced1552ff26a
+size 5050953

test/test_0030.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f30ba033dea3210a850a9caca562ebf7a13cd85576bd4a051fb959705d27a611
+size 5336609

test/test_0031.pgn.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72608d49c0cc62cb2fec8d06f5b6d205fe7e12a68b8d52fa736ea5267d6c5eef
+size 5079960

train/pgns-run1-test80-20220404-0654.pgn_part_1.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0291d3b461ee4d56da60f4cc7d7c9a91d021087d4d43e63c8419e0cdc59cae26
-size 1939586

train/pgns-run1-test80-20220404-1254.pgn_part_1.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a50fe0e681614beffd3d9fdee0eddace13b245e08a6e47d83a4242f29b0d5ac9
-size 23873124

train/pgns-run1-test80-20220404-1254.pgn_part_2.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b747562d4f08f7d5a59c40e1211267298706f51611291e9659341b8b8428c887
-size 7159525

train/pgns-run1-test80-20220404-1854.pgn_part_1.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0c8690b4b1e96008d370b8f39f537d71e3b79373498b56b189917aabf002cdc6
-size 23811945

train/pgns-run1-test80-20220404-1854.pgn_part_2.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5d4449aa97fcc9d59fbc36b7ec74e66ceffabf0fb46fae90f1649455ff827aa4
-size 23771060

train/pgns-run1-test80-20220404-1854.pgn_part_3.pgn.zst

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8e85bcfd48083b8a0ade5b8f0b6774adb28e42d46c4ba152d60d0f045aac7825
-size 14511122