Update README.md

README.md

@@ -1,3 +1,222 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- chess
+- uci
+- transformer
+- games
+- elite
+- lichess
+- twic
+- tokenized
+size_categories:
+- 1M<n<10M
+---
+
+# chess-elite-uci
+
+A transformer-ready dataset of ~8 million elite chess games, pre-tokenized in UCI notation with a deterministic 1977-token vocabulary. Built for training chess language models directly — no preprocessing required.
+
+## Dataset Summary
+
+| Field | Value |
+|---|---|
+| Total games | 7,972,071 |
+| Lichess Elite games | 7,805,503 |
+| TWIC OTB games | 166,568 |
+| Average sequence length | 94.3 tokens |
+| Max sequence length | 255 tokens |
+| Vocabulary size | 1,977 tokens |
+| Mean combined Elo | 5,212 (~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.
+
+**The Week in Chess (TWIC)** (Issues 920–1633, ~2013–2026)
+OTB classical tournament games where both players are FIDE-rated 2500+. Source: [theweekinchess.com](https://theweekinchess.com). Permission pending.
+
+Cross-dataset duplicates (3,173 games appearing in both sources) were removed using SHA1 hashing of move sequences. Lichess takes priority on conflicts.
+
+## Vocabulary
+
+The vocabulary contains **1,977 tokens** and is fully deterministic — 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. For TOP (Token Order Prediction) auxiliary loss, apply no masking — all tokens should be ranked.
+
+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.4% |
+| White resignation | 2,000,000 | 25.1% |
+| Black checkmate | 1,702,752 | 21.4% |
+| Black resignation | 2,000,000 | 25.1% |
+| Forced draw | 400,000 | 5.0% |
+| TWIC (all types) | 166,568 | 2.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" or "twic"
+    "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>
+
+# Filter by source
+lichess_only = ds.filter(lambda x: x["source"] == "lichess")
+twic_only    = ds.filter(lambda x: x["source"] == "twic")
+
+# 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.
+
+## Related Work
+
+- [Grandmaster-Level Chess Without Search](https://arxiv.org/abs/2402.04494) — 270M parameter transformer reaching 2895 Lichess blitz Elo
+- [adamkarvonen/chess_games](https://huggingface.co/datasets/adamkarvonen/chess_games) — raw PGN blocks used in chess-GPT
+
+## 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
+- [The Week in Chess](https://theweekinchess.com) by Mark Crowther — permission pending
+- [python-chess](https://python-chess.readthedocs.io) for move parsing and board state verification
+- [Modal](https://modal.com) for distributed compute