|
|
"""
|
|
|
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
|
|
|
"""
|
|
|
|
|
|
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]:
|
|
|
"""
|
|
|
Tokenizes text by first normalizing specific chess patterns
|
|
|
and then extracting squares/promotions.
|
|
|
"""
|
|
|
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:
|
|
|
"""Convert a token to its ID."""
|
|
|
return self._vocab.get(token, self._vocab.get(self.UNK_TOKEN, 0))
|
|
|
|
|
|
def _convert_id_to_token(self, index: int) -> str:
|
|
|
"""Convert an ID to its token."""
|
|
|
return self._ids_to_tokens.get(index, self.UNK_TOKEN)
|
|
|
|
|
|
def convert_tokens_to_string(self, tokens: List[str]) -> str:
|
|
|
"""Reconstructs standard UCI string (e.g. "e2e4 a7a8q")"""
|
|
|
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)
|
|
|
|
