| |
| """Normalize evaluation perplexity to bits-per-character (BPC). |
| |
| PPL is not comparable across languages or tokenizers: a tokenizer with higher |
| fertility (tokens per character) spreads the same text over more tokens, which |
| inflates PPL. BPC divides the total negative log-likelihood by characters |
| instead: |
| |
| BPC = log2(PPL) * tokens / chars = log2(PPL) * fertility |
| |
| Only the public tokenizer is needed. No model weights, no GPU. |
| |
| ``tokens`` here means *scored* positions, matching what ``eval_quantized.py`` |
| puts in its JSON: each chunk contributes ``len(chunk) - 1`` predictions, since |
| the first token of every chunk is only context. The character count is measured |
| on the same scored stream: the chunks are rebuilt with the same |
| ``chunks_from_text`` logic as ``eval_quantized.py``, the full stream is decoded |
| once, and the characters of the skipped first token of each chunk are removed. |
| This avoids counting every chunk boundary twice. |
| |
| Usage: |
| python scripts/compute_bpc.py \ |
| --ppl-json out/eval/ppl_en.json \ |
| --ppl-json out/eval/ppl_ja.json \ |
| --tokenizer Qwen/Qwen3.5-0.8B |
| |
| python scripts/compute_bpc.py --ppl-json ppl_en.json --tokenizer ./tokenizer-dir --json report.json |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def load_tokenizer(source: str): |
| from tokenizers import Tokenizer |
|
|
| path = Path(source) |
| if path.is_dir(): |
| return Tokenizer.from_file(str(path / "tokenizer.json")) |
| if path.is_file(): |
| return Tokenizer.from_file(str(path)) |
| from huggingface_hub import hf_hub_download |
|
|
| return Tokenizer.from_file(hf_hub_download(source, "tokenizer.json")) |
|
|
|
|
| def chunks_from_text(tokenizer, text: str, max_tokens: int, min_tokens: int, limit: int) -> list[list[int]]: |
| """Mirror of eval_quantized.chunks_from_text; must stay identical.""" |
| ids = tokenizer.encode(text, add_special_tokens=True).ids |
| chunks = [ids[start : start + max_tokens] for start in range(0, len(ids), max_tokens)] |
| chunks = [chunk for chunk in chunks if len(chunk) >= min_tokens] |
| return chunks[:limit] |
|
|
|
|
| def read_corpus(path: str) -> str: |
| text = Path(path).read_text(encoding="utf-8") |
| return text.replace("\x00", "") |
|
|
|
|
| def scored_tokens(chunks: list[list[int]]) -> int: |
| """Predictions per chunk: every token except the first (context only).""" |
| return sum(max(len(chunk) - 1, 0) for chunk in chunks) |
|
|
|
|
| def target_chars(tokenizer, chunks: list[list[int]]) -> int: |
| """Characters of the scored stream. |
| |
| Decoding the whole stream at once keeps multi-byte characters intact; the |
| context-only first token of each chunk is then removed. A token that holds a |
| partial UTF-8 sequence at a chunk boundary can shift this by at most one |
| character per chunk. |
| """ |
| flat: list[int] = [] |
| for chunk in chunks: |
| flat.extend(chunk) |
| full = tokenizer.decode(flat) |
| skipped = sum(len(tokenizer.decode([chunk[0]])) for chunk in chunks if chunk) |
| return len(full) - skipped |
|
|
|
|
| def bpc(ppl: float, tokens: int, chars: int) -> float: |
| if chars <= 0: |
| raise ValueError("chars must be positive") |
| if tokens <= 0: |
| raise ValueError("tokens must be positive") |
| if ppl <= 0: |
| raise ValueError("ppl must be positive") |
| return math.log2(ppl) * tokens / chars |
|
|
|
|
| def sha256_text(path: str) -> str | None: |
| try: |
| return hashlib.sha256(Path(path).read_bytes()).hexdigest()[:16] |
| except OSError: |
| return None |
|
|
|
|
| def analyze(payload: dict[str, Any], tokenizer_source: str, corpus_override: str | None) -> dict[str, Any]: |
| config = payload.get("config") or {} |
| corpus = corpus_override or config.get("corpus") or payload.get("corpus") |
| if not corpus: |
| raise SystemExit("no corpus in PPL JSON; pass --corpus") |
| max_tokens = int(config.get("max_tokens", 128)) |
| min_tokens = int(config.get("min_tokens", 16)) |
| max_sequences = int(config.get("max_sequences", payload.get("chunks", 0) or 0)) |
| if max_sequences <= 0: |
| raise SystemExit("no max_sequences in PPL JSON; pass --max-sequences") |
|
|
| tokenizer = load_tokenizer(tokenizer_source) |
| text = read_corpus(corpus) |
| chunks = chunks_from_text(tokenizer, text, max_tokens, min_tokens, max_sequences) |
| if not chunks: |
| raise SystemExit(f"no chunks from {corpus}") |
|
|
| tokens = scored_tokens(chunks) |
| chars = target_chars(tokenizer, chunks) |
| fertility = tokens / chars |
|
|
| expected_chunks = payload.get("chunks") |
| expected_tokens = payload.get("tokens") |
| report: dict[str, Any] = { |
| "corpus": corpus, |
| "corpus_sha256": sha256_text(corpus), |
| "tokenizer": tokenizer_source, |
| "config": { |
| "max_tokens": max_tokens, |
| "min_tokens": min_tokens, |
| "max_sequences": max_sequences, |
| }, |
| "chunks": len(chunks), |
| "tokens": tokens, |
| "chars": chars, |
| "tokens_per_char": fertility, |
| "reproduced": { |
| "chunks_match": expected_chunks is None or expected_chunks == len(chunks), |
| "tokens_match": expected_tokens is None or expected_tokens == tokens, |
| }, |
| } |
|
|
| for key, value in payload.items(): |
| if key.endswith("_ppl") and isinstance(value, (int, float)): |
| label = key[: -len("_ppl")] or "model" |
| report[f"bpc_{label}"] = bpc(float(value), tokens, chars) |
| report[f"ppl_{label}"] = float(value) |
|
|
| if "delta_nll_per_token" in payload: |
| report["bpc_delta"] = float(payload["delta_nll_per_token"]) / math.log(2) * fertility |
|
|
| return report |
|
|
|
|
| def format_table(reports: list[dict[str, Any]]) -> str: |
| lines = [ |
| "| run | chunks | tokens | chars | tok/char | PPL | BPC |", |
| "|---|---:|---:|---:|---:|---:|---:|", |
| ] |
| for report in reports: |
| name = Path(report.get("source", "?")).parent.name or "?" |
| ppl = report.get("ppl_candidate", report.get("ppl_bf16")) |
| bp = report.get("bpc_candidate", report.get("bpc_bf16")) |
| lines.append( |
| f"| {name} | {report['chunks']} | {report['tokens']} | {report['chars']} " |
| f"| {report['tokens_per_char']:.4f} | {ppl:.2f} | {bp:.4f} |" |
| ) |
| return "\n".join(lines) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--ppl-json", action="append", required=True, help="eval_quantized.py output (repeatable)") |
| parser.add_argument("--tokenizer", required=True, help="tokenizer dir, tokenizer.json, or HF repo id") |
| parser.add_argument("--corpus", default=None, help="override corpus path recorded in the PPL JSON") |
| parser.add_argument("--json", default=None, help="write the report here") |
| parser.add_argument("--strict", action="store_true", help="fail when chunk/token counts do not reproduce") |
| args = parser.parse_args() |
|
|
| reports = [] |
| failed = False |
| for path in args.ppl_json: |
| payload = json.loads(Path(path).read_text(encoding="utf-8")) |
| report = analyze(payload, args.tokenizer, args.corpus) |
| report["source"] = str(path) |
| reports.append(report) |
| reproduced = report["reproduced"] |
| if args.strict and not (reproduced["chunks_match"] and reproduced["tokens_match"]): |
| failed = True |
| print(f"MISMATCH {path}: {reproduced}") |
|
|
| for report in reports: |
| print(json.dumps(report, indent=2, ensure_ascii=False)) |
| print() |
| print(format_table(reports)) |
|
|
| if args.json: |
| Path(args.json).write_text(json.dumps(reports, indent=2, ensure_ascii=False), encoding="utf-8") |
| print(f"\nwrote {args.json}") |
| if failed: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
