thesaurus/code/random_baseline_v2.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""随机 baseline v2 — 真实的 null: 从模型自己的 token 池随机抽, 而非 curated 词典.
旧版从 77k WordNet 真实词抽 -> 偏高. 正常 null 应接近 0 (大量功能词/碎片被 is_word/in_wordnet 滤掉).

两个池 (per-model, 各模型 tokenizer 不同):
  A (alpaca): 模型在 400 句 self_gen 上实际产生的 token, *按出现频率加权* 抽 K 个不同的
              -> 高频功能词/碎片(the/of/ing/##s)主导, 与真实 channel top-K 的组成一致,
                 这些非真实词被 in_wordnet 剔出分母 -> 稀释聚合, 给出真正的 null.
              (旧版 bug: 去重成 SET 后均匀抽 -> 每次 50 个干净实词, 无碎片稀释 -> 虚高 35%)
  B (vocab) : 模型完整 tokenizer 词表的 distinct token, 均匀抽 K 个 (词表无天然频率)

伪channel = 从池里抽 K 个 *不同的* token; 走与真实 channel 完全相同的
clean->is_word->in_wordnet / super / encoder 流程, 取均值. 两口径(全部/只有组).

用法: random_baseline_v2.py --tokenizer <path> --model <m> --sentences <sent.json> \
        --thesaurus_table expanded_thesaurus.json --super_table super_thesaurus.json \
        --ks 3,5,10,20,30,50 --n 2000 --seed 0 --encoder --out random_v2_<m>.json
"""
import argparse, json, random, time
from pathlib import Path
import thesaurus_grouping as tg

ENC_THRESHS = (0.4, 0.45, 0.5)


def _agg(fm, avg, maxg, nmulti):
    n = len(nmulti); nwith = sum(1 for x in nmulti if x >= 1)
    s_fm, s_avg, s_nm = sum(fm), sum(avg), sum(nmulti)
    return {
        "frac_merged_mean": round(s_fm / n, 4) if n else 0.0,
        "avg_multi_size_mean": round(s_avg / n, 4) if n else 0.0,
        "n_multi_groups_mean": round(s_nm / n, 4) if n else 0.0,
        "frac_merged_grouponly": round(s_fm / nwith, 4) if nwith else 0.0,
        "avg_multi_size_grouponly": round(s_avg / nwith, 4) if nwith else 0.0,
        "n_multi_groups_grouponly": round(s_nm / nwith, 4) if nwith else 0.0,
        "n_with_group": nwith, "n_total": n,
        "max_group_size_int": int(max(maxg)) if maxg else 0,
        "max_n_multi_groups": int(max(nmulti)) if nmulti else 0,
    }


def build_pools(tok_path, sent_path):
    from transformers import AutoTokenizer
    from collections import Counter
    tk = AutoTokenizer.from_pretrained(tok_path)
    # B: 完整 vocab — decode 每个 id, clean, 去重 (保留所有, 不预过滤, 让流程自己滤)
    vocab_pool = set()
    vid = tk.get_vocab()
    for tid in vid.values():
        try:
            c = tg.clean(tk.decode([tid])).lower()
        except Exception:
            continue
        if c:
            vocab_pool.add(c)
    # A: alpaca — 400 句的 token *计频* (按模型分词, decode 单 token), 保留频率用于加权抽样
    sents = json.loads(Path(sent_path).read_text(encoding="utf-8"))["sentences"]
    cnt = Counter()
    for s in sents:
        for tid in tk.encode(s, add_special_tokens=False):
            c = tg.clean(tk.decode([tid])).lower()
            if c:
                cnt[c] += 1
    alpaca_tokens = sorted(cnt)
    alpaca_weights = [cnt[t] for t in alpaca_tokens]
    return alpaca_tokens, alpaca_weights, sorted(vocab_pool)


def run_pool(pool, ks, n, sample_fn, do_encoder):
    """sample_fn(K) -> K 个不同 token 的 list (alpaca 频率加权 / vocab 均匀)."""
    methods = ["wordnet", "super"] + ([f"enc{t}" for t in ENC_THRESHS] if do_encoder else [])
    out = {m: {} for m in methods}
    for K in ks:
        if len(pool) < K:
            continue
        acc = {m: {"fm": [], "avg": [], "maxg": [], "nmulti": []} for m in methods}
        for _ in range(n):
            toks = sample_fn(K)
            mw = tg.wordnet_group_metrics(toks); ms = tg.super_group_metrics(toks)
            for mth, m in (("wordnet", mw), ("super", ms)):
                a = acc[mth]; a["fm"].append(m["frac_merged"]); a["avg"].append(m["avg_multi_size"])
                a["maxg"].append(m["max_multi_size"]); a["nmulti"].append(m["n_multi_groups"])
            if do_encoder:
                mm = tg.encoder_group_metrics_multi(toks, None, threshs=ENC_THRESHS)
                for t in ENC_THRESHS:
                    em = mm[round(t, 2)]; a = acc[f"enc{t}"]
                    a["fm"].append(em["frac_merged"]); a["avg"].append(em["avg_multi_size"])
                    a["maxg"].append(em["max_multi_size"]); a["nmulti"].append(em["n_multi_groups"])
        for mth in methods:
            a = acc[mth]; out[mth][str(K)] = _agg(a["fm"], a["avg"], a["maxg"], a["nmulti"])
    return out


def main(tok_path, model, sent_path, table, super_table, ks, n, seed, out, do_encoder):
    import numpy as np
    rng = random.Random(seed)
    tg.load_thesaurus_table(table); tg.load_super_table(super_table)
    alpaca_tokens, alpaca_weights, vocab_pool = build_pools(tok_path, sent_path)
    print(f"[{model}] alpaca_pool={len(alpaca_tokens)} vocab_pool={len(vocab_pool)}", flush=True)
    if do_encoder:
        from group_metric_sweep import HFEncoder
        enc = HFEncoder()
        tg.prewarm_encoder_cache(sorted(set(alpaca_tokens) | set(vocab_pool)), enc, batch_size=8192)
        print(f"[{model}] enc cache={len(tg._EMB_CACHE)}", flush=True)
    # alpaca: 频率加权抽 K 个不同; vocab: 均匀抽 K 个不同
    rs = np.random.RandomState(seed)
    a_arr = np.array(alpaca_tokens, dtype=object)
    a_p = np.asarray(alpaca_weights, dtype=np.float64); a_p = a_p / a_p.sum()
    def alpaca_sample(K):
        return list(a_arr[rs.choice(len(a_arr), size=K, replace=False, p=a_p)])
    def vocab_sample(K):
        return rng.sample(vocab_pool, K)
    t0 = time.time()
    res = {"model": model, "ks": ks, "n_per_k": n, "seed": seed,
           "alpaca_sampling": "frequency_weighted", "vocab_sampling": "uniform",
           "alpaca_pool_size": len(alpaca_tokens), "vocab_pool_size": len(vocab_pool),
           "alpaca": run_pool(alpaca_tokens, ks, n, alpaca_sample, do_encoder),
           "vocab": run_pool(vocab_pool, ks, n, vocab_sample, do_encoder)}
    Path(out).write_text(json.dumps(res, ensure_ascii=False, indent=1), encoding="utf-8")
    for pool in ("alpaca", "vocab"):
        w = res[pool]["wordnet"].get("50", {})
        print(f"[{model}] {pool} K50 wordnet: all_fm={w.get('frac_merged_mean')} "
              f"grouponly={w.get('frac_merged_grouponly')} nwith={w.get('n_with_group')}/{w.get('n_total')}", flush=True)
    print(f"[{model}] -> {out}  ({time.time()-t0:.0f}s)", flush=True)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--tokenizer", required=True)
    ap.add_argument("--model", required=True)
    ap.add_argument("--sentences", required=True)
    ap.add_argument("--thesaurus_table", required=True)
    ap.add_argument("--super_table", required=True)
    ap.add_argument("--ks", default="3,5,10,20,30,50")
    ap.add_argument("--n", type=int, default=2000)
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--encoder", action="store_true")
    ap.add_argument("--out", required=True)
    a = ap.parse_args()
    main(a.tokenizer, a.model, a.sentences, a.thesaurus_table, a.super_table,
         [int(x) for x in a.ks.split(",")], a.n, a.seed, a.out, a.encoder)