#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""数据集归一化 token selectivity (per-channel).

sel(ch, tok) = (tok 在该 channel 高激活的次数, full_neuron_token_stats[ch][tok])
               ──────────────────────────────────────────────────────────────
               (tok 在 400 条 self_gen 回答里的总出现次数, tokenizer 数, strip 对齐)

口径统一: 分子来自 full_neuron_token_stats (key 已 strip), 分母对 decode token 同样 strip.
每个 channel 取 selectivity 最高的 token -> 该 channel 的'专一度'(对某词最集中的占比);
report: 跨模块平均 + max (该 channel-level 标量), 以及全局 token-level 分布(诊断).

用法: selectivity.py --in_dir <batch_...-en> --model <m> --tokenizer <path> --out sel_<m>.json
"""
import argparse, json, glob, re
from collections import defaultdict, Counter
from pathlib import Path


def _module_of(fname):
    m = re.match(r"(.+)_layer\d+_stats\.json$", fname)
    return (m.group(1) if m else "?")


def main(in_dir, model, tok_path, out):
    from transformers import AutoTokenizer
    tk = AutoTokenizer.from_pretrained(tok_path)

    in_dir = Path(in_dir)
    stats_files = sorted(in_dir.glob("*_stats.json"))
    print(f"[{model}] {len(stats_files)} stats files", flush=True)

    # ---- 分母: 数据集 token 总频次 (strip 对齐 full_neuron_token_stats 的 key) ----
    sent_file = sorted(in_dir.glob("*_sentence.json"))[0]
    sentences = json.loads(sent_file.read_text(encoding="utf-8"))["sentences"]
    denom = Counter()
    for s in sentences:
        for tid in tk.encode(s, add_special_tokens=False):
            denom[tk.decode([tid]).strip()] += 1
    print(f"[{model}] dataset tokens: {sum(denom.values())} total, {len(denom)} distinct", flush=True)

    # ---- per-channel selectivity: sel(ch,tok)=full[ch][tok]/denom[tok] ----
    # 每 channel 取最大 sel token 作为该 channel 的标量; 按 module 聚合 (mean + 真实 max)
    by_mod_sum = defaultdict(float); by_mod_n = defaultdict(int); by_mod_max = defaultdict(float)
    by_mod_argmax = {}                     # module -> (best_sel, tok, num, den)
    tok_sel_global = {}                    # 诊断: 全局每 token 的最大 per-channel sel
    for f in stats_files:
        mod = _module_of(f.name)
        try:
            full = json.loads(f.read_text(encoding="utf-8")).get("full_neuron_token_stats", {})
        except Exception as e:
            print(f"[{model}] skip {f.name}: {e}", flush=True); continue
        for ch, toks in full.items():
            # 该 channel 高激活次数最多的 token (主导词); 算它的数据集占比
            dom_tok, dom_cnt = None, -1
            for tok, cnt in toks.items():
                if denom.get(tok, 0) <= 0:
                    continue                        # 数据集无此 form (特殊 token 等) -> 跳过
                if cnt > dom_cnt:
                    dom_cnt = cnt; dom_tok = tok
            if dom_tok is None:
                continue
            d = denom[dom_tok]
            sel = dom_cnt / d
            if sel > 1.0:
                sel = 1.0                           # clamp: 占比上限 100% (极少数 num>den 边缘)
            if sel > tok_sel_global.get(dom_tok, 0):
                tok_sel_global[dom_tok] = sel
            by_mod_sum[mod] += sel; by_mod_n[mod] += 1
            if sel > by_mod_max[mod]:
                by_mod_max[mod] = sel
                by_mod_argmax[mod] = (round(sel, 4), dom_tok, dom_cnt, d)

    per_mod_mean = {m: round(by_mod_sum[m] / by_mod_n[m], 4) for m in by_mod_sum if by_mod_n[m]}
    per_mod_max = {m: round(by_mod_max[m], 4) for m in by_mod_max}
    cross_mod_mean = round(sum(per_mod_mean.values()) / len(per_mod_mean), 4) if per_mod_mean else 0.0
    cross_mod_max = round(max(per_mod_max.values()), 4) if per_mod_max else 0.0
    best_mod = max(per_mod_mean, key=lambda m: per_mod_mean[m]) if per_mod_mean else None
    top_tok = sorted(tok_sel_global.items(), key=lambda kv: kv[1], reverse=True)[:30]

    result = {
        "model": model, "tokenizer": tok_path,
        "n_dataset_tokens": sum(denom.values()), "n_distinct_dataset": len(denom),
        "definition": "per-channel 主导token(高激活次数最多): sel=dom_count/dataset_total; clamp<=1",
        "cross_module": {
            "mean_all": cross_mod_mean, "max_all": cross_mod_max,
            "best_module": best_mod, "best_module_mean": per_mod_mean.get(best_mod, 0.0),
            "per_module_mean": per_mod_mean, "per_module_max": per_mod_max,
            "per_module_argmax": by_mod_argmax,           # 各 module 最专一的 (sel,tok,num,den)
        },
        "top30_token_selectivity": [(t, round(s, 4)) for t, s in top_tok],
    }
    Path(out).write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
    print(f"[{model}] cross_mod mean={cross_mod_mean} max={cross_mod_max} best={best_mod} -> {out}", flush=True)
    print(f"[{model}] top token-selectivity: " +
          ", ".join(f"{t}={s:.2f}" for t, s in top_tok[:8]), flush=True)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--in_dir", required=True)
    ap.add_argument("--model", required=True)
    ap.add_argument("--tokenizer", required=True)
    ap.add_argument("--out", required=True)
    a = ap.parse_args()
    main(a.in_dir, a.model, a.tokenizer, a.out)