| """ |
| Custom Chess Tokenizer for the Chess Challenge. |
| |
| This tokenizer treats each move as a single token using the extended UCI notation |
| from the Lichess dataset (e.g., WPe2e4, BNg8f6). |
| |
| The dataset format uses: |
| - W/B prefix for White/Black |
| - Piece letter: P=Pawn, N=Knight, B=Bishop, R=Rook, Q=Queen, K=King |
| - Source and destination squares (e.g., e2e4) |
| - Special suffixes: (x)=capture, (+)=check, (+*)=checkmate, (o)/(O)=castling |
| - Promotion: (Q)=queen, (R)=rook, (B)=bishop, (N)=knight |
| |
| New token strategy: |
| - we only retain the squares involved in the move and the promotion piece if any |
| - everything else (piece type, capture flag, check flag, etc.) is discarded |
| - the vocabulary size is thus minimal (72 tokens): 64 squares + 4 promotion pieces + 4 special tokens |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| from pathlib import Path |
| from typing import Dict, List, Optional |
| import re |
|
|
| from transformers import PreTrainedTokenizer |
|
|
|
|
| class ChessTokenizer(PreTrainedTokenizer): |
| model_input_names = ["input_ids", "attention_mask"] |
| |
| PAD_TOKEN = "[PAD]" |
| BOS_TOKEN = "[BOS]" |
| EOS_TOKEN = "[EOS]" |
| UNK_TOKEN = "[UNK]" |
| |
| def __init__( |
| self, |
| vocab_file: Optional[str] = None, |
| vocab: Optional[Dict[str, int]] = None, |
| **kwargs, |
| ): |
| self._pad_token = self.PAD_TOKEN |
| self._bos_token = self.BOS_TOKEN |
| self._eos_token = self.EOS_TOKEN |
| self._unk_token = self.UNK_TOKEN |
|
|
| kwargs.pop("pad_token", None) |
| kwargs.pop("bos_token", None) |
| kwargs.pop("eos_token", None) |
| kwargs.pop("unk_token", None) |
| |
| self.token_pattern = re.compile(r'[a-h][1-8]|[qrbn]') |
|
|
| if vocab is not None: |
| self._vocab = vocab |
| elif vocab_file is not None and os.path.exists(vocab_file): |
| with open(vocab_file, "r", encoding="utf-8") as f: |
| self._vocab = json.load(f) |
| else: |
| self._vocab = self._create_default_vocab() |
| |
| self._ids_to_tokens = {v: k for k, v in self._vocab.items()} |
| |
| super().__init__( |
| pad_token=self._pad_token, |
| bos_token=self._bos_token, |
| eos_token=self._eos_token, |
| unk_token=self._unk_token, |
| **kwargs, |
| ) |
| |
| def _create_default_vocab(self) -> Dict[str, int]: |
| special_tokens = [self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN] |
| vocab = {token: idx for idx, token in enumerate(special_tokens)} |
| idx = len(vocab) |
| |
| for f in 'abcdefgh': |
| for r in '12345678': |
| vocab[f"{f}{r}"] = idx |
| idx += 1 |
| |
| for p in ['q', 'r', 'b', 'n']: |
| vocab[p] = idx |
| idx += 1 |
| return vocab |
| |
| def _tokenize(self, text: str) -> List[str]: |
| text = (text.replace("(Q)", "q") |
| .replace("(R)", "r") |
| .replace("(B)", "b") |
| .replace("(N)", "n")) |
| |
| return self.token_pattern.findall(text) |
| |
| def _convert_token_to_id(self, token: str) -> int: |
| return self._vocab.get(token, self._vocab.get(self.UNK_TOKEN, 0)) |
| |
| def _convert_id_to_token(self, index: int) -> str: |
| return self._ids_to_tokens.get(index, self.UNK_TOKEN) |
| |
| def convert_tokens_to_string(self, tokens: List[str]) -> str: |
| special = {self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN} |
| clean_tokens = [t for t in tokens if t not in special] |
| |
| output = [] |
| for token in clean_tokens: |
| if token in ['q', 'r', 'b', 'n'] and output: |
| output[-1] += token |
| elif output and len(output[-1]) == 2 and output[-1][0] in 'abcdefgh': |
| output[-1] += token |
| else: |
| output.append(token) |
| |
| return " ".join(output) |
| |
| def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> tuple: |
| if not os.path.isdir(save_directory): |
| os.makedirs(save_directory, exist_ok=True) |
| vocab_file = os.path.join( |
| save_directory, (filename_prefix + "-" if filename_prefix else "") + "vocab.json" |
| ) |
| with open(vocab_file, "w", encoding="utf-8") as f: |
| json.dump(self._vocab, f, ensure_ascii=False, indent=2) |
| return (vocab_file,) |
| |
| @classmethod |
| def build_vocab_from_iterator(cls, iterator, min_frequency=1): |
| return cls() |
| |
| @classmethod |
| def build_vocab_from_dataset(cls, **kwargs): |
| return cls() |
|
|
| @property |
| def vocab_size(self) -> int: |
| return len(self._vocab) |
| |
| def get_vocab(self) -> Dict[str, int]: |
| return dict(self._vocab) |
