#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""指标③ selectivity 的 K-sweep + 纯随机 baseline.

real selectivity@K(ch) = 该 channel top-K 激活 token (neuron_analysis rank 1..K) 的
                         min(num/den,1) 平均; num=full_neuron_token_stats[ch][form],
                         den=该 token 在 400 条 selfgen 的 tokenizer 计数 (strip 对齐)。
跨 channel 平均 (再跨模块平均)。K ∈ {3,5,10,20,30,50}。

纯随机 baseline (配置/置换 null): 逐模块, 把每个 token t 的总高激活数 C_t = Σ_ch full[ch][t]
                         *均匀随机* 重新分配到该模块的 N 个 channel (保持每 token 总高激活数 +
                         数据集分母 den 不变, 只打乱'哪个 channel 高激活它')。再用同一公式算
                         selectivity@K (null 无激活值 -> 用 null-count 排 top-K)。
                         -> 一次性稀有词(den 小)在 null 里同样 sel≈1 (组合学必然), 但高频词
                            被单一 channel 完美锁定(<think>400/400) 在 null 里不会出现。
                            real ≫ null 的部分 = 真专一。

用法: selectivity_sweep.py --in_dir <batch_...-en> --model <m> --tokenizer <path> \
        --ks 3,5,10,20,30,50 --seed 0 --out sel_sweep_<m>.json
"""
import argparse, json, re
from collections import defaultdict, Counter
from pathlib import Path
import numpy as np


def _strip(e):
    return (e.get("token", "") if isinstance(e, dict) else str(e)).strip()


def channel_topk_forms(lst, K):
    """neuron_analysis[ch] 已按激活降序; 取前 K 个 distinct strip form (保序)."""
    out, seen = [], set()
    for e in lst:
        f = _strip(e)
        if not f or f in seen:
            continue
        seen.add(f); out.append(f)
        if len(out) >= K:
            break
    return out


def main(in_dir, model, tok_path, ks, seed, out):
    from transformers import AutoTokenizer
    tk = AutoTokenizer.from_pretrained(tok_path)
    in_dir = Path(in_dir); kmax = max(ks)
    rng = np.random.RandomState(seed)

    # 分母: 数据集 token 总频次 (strip 对齐, 不 lower)
    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 {sum(denom.values())} tok, {len(denom)} distinct", flush=True)

    na_files = sorted(in_dir.glob("*_neuron_analysis.json"))
    # 逐模块累加: 每 K 的 (real sel 之和, n_channel), (rand sel 之和, n_channel)
    real_sum = {K: 0.0 for K in ks}; real_n = {K: 0 for K in ks}
    rand_sum = {K: 0.0 for K in ks}; rand_n = {K: 0 for K in ks}

    for naf in na_files:
        try:
            na = json.loads(naf.read_text(encoding="utf-8")).get("neuron_top_tokens", {})
        except Exception as e:
            print(f"[{model}] skip {naf.name}: {e}", flush=True); continue
        ch_ids = [c for c in na if na.get(c)]
        N = len(ch_ids)
        if N < 2:
            continue
        # num = 该 channel 高激活该 token 的次数, 直接从 neuron_analysis raw list 计 (激活 token, strip 对齐).
        # 自洽口径: 与全分析一致用 activating token; 无需 _stats.json (抽取不产出, 且原版不可复现).
        nacnt = {ch: Counter(_strip(e) for e in na[ch]) for ch in ch_ids}

        # ---- real: 每 channel top-K 激活 token 的 min(num/den,1) 平均 ----
        for ch in ch_ids:
            forms = channel_topk_forms(na[ch], kmax)
            cnt = nacnt[ch]
            sels = []
            for f in forms:
                d = denom.get(f, 0)
                if d <= 0:                       # den=0 (结构 token) 不计入
                    continue
                sels.append(min(cnt[f] / d, 1.0))
            for K in ks:
                sk = sels[:K]
                if sk:
                    real_sum[K] += sum(sk) / len(sk); real_n[K] += 1

        # ---- random baseline: 每 token 总高激活数 C_t 均匀重分配到 N channel ----
        # 汇总该模块每 token 的总高激活数 (仅 den>0 的 token)
        C = Counter()
        for ch in ch_ids:
            for f, c in nacnt[ch].items():
                if denom.get(f, 0) > 0:
                    C[f] += c
        # 模拟分配 -> 每 channel 的 {token: null_count}
        null_ch = [dict() for _ in range(N)]
        for f, c in C.items():
            if c <= 0:
                continue
            idx = rng.randint(0, N, size=int(c))
            cnts = np.bincount(idx, minlength=N)
            nz = np.nonzero(cnts)[0]
            for j in nz:
                null_ch[j][f] = int(cnts[j])
        for j in range(N):
            tokcnt = null_ch[j]
            if not tokcnt:
                continue
            # null 无激活值 -> 按 null-count 降序取 top-K
            ordered = sorted(tokcnt.items(), key=lambda kv: kv[1], reverse=True)
            sels = [min(cnt / denom[f], 1.0) for f, cnt in ordered]
            for K in ks:
                sk = sels[:K]
                if sk:
                    rand_sum[K] += sum(sk) / len(sk); rand_n[K] += 1
        del na, nacnt

    res = {"model": model, "ks": ks, "seed": seed,
           "n_dataset_tokens": sum(denom.values()),
           "real": {str(K): round(real_sum[K] / real_n[K], 4) if real_n[K] else None for K in ks},
           "rand": {str(K): round(rand_sum[K] / rand_n[K], 4) if rand_n[K] else None for K in ks},
           "real_n": {str(K): real_n[K] for K in ks}, "rand_n": {str(K): rand_n[K] for K in ks}}
    Path(out).write_text(json.dumps(res, ensure_ascii=False, indent=1), encoding="utf-8")
    print(f"[{model}] real={res['real']}", flush=True)
    print(f"[{model}] rand={res['rand']} -> {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("--ks", default="3,5,10,20,30,50")
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--out", required=True)
    a = ap.parse_args()
    main(a.in_dir, a.model, a.tokenizer, [int(x) for x in a.ks.split(",")], a.seed, a.out)