Update README.md

README.md

@@ -14,15 +14,14 @@ Games are stored in a format that is much faster to process than the original PG
 <br>
 Requirements:
 ```
-    pip install zstandard python-chess
+    pip install zstandard python-chess datasets
 ```
 
 # Quick Guide
-In the following I help you understand the data format aswell as using the dataset. At the end, you find a complete example script.
+In the following, I explain the data format and how to use the dataset. At the end, you find a complete example script.
 
 ### 1. Loading the dataset
-You can stream the data without storing it locally (~100 GB currently).
-Note, `trust_remote_code=True` is needed to execute my [custom data loading script](https://huggingface.co/datasets/mauricett/lichess_sf/blob/main/lichess_sf.py), which is necessary to decompress the files.
+You can stream the data without storing it locally (~100 GB currently). The dataset requires `trust_remote_code=True` to execute the [custom data loading script](https://huggingface.co/datasets/mauricett/lichess_sf/blob/main/lichess_sf.py), which is necessary to decompress the files.
 See [HuggingFace's documentation](https://huggingface.co/docs/datasets/main/en/load_hub#remote-code) if you're unsure.
 ```py
 # Load dataset.
@@ -42,66 +41,42 @@ print(example)
 
 A single sample from the dataset contains one complete chess game as a dictionary. The dictionary keys are as follows:
 
-1. `example['fens']` --- A list of FENs in a slightly stripped format, missing the half-move clock aswell as the fullmove clock (see [definitions on wiki](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation#Definition))
-2. `example['moves'] --- A list of moves in [UCI format](https://en.wikipedia.org/wiki/Universal_Chess_Interface). `example['moves'][42]` is the move that led to position `example['fens'][42]`, etc.
-3. `example['scores'] --- A list of Stockfish evaluations in units of centipawns, stored as strings. If the game ended in a checkmate, stalemate or draw by insufficient material, the last elements of the list is 'C' (checkmate), 'I' (insufficient material) or 'S' (stalemate).
+1. `example['fens']` --- A list of FENs in a slightly stripped format, missing the halfmove clock and fullmove number (see [definitions on wiki](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation#Definition)). The starting positions have been excluded (no player made a move yet).
+2. `example['moves']` --- A list of moves in [UCI format](https://en.wikipedia.org/wiki/Universal_Chess_Interface). `example['moves'][42]` is the move that led to position `example['fens'][42]`, etc.
+3. `example['scores']` --- A list of Stockfish evaluations (in centipawns) from the perspective of the player who is next to move. If `example['fens'][42]` is black's move, `example['scores'][42]` will be from black's perspective. If the game ended with a terminal condition, the last element of the list is a string 'C' (checkmate), 'S' (stalemate) or 'I' (insufficient material). Games with other outcome conditions have been excluded.
 4. `example['WhiteElo'], example['BlackElo']` --- Player's Elos.
 <br>
 
-The dictionary contains 1) player's Elos, 2) all game positions as FENs, 3) all moves, 4) all Stockfish evaluations and/or the outcome condition.
-The FENs are slightly stripped. I removed the half-move clock aswell as the fullmove number. See the [definition of FEN](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation#Definition).
-```py
-fens = example['fens']
-moves = example['moves']
-scores = example['scores']
-white_elo = example['WhiteElo']
-black_elo = example['BlackElo']
-```
-Every sample drawn from the dataset will have a different number of FENs, moves and scores, but within a single sample we have
-```py
-len(fens) == len(moves) == len(scores) # True
-```
-
+Everything but Elos is stored as strings.
 
-### Usage
-To use the dataset, apply `datasets.shuffle()` and your own transformations (e.g. tokenizer) using `datasets.map()`. The latter will process individual samples in parallel if you're using multiprocessing (e.g. with PyTorch dataloader).
+### 3. Shuffle and preprocess
+Use `datasets.shuffle()` to properly shuffle the dataset. Use `datasets.map()` to transform the data to the format you require. This will process individual samples in parallel if you're using multiprocessing (e.g. with PyTorch dataloader).
 
 
 ```py
-    # Load dataset.
-    dataset = load_dataset(path="../FishData/lichess_sf_test.py",
-                           split="train",
-                           streaming=True,
-                           trust_remote_code=True)
-
-    # Shuffle and apply your own preprocessing.
-    dataset = dataset.shuffle(seed=42)
-    dataset = dataset.map(preprocess, fn_kwargs={'useful_fn': useful_fn})
+# Shuffle and apply your own preprocessing.
+dataset = dataset.shuffle(seed=42)
+dataset = dataset.map(preprocess, fn_kwargs={'useful_fn': useful_fn})
 ```
 
 For a quick working example, you can try to use the following functions:
 ```py
-    def preprocess(example, useful_fn):
-        # Get number of moves made in the game.
-        max_ply = len(example['moves']) 
-        pick_random_move = random.randint(0, max_ply)
-
-        # Get the FEN, move and score for our random choice.
-        fen = example['fens'][pick_random_move]
-        move = example['moves'][pick_random_move]
-        score = example['scores'][pick_random_move]
-
-        # Transform data into the format of your choice.
-        example['fens'] = useful_fn(fen)
-        example['moves'] = useful_fn(move)
-        example['scores'] = useful_fn(score)
-        return example
-
-    def useful_fn(example):
-        return example
-```
-
-# Data Format
-Every position of every game either has a Stockfish evaluation or an outcome condition that is either checkmate, stalemate or insufficient material.
-All other outcome conditions have been excluded from the data.
-In the FEN dataset, the starting positions have been excluded (no player made a move yet).
+def useful_fn(example):
+    return example
+
+def preprocess(example, useful_fn):
+    # Get number of moves made in the game.
+    max_ply = len(example['moves']) 
+    pick_random_move = random.randint(0, max_ply)
+
+    # Get the FEN, move and score for our random choice.
+    fen = example['fens'][pick_random_move]
+    move = example['moves'][pick_random_move]
+    score = example['scores'][pick_random_move]
+
+    # Transform data into the format of your choice.
+    example['fens'] = useful_fn(fen)
+    example['moves'] = useful_fn(move)
+    example['scores'] = useful_fn(score)
+    return example
+```