README.md

---
license: cc-by-4.0
task_categories:
- text-generation
- reinforcement-learning
language:
- en
tags:
- chess
- uci
- transformer
- games
- elite
- lichess
- tokenized
size_categories:
- 1M<n<10M
---

# chess-elite-uci

A transformer-ready dataset of ~7.8 million elite chess games, pre-tokenized in UCI notation with a deterministic 1977-token vocabulary. Built for training chess language models directly with no preprocessing required.

## Dataset Summary
| Field | Value |
|---|---|
| Total games | 7,805,503 |
| Average sequence length | 94.24 tokens |
| Max sequence length | 255 tokens |
| Vocabulary size | 1,977 tokens |
| Mean combined Elo | 5,211 (~2,606 per player) |

## Sources

**Lichess Elite Database** (June 2020 – November 2025)
Games where both players are rated 2500+ vs 2300+ (2022 onwards: 2500+ vs 2300+; prior: 2400+ vs 2200+). Source: [database.nikonoel.fr](https://database.nikonoel.fr). Licensed CC0.

## Vocabulary

The vocabulary contains **1,977 tokens** and is fully deterministic and enumerated from chess geometry, not derived from data. It will never produce OOV tokens for any legal chess game.

| ID | Token | Description
|---|---|---|
| 0 | `<PAD>` | Padding
| 1 | `<W>` | POV token: white wins / white side for draws |
| 2 | `<B>` | POV token: black wins / black side for draws |
| 3 | `<CHECKMATE>` | Terminal: game ended in checkmate |
| 4 | `<RESIGN>` | Terminal: losing side resigned (≥ 40 ply) |
| 5 | `<STALEMATE>` | Terminal: draw by stalemate |
| 6 | `<REPETITION>` | Terminal: draw by threefold repetition |
| 7 | `<FIFTY_MOVE>` | Terminal: draw by 50-move rule |
| 8 | `<INSUFF_MATERIAL>` | Terminal: draw by insufficient material |
| 9+ | a1a2 … h7h8q | 1968 UCI move strings, sorted lexicographically |


The full vocabulary is provided in `vocab.json` as `{ token_str: int_id }`.

## Sequence Format

Every game is encoded as a flat list of integer token IDs:
```
[ <POV> | m1 | m2 | m3 | ... | mN | <TERMINAL> ]
```

- **POV token** (position 0): `<W>` if white wins, `<B>` if black wins. For draws, assigned randomly 50/50 between `<W>` and `<B>`.
- **Move tokens** (positions 1 to N): UCI half-moves alternating white/black, e.g. `e2e4`, `e7e5`, `g1f3`, `e1g1` (castling), `e7e8q` (promotion).
- **Terminal token** (position N+1): encodes why the game ended.

Maximum sequence length is **255 tokens** (1 POV + 253 moves + 1 terminal). Sequences are variable length, pad to 255 with `<PAD>` (ID 0) in your DataLoader.

## NTP Loss Mask

The `ntp_mask` column contains a binary list of the same length as `token_ids`. It indicates which positions should have next-token-prediction (NTP) loss applied during training:
```
Position           NTP loss
─────────────────────────────
POV token          1  (always)
Winning side move  1
Losing side move   0  (context only)
Terminal token     1  (always)
Draw game moves    1  (both sides, since neither lost)
```

This implements win-conditioned training: the model learns to predict the winning side's moves given the POV token, while still attending to the losing side's moves as context.

Usage in PyTorch:
```python
loss = cross_entropy(logits, labels, reduction="none")
loss = (loss * ntp_mask).sum() / ntp_mask.sum()
```

## Filtering

Games were filtered as follows before inclusion:

**Decisive games (1-0 / 0-1):**
- **Checkmates**: verified by `board.is_checkmate()` on the final position. No length minimum.
- **Resignations**: not checkmate, minimum 40 halfmoves (20 moves each side).

**Draws (1/2-1/2):**
- Only **forced draws** are included: stalemate, insufficient material, 50-move rule, threefold repetition.
- Draw-by-agreement is excluded (`board.is_game_over(claim_draw=True)` must return True).

**All games:**
- Maximum 253 halfmoves (fits within 255-token sequence budget).
- Both player Elo values must be present and non-zero.
- All moves must be legally parseable by python-chess.

**Game type breakdown:**

| Type | Count | % |
|---|---|---|
| White checkmate | 1,702,751 | 21.8% |
| White resignation | 2,000,000 | 25.6% |
| Black checkmate | 1,702,752 | 21.8% |
| Black resignation | 2,000,000 | 25.6% |
| Forced draw | 400,000 | 5.1% |

## Schema
```python
{
    "white_elo":    int32,        # white player Elo
    "black_elo":    int32,        # black player Elo
    "combined_elo": int32,        # white_elo + black_elo
    "result":       string,       # "1-0", "0-1", or "1/2-1/2"
    "game_type":    string,       # "checkmate", "resignation", or "forced_draw"
    "pov":          string,       # "<W>" or "<B>"
    "terminal":     string,       # "<CHECKMATE>", "<RESIGN>", "<STALEMATE>", ...
    "source":       string,       # "lichess"
    "moves_uci":    string,       # space-separated UCI moves, human-readable
    "token_ids":    list[int32],  # encoded sequence, use this for training
    "ntp_mask":     list[int32],  # 1 = apply NTP loss, 0 = skip
    "seq_len":      int32,        # len(token_ids), always in [3, 255]
}
```

## Usage
```python
from datasets import load_dataset
import json

# Load dataset
ds = load_dataset("MostLime/chess-elite-uci", split="train")

# Load vocabulary
with open("vocab.json") as f:
    vocab = json.load(f)
id_to_token = {v: k for k, v in vocab.items()}

# Decode a game
row = ds[0]
tokens = [id_to_token[i] for i in row["token_ids"]]
print(" ".join(tokens))
# → <W> e2e4 e7e5 g1f3 b8c6 f1b5 ... <RESIGN>

# PyTorch DataLoader
import torch
from torch.utils.data import DataLoader

def collate(batch):
    max_len = 255
    token_ids = torch.zeros(len(batch), max_len, dtype=torch.long)
    ntp_mask  = torch.zeros(len(batch), max_len, dtype=torch.float)
    for i, row in enumerate(batch):
        n = row["seq_len"]
        token_ids[i, :n] = torch.tensor(row["token_ids"], dtype=torch.long)
        ntp_mask[i,  :n] = torch.tensor(row["ntp_mask"],  dtype=torch.float)
    return {"token_ids": token_ids, "ntp_mask": ntp_mask}

loader = DataLoader(ds, batch_size=32, collate_fn=collate)
```

## Inference

At inference time, prepend the POV token for the side the model plays as, then feed opponent moves as context and sample responses:
```python
# Model plays as white
sequence = [vocab["<W>"]]

# Opponent plays e7e5 — append as context
sequence.append(vocab["e7e5"])

# Sample model's next move from legal UCI moves for the current position
```

Terminal tokens are never generated during normal play. The game ends when the opponent resigns or a draw is claimed externally.

## Citation
```bibtex
@dataset{mostlime2026chessEliteUCI,
  author    = {MostLime},
  title     = {chess-elite-uci: A Transformer-Ready Dataset of Elite Chess Games},
  year      = {2026},
  publisher = {HuggingFace},
  url       = {https://huggingface.co/datasets/MostLime/chess-elite-uci}
}
```

## Acknowledgements

- [Lichess Elite Database](https://database.nikonoel.fr) by nikonoel — CC0
- [python-chess](https://python-chess.readthedocs.io) for move parsing and board state verification
- [Modal](https://modal.com) for distributed compute