thesaurus/code/thesaurus_grouping.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Phase-1 追加实验: 近义词库 (WordNet) 概念分组.

复用已抽取的 per-channel top tokens (*_neuron_analysis.json), 对每个 channel 的 top-K token
用三种方法分组并数概念组数:
  editdist : 现有 _token_similar (完全相同/子串/Levenshtein>=0.8) —— 复刻基线
  wordnet  : WordNet synset/lemma 近义合并 —— 本次新法
  (encoder : 可选, MiniLM 余弦; 若 sentence-transformers 不可用则跳过, 标 N/A)

逐 channel n_groups -> 按模型聚合 avg / std / 逐层 profile, 口径对齐 task1_polysemantic.json.

用法:
  python thesaurus_grouping.py --in_dir <batch_alpaca-cleaned-en> --model llama32_1b \
      --out task1_thesaurus_llama32_1b.json --topk 30 [--limit_channels 200 --limit_files 2] [--encoder]
"""
from __future__ import annotations
import argparse, json, re, sys
from collections import defaultdict
from pathlib import Path

# ---------------- token 清洗 ----------------
_BPE = ("▁", "Ġ", "Ċ")          # ▁ Ġ Ċ
_PUNCT = re.compile(r"^[^\w]+$", re.UNICODE)
_NUM = re.compile(r"^[\d.,:/%+\-]+$")

def clean(tok: str) -> str:
    t = tok or ""
    for b in _BPE:
        t = t.replace(b, "")
    return t.strip()

def is_word(t: str) -> bool:
    if not t or len(t) < 2:
        return False
    if _PUNCT.match(t) or _NUM.match(t):
        return False
    return any(c.isalpha() for c in t)

# ---------------- editdist 基线 (复刻 _token_similar) ----------------
try:
    from rapidfuzz.fuzz import ratio as _rf_ratio
    _HAS_RF = True
except Exception:
    _HAS_RF = False

def _lev_ratio(a: str, b: str) -> float:
    n, m = len(a), len(b)
    if n == 0 or m == 0:
        return 0.0
    d = list(range(m + 1))
    for i in range(1, n + 1):
        prev = d[0]; d[0] = i
        for j in range(1, m + 1):
            cur = d[j]
            cost = 0 if a[i-1] == b[j-1] else 1
            d[j] = min(d[j] + 1, d[j-1] + 1, prev + cost)
            prev = cur
    return 1.0 - d[m] / max(n, m)

def token_similar(a: str, b: str, min_ratio: float = 0.8, min_len_substr: int = 5) -> bool:
    if not a or not b:
        return False
    a, b = a.strip().lower(), b.strip().lower()
    if a == b:
        return True
    if len(a) >= min_len_substr and len(b) >= min_len_substr and (a in b or b in a):
        return True
    if _HAS_RF:
        return _rf_ratio(a, b) >= min_ratio * 100
    return _lev_ratio(a, b) >= min_ratio

# ---------------- WordNet 近义 ----------------
_WN = None
_LEMM = None
_POS = None
_WN_PRELOAD = False                   # all_synsets() 在本环境 omw 下病态慢, 不预载
def _init_wordnet():
    global _WN, _LEMM, _POS
    if _WN is not None:
        return
    from nltk.corpus import wordnet as wn
    from nltk.stem import WordNetLemmatizer
    _WN = wn
    _LEMM = WordNetLemmatizer()
    _POS = ["n", "v", "a", "r"]
    try:
        wn.synsets("test"); _LEMM.lemmatize("tests")
    except Exception as e:
        print(f"[warn] wordnet warmup failed: {e}", flush=True)
    # 全量预载: 把整个 WordNet 拉进内存一次 (~一次性几十秒), 之后 similar_tos/
    # hypernyms/lemmas 等关系遍历都是 RAM 命中. 扩充模式下逐 token lazy 读共享 FS
    # 会慢到不可用 (30k 词 x 多关系), 故默认全量预载.
    if _WN_PRELOAD:
        import time as _t
        t0 = _t.time()
        try:
            syns = list(wn.all_synsets())          # 一次性物化所有 synset 对象到内存
            print(f"[wordnet] preloaded {len(syns)} synsets in {_t.time()-t0:.0f}s", flush=True)
        except Exception as e:
            print(f"[warn] wordnet preload failed: {e}", flush=True)

def _lemma_forms(t: str):
    forms = {t}
    for p in _POS:
        try:
            forms.add(_LEMM.lemmatize(t, p))
        except Exception:
            pass
    return forms

def _synset_lemma_sets(t: str):
    """返回 (synset 名集合, 该词所有 synset 的 lemma 名集合). 试多种词形.
    扩充近义/同义覆盖 (默认开启, 见 _WN_EXPAND):
      - similar_tos : 形容词卫星同义 (big/large/huge 互连)
      - hypernyms   : 直接上位词 (1 级) + 其 lemma (轻度泛化, 让 co-hyponym 经共享上位词相连)
      - also_sees / verb_groups : 相关词
    严格模式 (_WN_EXPAND=False) 只用原 synset+lemma, 作为对比 baseline."""
    syns, lemmas = set(), set()
    for f in _lemma_forms(t):
        for s in _WN.synsets(f):
            related = [s]
            if _WN_EXPAND:
                try:
                    related = related + s.similar_tos() + s.hypernyms()
                except Exception:
                    pass
            for r in related:
                syns.add(r.name())
                for l in r.lemmas():
                    lemmas.add(l.name().lower().replace("_", " "))
    return syns, lemmas

_WN_EXPAND = True                     # True=扩充近义库; False=严格 synset (baseline)
_SYN_CACHE: dict = {}                 # 全局缓存: token 在所有 channel 间大量复现
_THES_TABLE = None                    # 预构建查表 {word: [synset names]}; 非空时走查表(零 WordNet 调用)

def load_thesaurus_table(path):
    """加载本地预构建的扩充近义词表; 之后 _syn/in_wordnet 纯查表, 不碰 WordNet 文件.
    一次性 read() 全文再 parse, 避免 Lustre 小块读病态; 分步打印进度."""
    global _THES_TABLE
    import json as _j, time as _t
    t0 = _t.time()
    with open(path, "rb") as _f:
        _raw = _f.read()                                  # 单次大块读
    print(f"[thesaurus] read {len(_raw)} bytes in {_t.time()-t0:.1f}s", flush=True)
    _obj = _j.loads(_raw.decode("utf-8"))
    print(f"[thesaurus] parsed {len(_obj)} entries in {_t.time()-t0:.1f}s", flush=True)
    _THES_TABLE = {w: set(v) for w, v in _obj.items()}
    print(f"[thesaurus] loaded table {len(_THES_TABLE)} words in {_t.time()-t0:.1f}s from {path}", flush=True)

# ---------------- WordNet-super (同类别: 按主导 lexname) ----------------
_SUPER_TABLE = None                   # {word: dominant_lexname}; 同 lexname => 同'类别'组

def load_super_table(path):
    """加载 super_thesaurus.json ({word: dominant_lexname}); super_synonym 纯查表."""
    global _SUPER_TABLE
    import json as _j, time as _t
    t0 = _t.time()
    with open(path, "rb") as _f:
        _raw = _f.read()
    _SUPER_TABLE = _j.loads(_raw.decode("utf-8"))
    print(f"[super] loaded {len(_SUPER_TABLE)} words in {_t.time()-t0:.1f}s from {path}", flush=True)

def in_super(t: str) -> bool:
    """真实词判定 (super 模式): 有主导 lexname 即认."""
    return bool(_SUPER_TABLE) and _SUPER_TABLE.get(t) is not None

def super_synonym(a: str, b: str, cache: dict | None = None) -> bool:
    """同类别: 共享主导 lexname (人名/动物/食物/地点/职业/情感/动作... 各自成类)."""
    if a == b:
        return True
    la = _SUPER_TABLE.get(a); lb = _SUPER_TABLE.get(b)
    return la is not None and la == lb

def super_group_metrics(tokens: list[str]) -> dict:
    """同 wordnet_group_metrics 口径, 但用 super_synonym (同类别) 分组, 真实词桶用 in_super."""
    word_raw = sorted(set(clean(t).lower() for t in tokens if is_word(clean(t))))
    words = [w for w in word_raw if in_super(w)]
    sizes = _group_sizes(words, super_synonym)
    n_words = len(words)
    multi = [s for s in sizes if s >= 2]
    n_singletons = len([s for s in sizes if s == 1])
    return {
        "n_word_raw": len(word_raw),
        "n_words": n_words,
        "frac_fragment": (1.0 - n_words / len(word_raw)) if word_raw else 0.0,
        "n_word_groups": len(sizes),
        "n_multi_groups": len(multi),
        "n_words_in_multi": sum(multi),
        "frac_merged": (sum(multi) / n_words) if n_words else 0.0,
        "avg_multi_size": (sum(multi) / len(multi)) if multi else 0.0,
        "max_multi_size": max(sizes) if sizes else 0,
        "n_groups_collapsed": len(multi) + (1 if n_singletons > 0 else 0),
    }

def _syn(t: str):
    if _THES_TABLE is not None:                 # 查表模式: 返回 (synset 名集合, 空 lemma 集)
        return (_THES_TABLE.get(t, set()), set())
    if t not in _SYN_CACHE:
        _SYN_CACHE[t] = _synset_lemma_sets(t)
    return _SYN_CACHE[t]

def in_wordnet(t: str) -> bool:
    """token 是否是 WordNet 认识的真实词. 查表模式: 表里有且 synset 非空.
    BPE subword 碎片不在 WordNet -> 排除, 否则虚增组数、稀释近义聚合信号."""
    if _THES_TABLE is not None:
        return len(_THES_TABLE.get(t, ())) > 0
    for f in _lemma_forms(t):
        if _WN.synsets(f):
            return True
    return False

def wordnet_synonym(a: str, b: str, cache: dict | None = None) -> bool:
    if a == b:
        return True
    sa, la = _syn(a); sb, lb = _syn(b)
    if sa & sb:                       # 共享 synset
        return True
    if b in la or a in lb:            # 互为对方 synset 的 lemma
        return True
    if la & lb:                       # 共享 lemma 名 (同义词链)
        return True
    return False

# ---------------- Union-Find 分组 ----------------
def _count_groups(items: list[str], sim_fn) -> int:
    n = len(items)
    if n <= 1:
        return n
    parent = list(range(n))
    def find(i):
        while parent[i] != i:
            parent[i] = parent[parent[i]]; i = parent[i]
        return i
    def union(i, j):
        pi, pj = find(i), find(j)
        if pi != pj:
            parent[pi] = pj
    for i in range(n):
        for j in range(i + 1, n):
            if find(i) == find(j):
                continue
            if sim_fn(items[i], items[j]):
                union(i, j)
    return len({find(i) for i in range(n)})

def _group_sizes(items: list[str], sim_fn) -> list[int]:
    """同 _count_groups 但返回每个 group 的大小列表 (保留结构, 用于按 group 算指标)."""
    n = len(items)
    if n == 0:
        return []
    if n == 1:
        return [1]
    parent = list(range(n))
    def find(i):
        while parent[i] != i:
            parent[i] = parent[parent[i]]; i = parent[i]
        return i
    def union(i, j):
        pi, pj = find(i), find(j)
        if pi != pj:
            parent[pi] = pj
    for i in range(n):
        for j in range(i + 1, n):
            if find(i) == find(j):
                continue
            if sim_fn(items[i], items[j]):
                union(i, j)
    from collections import Counter
    sizes = Counter(find(i) for i in range(n))
    return list(sizes.values())

def wordnet_group_metrics(tokens: list[str]) -> dict:
    """按 group 算近义词聚合指标 (只在 WordNet 真实词上, 条件于'近义词在同一 group').
    关键修复: 排除 BPE subword 碎片 (in_wordnet=False), 否则碎片各自成 singleton
    虚增组数、稀释近义聚合信号.
      n_word_raw       : is_word 通过的 distinct token 数 (含碎片)
      n_words          : WordNet 认识的真实词数 (去碎片后)
      frac_fragment    : 碎片占 is_word token 的比例
      n_word_groups    : 真实词 group 数
      n_multi_groups   : 大小>=2 的 group 数 (真正含近义词的 group)
      n_words_in_multi : 落在 size>=2 group 里的词数 (被近义聚合的词)
      frac_merged      : n_words_in_multi / n_words  (被聚合词占比)
      avg_multi_size   : size>=2 group 的平均大小 (近义组平均含几个词); 无则 0
      max_multi_size   : 最大 group 的大小
      n_groups_collapsed: 概念组数, '杂乱'(所有 singleton 散词)折叠为 1 个,
                          其余 size>=2 近义组各算 1 -> n_multi_groups + (1 if 有散词 else 0)
    """
    word_raw = sorted(set(clean(t).lower() for t in tokens if is_word(clean(t))))
    words = [w for w in word_raw if in_wordnet(w)]     # 去掉 BPE 碎片
    sizes = _group_sizes(words, wordnet_synonym)
    n_words = len(words)
    n_word_groups = len(sizes)
    multi = [s for s in sizes if s >= 2]
    n_singletons = len([s for s in sizes if s == 1])
    return {
        "n_word_raw": len(word_raw),
        "n_words": n_words,
        "frac_fragment": (1.0 - n_words / len(word_raw)) if word_raw else 0.0,
        "n_word_groups": n_word_groups,
        "n_multi_groups": len(multi),
        "n_words_in_multi": sum(multi),
        "frac_merged": (sum(multi) / n_words) if n_words else 0.0,
        "avg_multi_size": (sum(multi) / len(multi)) if multi else 0.0,
        "max_multi_size": max(sizes) if sizes else 0,
        "n_groups_collapsed": len(multi) + (1 if n_singletons > 0 else 0),
    }

def n_groups_editdist(tokens: list[str]) -> int:
    uniq = sorted(set(t.lower() for t in tokens if t))
    return _count_groups(uniq, token_similar)

def n_groups_wordnet(tokens: list[str]) -> int:
    """词桶用 WordNet 近义; 非词桶 (数字/标点/碎片) 用 editdist 兜底; 两者相加."""
    words = sorted(set(t.lower() for t in tokens if is_word(t)))
    nonwords = sorted(set(t.lower() for t in tokens if t and not is_word(t)))
    g_word = _count_groups(words, wordnet_synonym)
    g_non = _count_groups(nonwords, token_similar)
    return g_word + g_non

# ---------------- 主流程 ----------------
def channel_tokens(ntt_list, topk: int) -> list[str]:
    # 口径对齐论文: 按激活幅度 rank -> 去重 -> 取 top-K.
    # 注意: 同一 channel 的 raw list 含大量"完全相同 token"(如 ' the' ×N),
    # 完全相同 == 同一概念, 这里按 clean+lower 去重直接合并 (= 近义的极端情形).
    out, seen = [], set()
    for e in ntt_list:                   # 扫完整 ranked list 再去重 (raw 可达 400, 不设 cap)
        t = clean(e.get("token", "") if isinstance(e, dict) else str(e))
        if not t:
            continue
        key = t.lower()
        if key in seen:                  # 完全相同 (大小写无关) -> 同一概念, 跳过
            continue
        seen.add(key); out.append(t)
        if len(out) >= topk:
            break
    return out


# ---------------- 上下文还原: 用 char-offset 把 BPE 碎片补成完整词 ----------------
_ALPHA = re.compile(r"[A-Za-z]")

def expand_to_word(sent_text: str, start_char, end_char):
    """用句子原文 + token 的 [start_char, end_char) 把碎片向两侧扩到字母词边界.
    先去掉前后空格 (BPE 前导��格), 再沿字母扩展; 返回纯字母完整词或 None."""
    if sent_text is None or start_char is None or end_char is None:
        return None
    n = len(sent_text)
    a, b = int(start_char), int(end_char)
    if a < 0 or b > n or a >= b:
        return None
    while a < b and sent_text[a] == " ":
        a += 1
    while b > a and sent_text[b - 1] == " ":
        b -= 1
    while a > 0 and _ALPHA.match(sent_text[a - 1]):
        a -= 1
    while b < n and _ALPHA.match(sent_text[b]):
        b += 1
    w = sent_text[a:b]
    return w if w.isalpha() and len(w) >= 2 else None


def channel_tokens_ctx(ntt_list, topk: int, sentences):
    """与 channel_tokens 同口径, 但对'非完整词碎片'用上下文还原成完整词:
      - token clean 后若已是 WordNet 真实词 (in_wordnet) -> 原样用;
      - 否则尝试 expand_to_word(句子, start_char, end_char) 还原完整词;
        还原成功且是真实词 -> 用还原词, 计 recovered;
        还原失败/仍非真实词 -> 用 clean 原值 (后续 in_wordnet 仍会排除它).
    返回 (tokens, n_recovered): tokens 按完整词 lower 去重、保 rank 序、取 top-K.
    sentences: 该文件的 sentences 列表 (按 sentence_idx 索引); 为 None 时退化为 channel_tokens."""
    if sentences is None:
        return channel_tokens(ntt_list, topk), 0
    out, seen, n_rec = [], set(), 0
    for e in ntt_list:
        if not isinstance(e, dict):
            t = clean(str(e))
        else:
            t = clean(e.get("token", ""))
            if t and not in_wordnet(t.lower()):          # 仅碎片走还原
                si = e.get("sentence_idx")
                if si is not None and 0 <= si < len(sentences):
                    full = expand_to_word(sentences[si], e.get("start_char"), e.get("end_char"))
                    if full and in_wordnet(full.lower()):
                        t = full; n_rec += 1
        if not t:
            continue
        key = t.lower()
        if key in seen:
            continue
        seen.add(key); out.append(t)
        if len(out) >= topk:
            break
    return out, n_rec

def channel_raw_distinct(ntt_list):
    """全 raw list (不截断): 返回 (n_raw_valid, n_distinct_valid).
    体现 stage-1 压缩: 同一 channel 反复激活'完全相同'的 token (' the' ×N).
    n_raw/n_distinct = 平均每个 surface form 被激活几次."""
    n_raw, seen = 0, set()
    for e in ntt_list:
        t = clean(e.get("token", "") if isinstance(e, dict) else str(e))
        if not t:
            continue
        n_raw += 1
        seen.add(t.lower())
    return n_raw, len(seen)


def channel_rank_freq(ntt_list, kmax: int):
    """相同 token 频率分布 (按出现次数排名).
    ��一个 channel: 统计每个不同 token (clean+lower) 在整个 raw list 里出现的次数,
    按次数降序排名, 返回:
      - shares: 长度 kmax 的列表, shares[r] = 排名第 r+1 的 token 个数 / raw 总数
                (排名第1=出现最多的'完全相同'token占比; 不足 kmax 处补 0)
      - n_raw : 该 channel 的 raw valid 总数
    """
    from collections import Counter
    cnt = Counter()
    for e in ntt_list:
        t = clean(e.get("token", "") if isinstance(e, dict) else str(e))
        if not t:
            continue
        cnt[t.lower()] += 1
    n_raw = sum(cnt.values())
    if n_raw == 0:
        return [0.0] * kmax, 0
    freqs = sorted(cnt.values(), reverse=True)[:kmax]
    shares = [f / n_raw for f in freqs]
    if len(shares) < kmax:
        shares += [0.0] * (kmax - len(shares))
    return shares, n_raw


def channel_top1_freq(ntt_list):
    """该 channel 出现次数最多的 token 占全部 token 的频率 (top-1 share).
    用带重复的 raw list 计 (与 part-a 同源): top1_count / n_raw.
    返回 (top1_share, n_raw); n_raw=0 时返回 (0.0, 0)."""
    from collections import Counter
    cnt = Counter()
    for e in ntt_list:
        t = clean(e.get("token", "") if isinstance(e, dict) else str(e))
        if not t:
            continue
        cnt[t.lower()] += 1
    n_raw = sum(cnt.values())
    if n_raw == 0:
        return 0.0, 0
    return max(cnt.values()) / n_raw, n_raw


def parse_layer_module(fname: str):
    # e.g. Q_layer17_neuron_analysis.json  /  layer_output_layer9_neuron_analysis.json
    m = re.match(r"(.+)_layer(\d+)_neuron_analysis\.json$", fname)
    if not m:
        return None, None
    return m.group(1), int(m.group(2))

def run(in_dir: Path, model: str, out: Path, topk: int,
        limit_channels: int | None, limit_files: int | None, use_encoder: bool):
    _init_wordnet()
    enc = None
    if use_encoder:
        try:
            from sentence_transformers import SentenceTransformer
            enc = SentenceTransformer("all-MiniLM-L6-v2")
        except Exception as e:
            print(f"[warn] encoder unavailable ({e}); skip encoder arm", flush=True)
            enc = None

    files = sorted(in_dir.glob("*_neuron_analysis.json"))
    if limit_files:
        files = files[:limit_files]
    print(f"[{model}] {len(files)} files topk={topk} limit_ch={limit_channels} enc={enc is not None}", flush=True)

    # 预热: pass-1 只扫一遍收集 vocab (不保留 token 列表, 省内存; 8B 全量保留会 OOM)
    vocab = set()
    layers = []
    for f in files:
        module, layer = parse_layer_module(f.name)
        if layer is None:
            continue
        layers.append((layer, f))
        blob = json.loads(f.read_text(encoding="utf-8"))
        ntt = blob.get("neuron_top_tokens", {})
        ch_ids = list(ntt.keys())
        if limit_channels:
            ch_ids = ch_ids[:limit_channels]
        for ch in ch_ids:
            for t in channel_tokens(ntt[ch], topk):
                if is_word(t):
                    vocab.add(t.lower())
        del blob, ntt
    print(f"[{model}] prewarm {len(vocab)} unique word tokens ...", flush=True)
    for t in vocab:
        if t not in _SYN_CACHE:
            _SYN_CACHE[t] = _synset_lemma_sets(t)
    print(f"[{model}] prewarm done, cache={len(_SYN_CACHE)}", flush=True)

    per_layer = defaultdict(lambda: {"editdist": [], "wordnet": [], "encoder": [],
                                     "n_distinct": [], "n_raw": [],
                                     "avg_group_size": [], "redundancy": []})
    g_all = {"editdist": [], "wordnet": [], "encoder": [],
             "n_distinct": [], "n_raw": [], "avg_group_size": [], "redundancy": []}
    n_ch_total = 0
    # 相同 token 频率分布: 按出现次数排名 1..topk, 累加每个 channel 的占比向量再求均值.
    rank_share_sum = [0.0] * topk
    rank_share_n = 0

    # pass-2: 逐文件重新读取并分组 (不在内存中保留全部 token)
    for fi, (layer, f) in enumerate(layers):
        blob = json.loads(f.read_text(encoding="utf-8"))
        ntt = blob.get("neuron_top_tokens", {})
        ch_ids = list(ntt.keys())
        if limit_channels:
            ch_ids = ch_ids[:limit_channels]
        for ch in ch_ids:
            toks = channel_tokens(ntt[ch], topk)
            if len(toks) < 5:                 # 口径对齐论文: 少于 5 个 valid token 的 channel 排除
                continue
            n_ch_total += 1
            n_raw, _ = channel_raw_distinct(ntt[ch])
            n_distinct = len(toks)            # top-K 内的不同 token 数
            # 相同 token 频率排名分布: rank1=出现最多的'完全相同'token 占 raw 比例, ...
            shares, _ = channel_rank_freq(ntt[ch], topk)
            for r in range(topk):
                rank_share_sum[r] += shares[r]
            rank_share_n += 1
            ge = n_groups_editdist(toks)
            gw = n_groups_wordnet(toks)
            # A: 概念组数 gw; B: 平均每组 token 数 = distinct/G, 冗余率 = 1 - G/distinct
            avg_gsize = n_distinct / gw if gw else 0.0
            redund = 1.0 - gw / n_distinct if n_distinct else 0.0
            for k, val in (("editdist", ge), ("wordnet", gw),
                           ("n_distinct", n_distinct), ("n_raw", n_raw),
                           ("avg_group_size", avg_gsize), ("redundancy", redund)):
                g_all[k].append(val); per_layer[layer][k].append(val)
            if enc is not None:
                gc = _n_groups_encoder(toks, enc)
                g_all["encoder"].append(gc); per_layer[layer]["encoder"].append(gc)
        del blob, ntt
        print(f"  [{fi+1}/{len(layers)}] {f.name} ed={_mean(per_layer[layer]['editdist']):.2f} "
              f"wn={_mean(per_layer[layer]['wordnet']):.2f} "
              f"gsize={_mean(per_layer[layer]['avg_group_size']):.2f}", flush=True)

    def agg(method):
        v = g_all[method]
        if not v:
            return None
        lp = {str(L): round(_mean(per_layer[L][method]), 4)
              for L in sorted(per_layer) if per_layer[L][method]}
        return {"avg_n_clusters": round(_mean(v), 4), "std_n_clusters": round(_std(v), 4),
                "n_channels": len(v), "layer_avg_nc": lp}

    # 复用 agg 的均值/std/逐层接口给所有新指标 (字段名沿用 avg_n_clusters 以兼容画图脚本)
    rank_share_avg = [round(s / rank_share_n, 6) for s in rank_share_sum] if rank_share_n else []
    # 累计占比 (top-r 个 token 合计占 raw 多少): cumsum
    rank_share_cum, _acc = [], 0.0
    for s in rank_share_avg:
        _acc += s
        rank_share_cum.append(round(_acc, 6))
    result = {"model": model, "topk": topk, "n_channels_scored": n_ch_total,
              "rank_freq": {
                  "share_by_rank": rank_share_avg,   # 平均: 排名第 r 的 token 占 raw 比例
                  "cum_share_by_rank": rank_share_cum,
                  "n_channels": rank_share_n,
              },
              "methods": {m: agg(m) for m in
                          ("editdist", "wordnet", "encoder",
                           "n_distinct", "n_raw", "avg_group_size", "redundancy")}}
    out.write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
    em = result["methods"]["editdist"]; wm = result["methods"]["wordnet"]
    print(f"[{model}] DONE editdist_avg={em and em['avg_n_clusters']} "
          f"wordnet_avg={wm and wm['avg_n_clusters']} -> {out}", flush=True)
    return result

def _n_groups_encoder(tokens, enc, thresh: float = 0.55):
    import numpy as np
    embs = enc.encode(tokens, normalize_embeddings=True, show_progress_bar=False)
    sim = embs @ embs.T
    return _count_groups(list(range(len(tokens))), lambda i, j: sim[i][j] >= thresh)

def encoder_group_metrics(tokens, enc, thresh: float = 0.55) -> dict:
    """MiniLM 嵌入余弦 >= thresh 聚类, 返回与 wordnet_group_metrics 同口径的指标.
    在真实词桶上算 (排除碎片), 让 WordNet-expanded 与 MiniLM 可同标尺比较.
    MiniLM 能抓更广的语义相关 (dog/cat), WordNet 抓严格近义."""
    word_raw = sorted(set(clean(t).lower() for t in tokens if is_word(clean(t))))
    words = [w for w in word_raw if in_wordnet(w)]
    n_words = len(words)
    if n_words < 2:
        return {"n_word_raw": len(word_raw), "n_words": n_words,
                "frac_fragment": (1.0 - n_words / len(word_raw)) if word_raw else 0.0,
                "n_word_groups": n_words, "n_multi_groups": 0, "n_words_in_multi": 0,
                "frac_merged": 0.0, "avg_multi_size": 0.0, "max_multi_size": max(1, n_words)}
    import numpy as np
    embs = enc.encode(words, normalize_embeddings=True, show_progress_bar=False)
    sim = embs @ embs.T
    sizes = _group_sizes(list(range(n_words)),
                         lambda i, j: float(sim[i][j]) >= thresh)
    multi = [s for s in sizes if s >= 2]
    return {
        "n_word_raw": len(word_raw),
        "n_words": n_words,
        "frac_fragment": (1.0 - n_words / len(word_raw)) if word_raw else 0.0,
        "n_word_groups": len(sizes),
        "n_multi_groups": len(multi),
        "n_words_in_multi": sum(multi),
        "frac_merged": (sum(multi) / n_words) if n_words else 0.0,
        "avg_multi_size": (sum(multi) / len(multi)) if multi else 0.0,
        "max_multi_size": max(sizes) if sizes else 0,
    }

_EMB_CACHE = {}                       # {word: np.ndarray(L2-normalized)} 全局缓存, 避免每channel重编码

def prewarm_encoder_cache(words, enc, batch_size=4096):
    """一次性大批量编码所有 distinct 词并缓存. 大 GPU 用大 batch.
    之后 encoder_group_metrics_multi 纯查表+矩阵乘, 不再 GPU forward."""
    import numpy as np
    todo = sorted({w for w in words if w not in _EMB_CACHE})
    if not todo:
        return 0
    for i in range(0, len(todo), batch_size):
        chunk = todo[i:i + batch_size]
        embs = enc.encode(chunk, normalize_embeddings=True, show_progress_bar=False,
                          batch_size=min(batch_size, 1024))
        embs = np.asarray(embs, dtype=np.float32)
        for w, v in zip(chunk, embs):
            _EMB_CACHE[w] = v
    return len(todo)

def encoder_group_metrics_multi(tokens, enc, threshs=(0.35, 0.45, 0.55, 0.65)) -> dict:
    """编码一次, 在多个余弦阈值下各算一套指标 (encode 是瓶颈, 分组很便宜).
    返回 {thresh: 同 encoder_group_metrics 口径的 dict}; 便于事后选信号最清晰的阈值.
    优化: 优先用 _EMB_CACHE 查表 (prewarm 后零 GPU forward); 未命中的词才即时编码并入缓存."""
    word_raw = sorted(set(clean(t).lower() for t in tokens if is_word(clean(t))))
    words = [w for w in word_raw if in_wordnet(w)]
    n_words = len(words)
    base = {"n_word_raw": len(word_raw), "n_words": n_words,
            "frac_fragment": (1.0 - n_words / len(word_raw)) if word_raw else 0.0}
    if n_words < 2:
        empty = dict(base, n_word_groups=n_words, n_multi_groups=0, n_words_in_multi=0,
                     frac_merged=0.0, avg_multi_size=0.0, max_multi_size=max(1, n_words),
                     n_groups_collapsed=n_words)
        return {round(t, 2): empty for t in threshs}
    import numpy as np
    miss = [w for w in words if w not in _EMB_CACHE]
    if miss:                                          # 缓存未命中 -> 即时编码并存入
        me = np.asarray(enc.encode(miss, normalize_embeddings=True, show_progress_bar=False),
                        dtype=np.float32)
        for w, v in zip(miss, me):
            _EMB_CACHE[w] = v
    embs = np.stack([_EMB_CACHE[w] for w in words])
    sim = embs @ embs.T
    out = {}
    for th in threshs:
        sizes = _group_sizes(list(range(n_words)),
                             lambda i, j, _th=th: float(sim[i][j]) >= _th)
        multi = [s for s in sizes if s >= 2]
        n_singletons = len([s for s in sizes if s == 1])
        out[round(th, 2)] = dict(base,
            n_word_groups=len(sizes), n_multi_groups=len(multi), n_words_in_multi=sum(multi),
            frac_merged=(sum(multi) / n_words) if n_words else 0.0,
            avg_multi_size=(sum(multi) / len(multi)) if multi else 0.0,
            max_multi_size=max(sizes) if sizes else 0,
            n_groups_collapsed=len(multi) + (1 if n_singletons > 0 else 0))
    return out

def _mean(v): return sum(v) / len(v) if v else 0.0
def _std(v):
    if len(v) < 2: return 0.0
    m = _mean(v); return (sum((x - m) ** 2 for x in v) / len(v)) ** 0.5

if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--in_dir", required=True)
    ap.add_argument("--model", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--topk", type=int, default=50)
    ap.add_argument("--limit_channels", type=int, default=None)
    ap.add_argument("--limit_files", type=int, default=None)
    ap.add_argument("--encoder", action="store_true")
    a = ap.parse_args()
    run(Path(a.in_dir), a.model, Path(a.out), a.topk,
        a.limit_channels, a.limit_files, a.encoder)