scrape_analysis/analyze.py

#!/usr/bin/env python3
"""
Analyze scraped tokenizer.json pre_tokenizers and classify each against the
PR's atom FSM shapes. Report which patterns are covered and which need hand-unroll.

PR atom FSM shapes (from fast_split/src/fsm.rs + TAG_CLASSIFY_SPEC.md):
  A1. fsm_split<DELIM,BEHAVIOR>       — Split delimiter (Removed/Isolated/Contiguous/MergedPrev/MergedNext)
                                        covers: WhitespaceSplit, Punctuation, Digits, Metaspace, CharDelimiterSplit, Split-literal
  A2. fsm_class_runs<DROP,ISOLATE,SPLIT> — class-change cut
                                        covers: Whitespace, Bert
  A3. fsm_cl100k                       — cl100k/o200k 7-rule scalar FSM
  A4. fsm_deepseek                     — deepseek-v3 Sequence (digits{1,3} → CJK → big regex)
  A5. fsm_byte_level                   — GPT-2/ByteLevel (TODO in PR)
  A6. fsm_script_run                   — UnicodeScripts (TODO in PR)
  OUT. Split(regex)                    — runtime regex, feature-gated escape hatch (NOT an atom)
"""
import json, os, re, sys
from collections import Counter, defaultdict

IN = os.path.join(os.path.dirname(__file__), "scrape_hf.jsonl")

# ── Canonical regex patterns we recognize ──────────────────────────────────────
# cl100k_base / o200k_base (GPT-4 / GPT-4o) pretokenizer regex:
CL100K_REGEX = r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
O200K_REGEX = r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{Lu}[\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
# GPT-2 / ByteLevel regex (use_regex=true):
GPT2_REGEX = r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
# Deepseek-v3 big-regex alt-3:
DS_BIGREGEX = r"""[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~][A-Za-z]+|[^\r\n\p{L}\p{P}\p{S}]?[\p{L}\p{M}]+| ?[\p{P}\p{S}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
# Qwen / Llama3 / Mistral-style Split regex (the common "ByteLevel with regex" split):
# This is the GPT-2-like regex but with \p{N}{1,2} or \p{N}{1,3} variations:
LLAMA3_REGEX = r"""(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""

def normalize_regex(r):
    """Normalize a regex string for comparison (strip whitespace, collapse)."""
    if r is None:
        return None
    r = r.strip()
    # collapse internal whitespace
    r = re.sub(r'\s+', '', r)
    return r

# Pre-compute normalized known regexes
KNOWN = {
    "cl100k": normalize_regex(CL100K_REGEX),
    "o200k": normalize_regex(O200K_REGEX),
    "gpt2": normalize_regex(GPT2_REGEX),
    "deepseek_big": normalize_regex(DS_BIGREGEX),
    "llama3": normalize_regex(LLAMA3_REGEX),
}

# ── Classification ─────────────────────────────────────────────────────────────

def classify_pre_tokenizer(pt, norm=None):
    """
    Classify a pre_tokenizer JSON object.
    Returns (atom_shape, canonical_signature, details).
    atom_shape is one of:
      'A1_split', 'A2_class_runs', 'A3_cl100k', 'A4_deepseek', 'A5_byte_level',
      'A6_script_run', 'A1_split_regex', 'SEQUENCE', 'null', 'UNKNOWN'
    canonical_signature: a string that uniquely identifies the pre_tokenizer pattern.
    """
    if pt is None:
        return ("null", "null", "no pre_tokenizer (SentencePiece or raw)")
    t = pt.get("type")
    sig_parts = []
    if t == "Sequence":
        subs = pt.get("pretokenizers", [])
        sub_results = []
        for s in subs:
            sub_atom, sub_sig, sub_det = classify_pre_tokenizer(s)
            sub_results.append((sub_atom, sub_sig, s.get("type")))
        # Classify the whole sequence
        sub_types = [s.get("type") for s in subs]
        sub_atoms = [r[0] for r in sub_results]
        sub_sigs = [r[1] for r in sub_results]
        sig = "Seq[" + ",".join(sub_sigs) + "]"
        # Heuristics for known sequences
        # Deepseek: [Split(N{1,3}), Split(CJK), Split(bigregex), ByteLevel]
        if len(subs) == 4 and sub_types == ["Split","Split","Split","ByteLevel"]:
            r0 = subs[0].get("pattern",{}).get("Regex","")
            r1 = subs[1].get("pattern",{}).get("Regex","")
            r2 = subs[2].get("pattern",{}).get("Regex","")
            if "N}" in r0 and ("4e00" in r1.lower() or "\\u4e00" in r1) and "p{P}" in r2:
                return ("A4_deepseek", sig, "deepseek-v3 Sequence")
            # Check if r2 is the deepseek big regex
            nr2 = normalize_regex(r2)
            if nr2 == KNOWN["deepseek_big"]:
                return ("A4_deepseek", sig, "deepseek-v3 Sequence (big regex match)")
        # Llama3/Qwen/Mistral: [Split(cl100k-like regex), ByteLevel]
        if len(subs) == 2 and sub_types == ["Split","ByteLevel"]:
            r0 = subs[0].get("pattern",{}).get("Regex","")
            nr0 = normalize_regex(r0)
            if nr0 == KNOWN["cl100k"] or nr0 == KNOWN["llama3"]:
                return ("A5_byte_level", sig, "ByteLevel + cl100k-regex Split (llama3/qwen pattern)")
            # generic regex + bytelevel
            return ("A5_byte_level", sig, f"ByteLevel + Split(regex {r0[:40]}...)")
        # XLM-R: [WhitespaceSplit, Metaspace]
        if len(subs) == 2 and sub_types == ["WhitespaceSplit","Metaspace"]:
            return ("A1_split", sig, "WhitespaceSplit + Metaspace (A1 ×2)")
        # Sequence of all A1-compatible splits
        if all(a in ("A1_split","A1_split_regex") for a in sub_atoms):
            if all(a == "A1_split" for a in sub_atoms):
                return ("A1_split", sig, "Sequence of A1-compatible splits")
            return ("A1_split_regex", sig, "Sequence with regex Split(s)")
        # Mixed
        return ("SEQUENCE", sig, f"Seq types={sub_types} atoms={sub_atoms}")
    elif t == "WhitespaceSplit":
        return ("A1_split", "WhitespaceSplit", "fsm_split<WS, Removed>")
    elif t == "Whitespace":
        return ("A2_class_runs", "Whitespace", "fsm_class_runs<WS,0,WORD>")
    elif t == "BertPreTokenizer":
        return ("A2_class_runs", "BertPreTokenizer", "fsm_class_runs<WS,PUNCT,0>")
    elif t == "Punctuation":
        return ("A1_split", "Punctuation", "fsm_split<PUNCT, Isolated>")
    elif t == "Digits":
        beh = pt.get("behavior", "Contiguous")
        return ("A1_split", f"Digits({beh})", f"fsm_split<NUMERIC, {beh}>")
    elif t == "Metaspace":
        return ("A1_split", "Metaspace", "fsm_split<Space→▁, MergedWithNext>")
    elif t == "ByteLevel":
        ur = pt.get("use_regex", False)
        if ur:
            return ("A5_byte_level", "ByteLevel(use_regex=true)", "fsm_byte_level (GPT-2 regex)")
        else:
            return ("A5_byte_level", "ByteLevel(use_regex=false)", "fsm_byte_level (no regex)")
    elif t == "Split":
        pat = pt.get("pattern", {})
        beh = pt.get("behavior", "?")
        inv = pt.get("invert", False)
        pat_kind = list(pat.keys())[0] if pat else "none"
        pat_val = list(pat.values())[0] if pat else ""
        if pat_kind == "Regex":
            nr = normalize_regex(pat_val)
            if nr == KNOWN["cl100k"]:
                return ("A3_cl100k", f"Split(cl100k:{beh})", "cl100k regex Split")
            if nr == KNOWN["o200k"]:
                return ("A3_cl100k", f"Split(o200k:{beh})", "o200k regex Split (A3 variant)")
            if nr == KNOWN["gpt2"]:
                return ("A5_byte_level", f"Split(gpt2:{beh})", "GPT-2 regex Split (A5)")
            if nr == KNOWN["deepseek_big"]:
                return ("A4_deepseek", f"Split(ds_big:{beh})", "deepseek big regex Split")
            # Unknown regex
            return ("A1_split_regex", f"Split(Regex:{beh}:{pat_val[:50]})", f"regex Split, behavior={beh}")
        elif pat_kind == "String":
            return ("A1_split", f"Split(String:{beh}:{pat_val})", "literal Split (CharDelimiterSplit family)")
        elif pat_kind == "FairSeq":
            return ("UNKNOWN", f"Split(FairSeq:{beh})", "FairSeq pattern — not an atom")
        else:
            return ("UNKNOWN", f"Split({pat_kind}:{beh})", f"unknown Split pattern type {pat_kind}")
    elif t == "UnicodeScripts":
        return ("A6_script_run", "UnicodeScripts", "fsm_script_run (TODO in PR)")
    elif t == "CharDelimiterSplit":
        ch = pt.get("delimiter", "?")
        return ("A1_split", f"CharDelimiterSplit({ch})", "byte compare, no tag")
    elif t == "FixedLength":
        return ("UNKNOWN", "FixedLength", "positional — rides char_start bitplane, not an atom FSM")
    elif t == "Symbols":
        return ("UNKNOWN", "Symbols", "Symbols pretokenizer — not in atom design")
    elif t == "Sequence":
        return classify_pre_tokenizer(pt, norm)  # handled above
    else:
        return ("UNKNOWN", f"{t}", f"unknown pretokenizer type: {t}")

# ── Main ───────────────────────────────────────────────────────────────────────

def main():
    records = [json.loads(l) for l in open(IN)]
    print(f"Loaded {len(records)} scraped records")

    # Classify each
    results = []
    for r in records:
        pt = r.get("pre_tokenizer")
        norm = r.get("normalizer")
        if r.get("error"):
            continue
        atom, sig, detail = classify_pre_tokenizer(pt, norm)
        results.append({
            "id": r["id"],
            "downloads": r.get("downloads", 0),
            "atom": atom,
            "sig": sig,
            "detail": detail,
            "pre_tokenizer": pt,
            "normalizer": norm,
        })

    print(f"Classified {len(results)} models (excluding errors)\n")

    # Aggregate by canonical signature
    sig_counts = Counter()
    sig_examples = defaultdict(list)
    sig_atom = {}
    sig_downloads = defaultdict(int)
    for r in results:
        sig_counts[r["sig"]] += 1
        sig_examples[r["sig"]].append(r["id"])
        sig_atom[r["sig"]] = r["atom"]
        sig_downloads[r["sig"]] += r["downloads"]

    # Print the full ranked table
    print("=" * 120)
    print(f"{'CANONICAL PRE_TOKENIZER SIGNATURE':<55} {'ATOM':<18} {'COUNT':>6} {'∑DL':>12}  EXAMPLES")
    print("=" * 120)
    for sig, cnt in sig_counts.most_common():
        atom = sig_atom[sig]
        dl = sig_downloads[sig]
        exs = sig_examples[sig][:3]
        ex_str = " | ".join(exs)
        if len(ex_str) > 40:
            ex_str = ex_str[:37] + "..."
        print(f"{sig:<55} {atom:<18} {cnt:>6} {dl:>12,}  {ex_str}")
    print("=" * 120)
    print(f"TOTAL distinct signatures: {len(sig_counts)}")
    print(f"TOTAL models classified: {len(results)}")

    # Atom coverage summary
    print("\n" + "=" * 80)
    print("ATOM COVERAGE SUMMARY")
    print("=" * 80)
    atom_counts = Counter(r["atom"] for r in results)
    atom_dl = defaultdict(int)
    for r in results:
        atom_dl[r["atom"]] += r["downloads"]
    for atom, cnt in atom_counts.most_common():
        dl = atom_dl[atom]
        print(f"  {atom:<20} models={cnt:>5}  ∑downloads={dl:>13,}")

    # Patterns NOT covered by atoms
    print("\n" + "=" * 80)
    print("PATTERNS NOT COVERED BY ATOMS (need hand-unroll or escape hatch)")
    print("=" * 80)
    uncovered = [r for r in results if r["atom"] in ("UNKNOWN", "A1_split_regex", "SEQUENCE")]
    unc_sigs = Counter(r["sig"] for r in uncovered)
    unc_atom = defaultdict(set)
    for r in uncovered:
        unc_atom[r["atom"]].add(r["sig"])
    print(f"\nBy atom category:")
    for atom in sorted(unc_atom.keys()):
        sigs = unc_atom[atom]
        total_models = sum(sig_counts[s] for s in sigs)
        total_dl = sum(sig_downloads[s] for s in sigs)
        print(f"\n  [{atom}]  {len(sigs)} distinct signatures, {total_models} models, ∑{total_dl:,} downloads")
        for sig in sorted(sigs, key=lambda s: sig_downloads[s], reverse=True)[:20]:
            cnt = sig_counts[sig]
            dl = sig_downloads[sig]
            exs = sig_examples[sig][:2]
            print(f"    {sig:<60} {cnt:>4} models  ∑{dl:>10,}  e.g. {exs[0]}")

    # The key question: how many unique "important" patterns need hand-unroll?
    print("\n" + "=" * 80)
    print("UNIQUE PATTERNS NEEDING HAND-UNROLL")
    print("=" * 80)
    # "Important" = either appears in >1 model OR >10K downloads
    important_uncovered = []
    for sig, cnt in unc_sigs.items():
        dl = sig_downloads[sig]
        atom = sig_atom[sig]
        if cnt > 1 or dl > 10000:
            important_uncovered.append((sig, atom, cnt, dl, sig_examples[sig][:3]))
    important_uncovered.sort(key=lambda x: x[3], reverse=True)
    print(f"\n{len(important_uncovered)} distinct signatures with >1 model OR >10K downloads:")
    for sig, atom, cnt, dl, exs in important_uncovered:
        print(f"  [{atom}] {sig[:65]:<65} {cnt:>3}x  ∑{dl:>10,}  {exs[0]}")

    # Save full results
    out_path = os.path.join(os.path.dirname(__file__), "classification.json")
    with open(out_path, "w") as f:
        json.dump(results, f, indent=2, ensure_ascii=False, default=str)
    print(f"\nFull classification saved to {out_path}")

if __name__ == "__main__":
    main()