#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""指标③ 数据集归一专一度 selectivity — 口径: 每 channel 的 *top-1 激活* token (激活值最大).

与 selectivity.py 的区别: selectivity.py 取"高激活出现次数最多"的主导 token (freq);
本脚本取"激活值最大"的 token —— 即 neuron_analysis 排名第 1 的那个 token (rank-1 by activation)。
(用户口径选择: 严格按激活值最大, 即使该 token 是 count=1 的稀有词。)

sel(ch) = (该 top-1 token 在本 channel 高激活的次数, full_neuron_token_stats[ch][form])
          ────────────────────────────────────────────────────────────────────────
          (该 token 在 400 条 self_gen 回答里的总出现次数, tokenizer 数, strip 对齐)
          , clamp ≤ 1

strip 对齐: na token / full_stats key / denom key 全部 .strip() (不 lower), 避免 form 错配。
top-1 token 不在数据集分母里 (den=0, 如纯结构特殊 token) -> 该 channel 跳过 (计 skipped)。

跨模块平均 + max; best module; 最强证据 channel (sel,tok,num,den)。

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


def _module_of_na(fname):
    m = re.match(r"(.+)_layer\d+_neuron_analysis\.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)

    # ---- 分母: 数据集 token 总频次 (strip 对齐) ----
    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)

    na_files = sorted(in_dir.glob("*_neuron_analysis.json"))
    print(f"[{model}] {len(na_files)} neuron_analysis files", flush=True)

    by_mod_sum = defaultdict(float); by_mod_n = defaultdict(int); by_mod_max = defaultdict(float)
    by_mod_argmax = {}                      # module -> (sel, tok, num, den)
    n_skip_den0 = 0; n_ch = 0
    global_best = (0.0, None, None, 0, 0)   # (sel, module, tok, num, den) — 按 sel (多为 1/1 噪声)
    n_num1 = 0                              # top-1 token 是 one-off (num==1) 的 channel 数 = 噪声占比
    sum_num2 = 0.0; n_num2 = 0             # 仅 num>=2 的去噪均值
    best_locked = (0, None, None, 0)       # (num, module, tok, den) — sel==1.0 里 num 最大 = 真高频锁定证据

    for naf in na_files:
        mod = _module_of_na(naf.name)
        sf = naf.with_name(naf.name.replace("_neuron_analysis.json", "_stats.json"))
        try:
            na = json.loads(naf.read_text(encoding="utf-8")).get("neuron_top_tokens", {})
            full = json.loads(sf.read_text(encoding="utf-8")).get("full_neuron_token_stats", {})
        except Exception as e:
            print(f"[{model}] skip {naf.name}: {e}", flush=True); continue
        for ch, lst in na.items():
            if not lst:
                continue
            n_ch += 1
            # top-1 激活 token = 激活排名第 1 的 entry (neuron_analysis 已按激活降序)
            e0 = lst[0]
            form = (e0.get("token", "") if isinstance(e0, dict) else str(e0)).strip()
            if not form:
                continue
            den = denom.get(form, 0)
            if den <= 0:                              # top-1 token 不在数据集 -> 无定义, 跳过
                n_skip_den0 += 1
                continue
            # 分子: 该 form 在本 channel 高激活的次数 (full stats 完整计数; 缺则在 na list 里数)
            fs = full.get(ch, {})
            num = fs.get(form)
            if num is None:
                num = sum(1 for e in lst
                          if (e.get("token", "") if isinstance(e, dict) else str(e)).strip() == form)
            sel = num / den
            if sel > 1.0:
                sel = 1.0
            by_mod_sum[mod] += sel; by_mod_n[mod] += 1
            if num == 1:
                n_num1 += 1
            else:
                sum_num2 += sel; n_num2 += 1
            if sel >= 1.0 and num > best_locked[0]:        # 真高频锁定: sel=1 且 num 最大
                best_locked = (int(num), mod, form, int(den))
            if sel > by_mod_max[mod]:
                by_mod_max[mod] = sel
                by_mod_argmax[mod] = (round(sel, 4), form, int(num), int(den))
            if sel > global_best[0]:
                global_best = (round(sel, 4), mod, form, int(num), int(den))

    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

    result = {
        "model": model, "tokenizer": tok_path, "mode": "top1_by_activation",
        "n_dataset_tokens": sum(denom.values()), "n_distinct_dataset": len(denom),
        "n_channels": n_ch, "n_skipped_den0": n_skip_den0,
        "definition": "per-channel top-1 激活 token (激活值最大, neuron_analysis rank-1): "
                      "sel = full_stats[ch][form] / dataset_total[form]; clamp<=1",
        "noise_diag": {
            "n_num1": n_num1, "frac_num1": round(n_num1 / (n_ch - n_skip_den0), 4) if (n_ch - n_skip_den0) else 0.0,
            "mean_num_ge2": round(sum_num2 / n_num2, 4) if n_num2 else 0.0, "n_num_ge2": n_num2,
            "note": "frac_num1 高 = top-1激活token 多为 one-off 稀有词, mean_all 被其 sel=1/小den 抬高; "
                    "mean_num_ge2 为剔除 one-off 后的去噪均值",
        },
        "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,
        },
        "strongest_channel": {"sel": global_best[0], "module": global_best[1],
                              "token": global_best[2], "num": global_best[3], "den": global_best[4]},
        "strongest_locked": {"num": best_locked[0], "module": best_locked[1],
                             "token": best_locked[2], "den": best_locked[3],
                             "note": "sel=1.0 且 num 最大: top-1激活 token 是高频词且 channel 每次都锁定它 = 真专一证据"},
    }
    Path(out).write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
    gb = result["strongest_channel"]; bl = result["strongest_locked"]; nd = result["noise_diag"]
    print(f"[{model}] mean={cross_mod_mean}(num>=2:{nd['mean_num_ge2']}) max={cross_mod_max} best={best_mod}"
          f" frac_num1={nd['frac_num1']} skipped={n_skip_den0}/{n_ch}"
          f" | maxsel:{gb['module']}:{gb['token']} {gb['num']}/{gb['den']}"
          f" | locked:{bl['module']}:{bl['token']} {bl['num']}/{bl['den']} -> {out}", 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)