metadata

license: cc0-1.0
tags:
  - chess
  - stockfish
pretty_name: Lichess Games With Stockfish Analysis

Condensed Lichess Database

This dataset is a condensed version of the Lichess database. It only includes games for which Stockfish evaluations were available. Currently, the dataset contains the entire year 2023, which consists of >100M games and >1B positions. Games are stored in a format that is much faster to process than the original PGN data.

Requirements:

    pip install zstandard python-chess datasets

Quick Guide

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). The dataset requires trust_remote_code=True to execute the custom data loading script, which is necessary to decompress the files. See HuggingFace's documentation if you're unsure.

# Load dataset.
dataset = load_dataset(path="mauricett/lichess_sf",
                       split="train",
                       streaming=True,
                       trust_remote_code=True)

2. Data Format

After loading the dataset, you can check how the samples look like:

example = next(iter(dataset))
print(example)

A single sample from the dataset contains one complete chess game as a dictionary. The dictionary keys are as follows:

example['fens'] --- A list of FENs in a slightly stripped format, missing the halfmove clock and fullmove number (see definitions on wiki). The starting positions have been excluded (no player made a move yet).
example['moves'] --- A list of moves in UCI format. example['moves'][42] is the move that led to position example['fens'][42], etc.
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 turn, 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.
example['WhiteElo'], example['BlackElo'] --- Player's Elos.

Everything but Elos is stored as strings.

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).

# Shuffle and apply your own preprocessing.
dataset = dataset.shuffle(seed=42)
dataset = dataset.map(preprocess, fn_kwargs={'tokenizer': tokenizer,
                                             'score_fn': score_fn})

In this example, we're passing two additional arguments to the preprocess function in dataset.map(). You can use the following mock examples for inspiration:

# A mock tokenizer and functions for demonstration.
class Tokenizer:
    def __init__(self):
        pass
    def __call__(self, example):
        return example

# Transform Stockfish score and terminal outcomes.
def score_fn(score):
    return score

def preprocess(example, tokenizer, score_fn):
    # Get number of moves made in the game.
    max_ply = len(example['moves']) 
    pick_random_move = random.randint(0, max_ply-1)

    # 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'] = tokenizer(fen)
    example['moves'] = tokenizer(move)
    example['scores'] = score_fn(score)
    return example

tokenizer = Tokenizer()

Complete Example

You can try pasting this into Colab and it should work fine. Have fun!

import random
from datasets import load_dataset
from torch.utils.data import DataLoader

# A mock tokenizer and functions for demonstration.
class Tokenizer:
    def __init__(self):
        pass
    def __call__(self, example):
        return example

def score_fn(score):
    # Transform Stockfish score and terminal outcomes.
    return score

def preprocess(example, tokenizer, score_fn):
    # Get number of moves made in the game.
    max_ply = len(example['moves']) 
    pick_random_move = random.randint(0, max_ply-1)

    # 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'] = tokenizer(fen)
    example['moves'] = tokenizer(move)
    example['scores'] = score_fn(score)
    return example


tokenizer = Tokenizer()

# Load dataset.
dataset = load_dataset(path="mauricett/lichess_sf",
                       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={'tokenizer': tokenizer,
                                             'score_fn': score_fn})

# PyTorch dataloader
dataloader = DataLoader(dataset, batch_size=256, num_workers=4)


n = 0
for batch in dataloader:

    # do stuff

    n += 1
    print(n)
    if n == 50:
        break