| |
| """Benchmark every tokenizer JSON row on one fixed Polish suite. |
| |
| The benchmark is diagnostic, not a downstream-language-model quality score. |
| All tokenizers see exactly the same strings and are loaded from the lossless |
| ``tokenizer_json`` column, so no contributor-specific files are required. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import importlib.metadata |
| import json |
| import platform |
| import re |
| import statistics |
| import time |
| from collections import Counter |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from tokenizers import Tokenizer |
|
|
| from custom_tokenizer_adapters import AdaptedTokenizer, load_custom_tokenizer_document |
|
|
|
|
| WORD_RE = re.compile(r"\w+", re.UNICODE) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--input", type=Path, default=Path("data/train-00000-of-00001.parquet")) |
| parser.add_argument("--suite", type=Path, default=Path("evaluation/polish_suite.jsonl")) |
| parser.add_argument("--output", type=Path, default=Path("results/tokenizer_benchmark.parquet")) |
| parser.add_argument("--summary-json", type=Path, default=Path("results/tokenizer_benchmark.json")) |
| parser.add_argument("--repeats", type=int, default=15, help="Timed batch repetitions") |
| return parser.parse_args() |
|
|
|
|
| def load_suite(path: Path) -> list[dict[str, str]]: |
| records = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()] |
| if not records or any(set(record) != {"domain", "text"} for record in records): |
| raise ValueError("suite must contain non-empty JSONL records with exactly domain and text") |
| return records |
|
|
|
|
| def timed_median(function, repeats: int) -> float: |
| samples = [] |
| for _ in range(repeats): |
| start = time.perf_counter_ns() |
| function() |
| samples.append((time.perf_counter_ns() - start) / 1e9) |
| return statistics.median(samples) |
|
|
|
|
| def encode_batch(tokenizer: Tokenizer | AdaptedTokenizer, texts: list[str]) -> list[list[int]]: |
| if isinstance(tokenizer, Tokenizer): |
| return [encoding.ids for encoding in tokenizer.encode_batch(texts, add_special_tokens=False)] |
| return [tokenizer.encode(text) for text in texts] |
|
|
|
|
| def decode_batch(tokenizer: Tokenizer | AdaptedTokenizer, batches: list[list[int]]) -> list[str]: |
| if isinstance(tokenizer, Tokenizer): |
| return tokenizer.decode_batch(batches, skip_special_tokens=False) |
| return [tokenizer.decode(ids) for ids in batches] |
|
|
|
|
| def counts_for(tokenizer: Tokenizer | AdaptedTokenizer, records: list[dict[str, str]]) -> tuple[dict, list, list]: |
| texts = [record["text"] for record in records] |
| id_batches = encode_batch(tokenizer, texts) |
| unk_id = tokenizer.token_to_id("<unk>") if isinstance(tokenizer, Tokenizer) else None |
| model_unk = None |
| try: |
| model_unk = json.loads(tokenizer.to_str()).get("model", {}).get("unk_token") if isinstance(tokenizer, Tokenizer) else None |
| except (TypeError, json.JSONDecodeError): |
| pass |
| if model_unk: |
| unk_id = tokenizer.token_to_id(model_unk) |
|
|
| result = Counter() |
| failures = [] |
| decoded_batch = decode_batch(tokenizer, id_batches) |
| for record, ids, decoded in zip(records, id_batches, decoded_batch): |
| text = record["text"] |
| result["texts"] += 1 |
| result["chars"] += len(text) |
| result["bytes"] += len(text.encode("utf-8")) |
| result["words"] += len(WORD_RE.findall(text)) |
| result["tokens"] += len(ids) |
| if unk_id is not None: |
| result["unks"] += sum(token_id == unk_id for token_id in ids) |
| if decoded != text: |
| result["roundtrip_failures"] += 1 |
| failures.append({"domain": record["domain"], "text": text, "decoded": decoded}) |
| return dict(result), id_batches, failures |
|
|
|
|
| def ratios(counts: dict) -> dict: |
| tokens = counts.get("tokens", 0) |
| words = counts.get("words", 0) |
| return { |
| "text_count": counts.get("texts", 0), |
| "word_count": words, |
| "token_count": tokens, |
| "tokens_per_word": tokens / words if words else None, |
| "chars_per_token": counts.get("chars", 0) / tokens if tokens else None, |
| "bytes_per_token": counts.get("bytes", 0) / tokens if tokens else None, |
| "unk_rate": counts.get("unks", 0) / tokens if tokens else None, |
| "roundtrip_failures": counts.get("roundtrip_failures", 0), |
| "roundtrip_pass": counts.get("roundtrip_failures", 0) == 0, |
| } |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if args.repeats < 1: |
| raise ValueError("--repeats must be positive") |
| suite = load_suite(args.suite) |
| table = pq.read_table(args.input) |
| rows = table.to_pylist() |
| texts = [record["text"] for record in suite] |
| total_bytes = sum(len(text.encode("utf-8")) for text in texts) |
| results = [] |
|
|
| for source in rows: |
| base = {key: source[key] for key in ("author", "name", "size", "sha256", "source_path")} |
| try: |
| if source["hf_loadable"]: |
| tokenizer: Tokenizer | AdaptedTokenizer = Tokenizer.from_str(source["tokenizer_json"]) |
| adapter_status = "native" |
| adapter_fidelity = "exact" |
| adapter_note = "Native Hugging Face Tokenizers artifact; no adapter used." |
| adapter_source_format = "hf_tokenizers" |
| runtime = "rust_tokenizers" |
| else: |
| adapted = load_custom_tokenizer_document( |
| json.loads(source["tokenizer_json"]), source["source_path"] |
| ) |
| tokenizer = adapted |
| adapter_status = "custom_adapter" |
| |
| |
| adapter_fidelity = "exact" if adapted.fidelity == "exact" else "core_only" |
| adapter_note = adapted.fidelity_note |
| adapter_source_format = adapted.source_format |
| runtime = "python_reference_adapter" |
| encode_batch(tokenizer, texts) |
| total, id_batches, failures = counts_for(tokenizer, suite) |
| encode_seconds = timed_median( |
| lambda: encode_batch(tokenizer, texts), args.repeats |
| ) |
| decode_seconds = timed_median( |
| lambda: decode_batch(tokenizer, id_batches), args.repeats |
| ) |
| domains = {} |
| for domain in sorted({record["domain"] for record in suite}): |
| domain_counts, _, _ = counts_for( |
| tokenizer, [record for record in suite if record["domain"] == domain] |
| ) |
| domains[domain] = ratios(domain_counts) |
| result = { |
| **base, |
| "status": "ok", |
| "adapter_status": adapter_status, |
| "adapter_fidelity": adapter_fidelity, |
| "adapter_note": adapter_note, |
| "adapter_source_format": adapter_source_format, |
| "runtime": runtime, |
| **ratios(total), |
| "encode_mb_per_s": total_bytes / 1_000_000 / encode_seconds, |
| "decode_mb_per_s": total_bytes / 1_000_000 / decode_seconds, |
| "serialized_bytes": len(source["tokenizer_json"].encode("utf-8")), |
| "domain_metrics_json": json.dumps(domains, ensure_ascii=False, sort_keys=True), |
| "roundtrip_examples_json": json.dumps(failures[:3], ensure_ascii=False), |
| "error": "", |
| } |
| except Exception as exc: |
| result = {**base, "status": "error", "error": f"{type(exc).__name__}: {exc}"} |
| results.append(result) |
|
|
| metadata = { |
| "suite": str(args.suite), |
| "suite_sha256": hashlib.sha256(args.suite.read_bytes()).hexdigest(), |
| "suite_records": len(suite), |
| "suite_bytes": total_bytes, |
| "repeats": args.repeats, |
| "timer": "median wall-clock batch time after one warm-up", |
| "python": platform.python_version(), |
| "tokenizers": importlib.metadata.version("tokenizers"), |
| "pyarrow": importlib.metadata.version("pyarrow"), |
| "platform": platform.platform(), |
| } |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.summary_json.parent.mkdir(parents=True, exist_ok=True) |
| pq.write_table(pa.Table.from_pylist(results), args.output, compression="zstd") |
| args.summary_json.write_text( |
| json.dumps({"benchmark_metadata": metadata, "results": results}, ensure_ascii=False, indent=2), |
| encoding="utf-8", |
| ) |
| print(json.dumps(metadata, indent=2)) |
| for result in sorted(results, key=lambda row: (row.get("tokens_per_word", float("inf")), row["author"])): |
| print( |
| result["author"], result["name"], result["status"], |
| f"tpw={result.get('tokens_per_word', float('nan')):.4f}", |
| f"roundtrip_failures={result.get('roundtrip_failures', '-')}" |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
