README.md

metadata

license: apache-2.0
language:
  - ar
  - en
tags:
  - tokenizer
  - benchmark
  - eval
  - arabic
  - english
  - chars-per-token
pretty_name: SARFTokenizer Benchmark Eval (600)
size_categories:
  - n<1K
task_categories:
  - text-classification
dataset_info:
  features:
    - name: idx
      dtype: int64
    - name: language
      dtype: string
    - name: text
      dtype: string
    - name: source
      dtype: string
  splits:
    - name: test
      num_bytes: 574100
      num_examples: 600
configs:
  - config_name: default
    data_files:
      - split: test
        path: eval.parquet

SARFTokenizer Benchmark Eval (600 docs)

The exact 300 Arabic + 300 English documents used to benchmark almaghrabima/SARFTokenizer against GPT-5, GPT-4o, Gemma-4, Qwen3.6, Kimi-K2.6, ALLaM, and 8 other tokenizers.

Publishing this dataset makes the benchmark in SARFTokenizer/BENCHMARK.md fully reproducible — anyone can compute the exact same chars-per-token numbers on the exact same samples.

Statistics

	AR	EN	Total
Documents	300	300	600
Characters	479,808	69,308	549,116
Words	82,964	9,805	92,769
Max chars/sample	2,000	2,000	—

Schema

Field	Type	Description
idx	int64	Index within the per-language subset (0–299)
language	string	"ar" or "en"
text	string	Document text, truncated to 2000 characters
source	string	Always "deeplatent-hq-bilingual"

Sampled from the first 5 ar_*.parquet and first 5 en_*.parquet files of the deeplatent-hq-bilingual validation shards, with a 10% Arabic-character threshold for AR filtering (matching scripts/bench_tokenizers.py).

Reproduce the headline benchmark

pip install transformers tokenizers datasets

from datasets import load_dataset
from transformers import AutoTokenizer

# Our eval corpus
ds = load_dataset("almaghrabima/SARFTokenizer-benchmark-eval", split="test")
ar_texts = [r["text"] for r in ds if r["language"] == "ar"]
en_texts = [r["text"] for r in ds if r["language"] == "en"]

# Load any tokenizer
from huggingface_hub import login
login(token="your_hf_token")  # needed for private SARFTokenizer; skip if public
tok = AutoTokenizer.from_pretrained("almaghrabima/SARFTokenizer")

def stats(texts):
    chars = sum(len(t) for t in texts)
    words = sum(len(t.split()) for t in texts)
    tokens = sum(len(tok.encode(t, add_special_tokens=False)) for t in texts)
    return chars, words, tokens

ar_c, ar_w, ar_t = stats(ar_texts)
en_c, en_w, en_t = stats(en_texts)
print(f"AR: {ar_c:,}c / {ar_t:,}t  →  CpT={ar_c/ar_t:.3f}  T/W={ar_t/ar_w:.2f}")
print(f"EN: {en_c:,}c / {en_t:,}t  →  CpT={en_c/en_t:.3f}  T/W={en_t/en_w:.2f}")
print(f"Parity = {(ar_c/ar_t)/(en_c/en_t):.3f}")

Expected output for SARFTokenizer v0.2:

AR: 479,808c / 130,253t  →  CpT=3.683  T/W=1.57
EN:  69,308c /  19,680t  →  CpT=3.522  T/W=2.01
Parity = 1.046

Compare multiple tokenizers in one shot

from datasets import load_dataset
from transformers import AutoTokenizer
from huggingface_hub import login

login(token="your_hf_token")  # needed for private SARFTokenizer

ds = load_dataset("almaghrabima/SARFTokenizer-benchmark-eval", split="test")
ar_texts = [r["text"] for r in ds if r["language"] == "ar"]
en_texts = [r["text"] for r in ds if r["language"] == "en"]
ar_chars = sum(len(t) for t in ar_texts)
en_chars = sum(len(t) for t in en_texts)

peers = {
    "SARFTokenizer-v0.2":      ("almaghrabima/SARFTokenizer", False),
    "gemma-4-31B-it":          ("google/gemma-4-31B-it", False),
    "Qwen3.6-35B-A3B":         ("Qwen/Qwen3.6-35B-A3B", False),
    "Kimi-K2.6":               ("moonshotai/Kimi-K2.6", True),
    "ALLaM-7B":                ("ALLaM-AI/ALLaM-7B-Instruct-preview", False),
    "Qwen2.5-0.5B":            ("Qwen/Qwen2.5-0.5B", False),
    "Falcon-7B":               ("tiiuae/falcon-7b", False),
}

print(f"{'Tokenizer':<22} {'Vocab':>10} {'AR CpT':>8} {'EN CpT':>8} {'Parity':>8}")
print("=" * 60)
for name, (repo, trc) in peers.items():
    try:
        t = AutoTokenizer.from_pretrained(repo, trust_remote_code=trc)
        ar_t = sum(len(t.encode(x, add_special_tokens=False)) for x in ar_texts)
        en_t = sum(len(t.encode(x, add_special_tokens=False)) for x in en_texts)
        ar_cpt = ar_chars / ar_t
        en_cpt = en_chars / en_t
        print(f"{name:<22} {len(t):>10,} {ar_cpt:>8.3f} {en_cpt:>8.3f} {ar_cpt/en_cpt:>8.3f}")
    except Exception as e:
        print(f"{name:<22} SKIP: {e.__class__.__name__}")

Expected numbers are the headline benchmark — any divergence means a tokenizer changed upstream.

Files

• eval.parquet — 600 documents, schema above, ~540 KB
• summary.json — aggregate stats
• README.md — this file

License

Apache 2.0. Underlying text is from the deeplatent-hq-bilingual curated corpus; individual documents retain their original web-sourced licenses.