src/calibration.py

"""Per-layer alpha sweep + monotonicity gate — v8b with CoT JSONL cache.

This version keeps the original 8B calibration/select behavior, but additionally
writes every generated calibration CoT for every layer x alpha into jsonl:

  data/monitoring/checkpoints/calib_cot_cache/
      layer_031_alpha_0.70.jsonl
      layer_031_alpha_0.30.jsonl
      layer_031_alpha_0.00.jsonl
      ...

Each row contains:
  layer_id, alpha, active/inactive, case_idx, problem, prompt,
  generated_text, think_text, detector counts, reduction/side_effect,
  repetition_score, and early-skip flags.
"""
import json, os, time
from typing import Dict, List
import numpy as np
from tqdm import tqdm
from src.detectors import BehaviorDetector
from src.interventions import generate_with_alpha
from src.utils import think_segment

MONOTONICITY_SLACK = 0.5


def _allowed_side_effects(n_inactive, side_effect_rate):
    return int(round(n_inactive * side_effect_rate))


def repetition_score(text, tail_chars=400, ngram=30):
    tail = text[-tail_chars:] if len(text) > tail_chars else text
    if len(tail) < ngram * 2:
        return 0.0
    seen = set()
    repeated = 0
    total = 0
    for i in range(len(tail) - ngram):
        chunk = tail[i:i + ngram]
        total += 1
        if chunk in seen:
            repeated += 1
        else:
            seen.add(chunk)
    return repeated / total if total else 0.0


def _cache_root():
    # default path works because slurm script cd's into project root
    root = os.environ.get(
        "CALIB_COT_CACHE_DIR",
        "data/monitoring/checkpoints/calib_cot_cache",
    )
    os.makedirs(root, exist_ok=True)
    return root


def _alpha_cache_file(layer_id, alpha):
    return os.path.join(
        _cache_root(),
        f"layer_{int(layer_id):03d}_alpha_{float(alpha):.2f}.jsonl",
    )


def _append_jsonl(path, obj):
    tmp_obj = dict(obj)
    with open(path, "a", encoding="utf-8") as f:
        f.write(json.dumps(tmp_obj, ensure_ascii=False) + "\n")


def _cache_generation(
    layer_id, alpha, kind, case_idx, sample,
    text, think, rep, new_count,
    reduction=None, side_effect=None,
    severe_repetition=False, gen_max_tokens=None,
):
    row = {
        "time": time.strftime("%Y-%m-%d %H:%M:%S"),
        "layer_id": int(layer_id),
        "alpha": float(alpha),
        "sample_kind": str(kind),          # active / inactive
        "case_idx": int(case_idx),
        "problem": sample.get("problem", ""),
        "prompt": sample.get("prompt", ""),
        "baseline_behavior_count": int(sample.get("behavior_count", 0)),
        "new_behavior_count": int(new_count),
        "reduction": None if reduction is None else float(reduction),
        "side_effect": None if side_effect is None else bool(side_effect),
        "repetition_score": float(rep),
        "severe_repetition": bool(severe_repetition),
        "gen_max_tokens": None if gen_max_tokens is None else int(gen_max_tokens),
        "generated_text": text,
        "think_text": think,
    }
    _append_jsonl(_alpha_cache_file(layer_id, alpha), row)


def _early_skip_result(layer_id, sweep, min_reduction, budget, severe_repetition, alpha, kind, case_idx, rep):
    return {
        "layer_id": int(layer_id),
        "best_alpha": 1.0,
        "best_reduction": 0.0,
        "fully_monotonic": False,
        "valid_prefix": [1.0],
        "prefix_has_intervention": False,
        "safe": False,
        "side_effect_budget": int(budget),
        "min_reduction": float(min_reduction),
        "sweep_detail": {f"{float(a):.2f}": v for a, v in sweep.items()},
        "severe_repetition": True,
        "severe_repetition_threshold": float(severe_repetition),
        "skip_reason": "severe_repetition",
        "skip_alpha": float(alpha),
        "skip_sample_kind": str(kind),
        "skip_case_idx": int(case_idx),
        "skip_repetition_score": float(rep),
    }


def calibrate_layer(
    model, tokenizer, direction_subspace, layer_id, alphas, device,
    active_samples, inactive_samples, detector,
    side_effect_rate=0.0, gen_max_tokens=2048,
    min_reduction=1.0, logger=None, severe_repetition=0.3,
):
    direction_per_layer = {layer_id: direction_subspace}
    budget = _allowed_side_effects(len(inactive_samples), side_effect_rate)
    sweep = {
        1.0: {
            "avg_reduction": 0.0,
            "reductions":    [0.0] * len(active_samples),
            "side_effects":  0,
            "n_inactive":    len(inactive_samples),
            "budget":        budget,
            "within_budget": True,
            "is_baseline":   True,
        }
    }

    for a in alphas:
        cache_file = _alpha_cache_file(layer_id, a)

        # Important: if this layer-alpha is recomputed, start a clean jsonl.
        # Resume still happens at the per-layer result level, so completed layers are not recomputed.
        if os.path.exists(cache_file):
            os.remove(cache_file)

        alpha_per_layer = {layer_id: a}
        red_list = []
        rep_list = []

        for case_idx, sample in enumerate(active_samples):
            text = generate_with_alpha(
                model, tokenizer, sample["prompt"],
                direction_per_layer, alpha_per_layer,
                device, max_new_tokens=gen_max_tokens,
            )
            think = think_segment(text)
            rep = repetition_score(think)
            rep_list.append(float(rep))

            new_count = detector.detect(think)["total"]
            reduction = sample["behavior_count"] - new_count

            _cache_generation(
                layer_id=layer_id,
                alpha=a,
                kind="active",
                case_idx=case_idx,
                sample=sample,
                text=text,
                think=think,
                rep=rep,
                new_count=new_count,
                reduction=reduction,
                side_effect=None,
                severe_repetition=(rep > severe_repetition),
                gen_max_tokens=gen_max_tokens,
            )

            if rep > severe_repetition:
                if logger:
                    logger.info(
                        f"  L{layer_id}: SKIP (severe repetition "
                        f"alpha={a:.2f} active_case={case_idx} "
                        f"rep={rep:.2f} thr={severe_repetition:.2f})"
                    )
                    logger.info(f"    cached bad CoT: {cache_file}")
                return _early_skip_result(
                    layer_id, sweep, min_reduction, budget,
                    severe_repetition, a, "active", case_idx, rep,
                )

            red_list.append(reduction)

        side = 0
        for case_idx, sample in enumerate(inactive_samples):
            text = generate_with_alpha(
                model, tokenizer, sample["prompt"],
                direction_per_layer, alpha_per_layer,
                device, max_new_tokens=gen_max_tokens,
            )
            think = think_segment(text)
            rep = repetition_score(think)
            rep_list.append(float(rep))

            new_count = detector.detect(think)["total"]
            is_side = new_count > sample["behavior_count"]

            _cache_generation(
                layer_id=layer_id,
                alpha=a,
                kind="inactive",
                case_idx=case_idx,
                sample=sample,
                text=text,
                think=think,
                rep=rep,
                new_count=new_count,
                reduction=None,
                side_effect=is_side,
                severe_repetition=(rep > severe_repetition),
                gen_max_tokens=gen_max_tokens,
            )

            if rep > severe_repetition:
                if logger:
                    logger.info(
                        f"  L{layer_id}: SKIP (severe repetition "
                        f"alpha={a:.2f} inactive_case={case_idx} "
                        f"rep={rep:.2f} thr={severe_repetition:.2f})"
                    )
                    logger.info(f"    cached bad CoT: {cache_file}")
                return _early_skip_result(
                    layer_id, sweep, min_reduction, budget,
                    severe_repetition, a, "inactive", case_idx, rep,
                )

            if is_side:
                side += 1

        avg_red = float(np.mean(red_list)) if red_list else 0.0
        sweep[a] = {
            "avg_reduction": avg_red,
            "reductions":    [float(r) for r in red_list],
            "side_effects":  int(side),
            "n_inactive":    len(inactive_samples),
            "budget":        budget,
            "within_budget": side <= budget,
            "is_baseline":   False,
            "max_repetition_score": float(max(rep_list)) if rep_list else 0.0,
            "cot_cache_file": cache_file,
        }

        # Fast strict-safe pruning.
        if float(a) == 0.0 and avg_red < 0.0:
            if logger:
                logger.info(
                    f"  L{layer_id}: SKIP "
                    f"(alpha=0.00 negative reduction red={avg_red:+.2f}; "
                    f"cannot be fully safe)"
                )
                logger.info(f"    cached CoT: {cache_file}")
            return {
                "layer_id": int(layer_id),
                "best_alpha": 1.0,
                "best_reduction": 0.0,
                "fully_monotonic": False,
                "valid_prefix": [1.0],
                "prefix_has_intervention": False,
                "safe": False,
                "side_effect_budget": int(budget),
                "min_reduction": float(min_reduction),
                "sweep_detail": {f"{float(k):.2f}": v for k, v in sweep.items()},
                "severe_repetition": False,
                "severe_repetition_threshold": float(severe_repetition),
                "skip_reason": "alpha0_negative_reduction",
                "skip_alpha": float(a),
                "skip_avg_reduction": float(avg_red),
                "cot_cache_file": cache_file,
            }

        if logger:
            tag = "ok" if side <= budget else "BUD"
            logger.info(
                f"    L{layer_id} a={a:.2f}: red={avg_red:+.2f} "
                f"side={side}/{len(inactive_samples)} (bud={budget}) "
                f"rep_max={(max(rep_list) if rep_list else 0.0):.2f} [{tag}] "
                f"cache={cache_file}"
            )

    sorted_desc = sorted(sweep.keys(), reverse=True)
    valid_prefix = [sorted_desc[0]]
    for i in range(1, len(sorted_desc)):
        prev_a, cur_a = sorted_desc[i - 1], sorted_desc[i]
        if (sweep[cur_a]["avg_reduction"]
                < sweep[prev_a]["avg_reduction"] - MONOTONICITY_SLACK):
            break
        valid_prefix.append(cur_a)

    best_alpha, best_red = 1.0, 0.0
    for a in [x for x in valid_prefix if x < 1.0]:
        d = sweep[a]
        if (d["within_budget"]
                and d["avg_reduction"] >= min_reduction
                and d["avg_reduction"] > best_red):
            best_alpha, best_red = a, d["avg_reduction"]

    fully_monotonic = len(valid_prefix) == len(sorted_desc)
    safe = best_alpha < 1.0 and best_red >= min_reduction
    return {
        "layer_id": layer_id,
        "best_alpha":      float(best_alpha),
        "best_reduction":  float(best_red),
        "fully_monotonic": bool(fully_monotonic),
        "valid_prefix":    [float(a) for a in valid_prefix],
        "prefix_has_intervention": len(valid_prefix) > 1,
        "safe":             bool(safe),
        "side_effect_budget": int(budget),
        "min_reduction":      float(min_reduction),
        "sweep_detail":   {f"{a:.2f}": v for a, v in sweep.items()},
    }


def calibrate_all_layers(
    model, tokenizer, direction_subspaces, alphas, device,
    active_samples, inactive_samples, detector,
    side_effect_rate=0.0, min_reduction=1.0, gen_max_tokens=2048,
    logger=None, per_layer_dir=None, severe_repetition=0.3,
):
    if per_layer_dir is not None:
        os.makedirs(per_layer_dir, exist_ok=True)

    os.makedirs(_cache_root(), exist_ok=True)

    results = {}
    layer_order = sorted(direction_subspaces.keys(), reverse=True)
    if logger:
        logger.info(f"  layer_order={layer_order}")
        logger.info(f"  severe_repetition_skip={severe_repetition}")
        logger.info(f"  cot_cache_dir={_cache_root()}")

    for lid in tqdm(layer_order, desc="  Calibrating"):
        layer_file = (
            os.path.join(per_layer_dir, f"layer_{lid:03d}.json")
            if per_layer_dir else None
        )
        if layer_file and os.path.exists(layer_file):
            try:
                with open(layer_file) as f:
                    saved = json.load(f)
                results[lid] = saved
                if logger:
                    tag = "KEEP" if saved.get("safe") else "SKIP"
                    extra = f" reason={saved.get('skip_reason')}" if saved.get("skip_reason") else ""
                    logger.info(
                        f"  L{lid}: [resume] {tag} "
                        f"a={saved.get('best_alpha', 1.0):.2f} "
                        f"red={saved.get('best_reduction', 0):+.2f}{extra}"
                    )
                continue
            except Exception as e:
                if logger:
                    logger.warning(
                        f"  L{lid}: [resume] unreadable ({e}); recomputing"
                    )

        if logger:
            logger.info(f"  Layer {lid}:")

        r = calibrate_layer(
            model, tokenizer, direction_subspaces[lid], lid, alphas, device,
            active_samples, inactive_samples, detector,
            side_effect_rate=side_effect_rate,
            min_reduction=min_reduction,
            gen_max_tokens=gen_max_tokens, logger=logger,
            severe_repetition=severe_repetition,
        )
        results[lid] = r

        if layer_file:
            tmp = layer_file + ".tmp"
            with open(tmp, "w") as f:
                json.dump(r, f, indent=2)
            os.replace(tmp, layer_file)

        tag = "KEEP" if r["safe"] else "SKIP"
        if logger:
            extra = ""
            if r.get("skip_reason"):
                extra = f" reason={r.get('skip_reason')} rep={r.get('skip_repetition_score', 0):.2f}"
            logger.info(
                f"  L{lid}: {tag} best_a={r['best_alpha']:.2f} "
                f"red={r['best_reduction']:+.2f} mono={r['fully_monotonic']}{extra}"
            )

    return results