| from __future__ import annotations |
|
|
| import hashlib |
| from pathlib import Path |
| from typing import Any, Protocol |
|
|
|
|
| class TokenizerProtocol(Protocol): |
| def encode(self, text: str) -> list[int]: ... |
| def decode(self, token_ids: list[int]) -> str: ... |
| def render_chat(self, messages: list[dict[str, Any]]) -> str: ... |
| def token_offset(self, rendered_text: str, substring: str) -> int: ... |
| @property |
| def fingerprint(self) -> str: ... |
|
|
|
|
| class TransformersTokenizer: |
| def __init__( |
| self, |
| model_path: str | Path, |
| *, |
| enable_thinking: bool = True, |
| reasoning_effort: str | None = "medium", |
| preserve_thinking: bool = True, |
| ): |
| try: |
| from transformers import AutoTokenizer |
| except ImportError as exc: |
| raise RuntimeError( |
| "Install shiftedx-bench[tokenizers] to use a Transformers tokenizer" |
| ) from exc |
| self.model_path = Path(model_path).expanduser().resolve() |
| self._tokenizer = AutoTokenizer.from_pretrained( |
| self.model_path, local_files_only=True, trust_remote_code=True |
| ) |
| self.enable_thinking = enable_thinking |
| self.reasoning_effort = reasoning_effort |
| self.preserve_thinking = preserve_thinking |
| digest = hashlib.sha256() |
| for name in ("tokenizer.json", "tokenizer_config.json", "special_tokens_map.json"): |
| path = self.model_path / name |
| if path.exists(): |
| digest.update(name.encode()) |
| digest.update(path.read_bytes()) |
| digest.update( |
| repr((self.enable_thinking, self.reasoning_effort, self.preserve_thinking)).encode() |
| ) |
| self._fingerprint = digest.hexdigest() |
|
|
| def encode(self, text: str) -> list[int]: |
| return list(self._tokenizer.encode(text, add_special_tokens=False)) |
|
|
| def decode(self, token_ids: list[int]) -> str: |
| return self._tokenizer.decode( |
| token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False |
| ) |
|
|
| def render_chat(self, messages: list[dict[str, Any]]) -> str: |
| kwargs: dict[str, Any] = { |
| "tokenize": False, |
| "add_generation_prompt": True, |
| "enable_thinking": self.enable_thinking, |
| "preserve_thinking": self.preserve_thinking, |
| } |
| if self.reasoning_effort: |
| kwargs["reasoning_effort"] = self.reasoning_effort |
| try: |
| value = self._tokenizer.apply_chat_template(messages, **kwargs) |
| except TypeError: |
| value = self._tokenizer.apply_chat_template( |
| messages, tokenize=False, add_generation_prompt=True |
| ) |
| if not isinstance(value, str): |
| raise TypeError("Tokenizer chat template did not return text") |
| return value |
|
|
| def token_offset(self, rendered_text: str, substring: str) -> int: |
| char_offset = rendered_text.find(substring) |
| if char_offset < 0: |
| raise ValueError(f"Substring not present in rendered prompt: {substring!r}") |
| encoded = self._tokenizer( |
| rendered_text, |
| add_special_tokens=False, |
| return_offsets_mapping=True, |
| ) |
| for index, (start, end) in enumerate(encoded["offset_mapping"]): |
| if start <= char_offset < end or start == char_offset: |
| return index |
| raise ValueError("Could not map substring to a token offset") |
|
|
| @property |
| def fingerprint(self) -> str: |
| return self._fingerprint |
|
|
