#!/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 --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)