llm_memory_validation/counterfactual_dense_bsc.py

from __future__ import annotations

import argparse
import json
import math
import statistics
import textwrap
from collections import Counter, defaultdict
from dataclasses import dataclass
from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np
import torch
from sklearn.metrics import accuracy_score, f1_score, mean_absolute_error
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from transformers import AutoModelForCausalLM, AutoTokenizer

from llm_memory_validation.bsc_longmemeval import (
    MemoryEntry,
    build_bsc,
    build_replay_only_router,
    count_words,
    exact_match,
    full_budget_words,
    load_dataset,
    make_entry,
    session_features,
    token_f1,
)
from llm_memory_validation.paper_competitor_suite import DenseEmbedder, dense_items_from_entries, dense_rag_retrieve


ACTIONS = ["discard", "replay", "cache", "consolidate"]
ACTION_TO_ID = {action: idx for idx, action in enumerate(ACTIONS)}
POSITIVE_ACTIONS = ["replay", "cache", "consolidate"]
ACTION_COMPUTE_PENALTY = {"replay": 0.08, "cache": 0.03, "consolidate": 0.02}
METHOD_ORDER = [
    "dense_budgeted_replay",
    "heuristic_dense_bsc",
    "counterfactual_oracle_bsc",
    "counterfactual_learned_bsc",
    "dense_rag_e5",
]


@dataclass
class CounterfactualCandidate:
    session_id: str
    session_index: int
    action: str
    text: str
    cost_words: int
    similarity: float


@dataclass
class ExampleContext:
    question_id: str
    question_type: str
    question: str
    gold_answer: str
    gold_session_ids: set[str]
    budget_words: int
    candidates_by_session: dict[int, dict[str, CounterfactualCandidate]]


@dataclass
class ControllerBundle:
    pipeline: Pipeline
    seed: int
    threshold: float
    train_mae: float
    val_mae: float
    train_macro_f1: float
    val_macro_f1: float
    train_accuracy: float
    val_accuracy: float


def split_examples(examples: list[dict], seed: int) -> tuple[list[dict], list[dict], list[dict]]:
    indices = list(range(len(examples)))
    labels = [example["question_type"] for example in examples]
    train_idx, temp_idx = train_test_split(
        indices,
        test_size=0.40,
        random_state=seed,
        stratify=labels,
    )
    temp_labels = [labels[index] for index in temp_idx]
    val_idx, test_idx = train_test_split(
        temp_idx,
        test_size=0.50,
        random_state=seed,
        stratify=temp_labels,
    )
    return (
        [examples[index] for index in train_idx],
        [examples[index] for index in val_idx],
        [examples[index] for index in test_idx],
    )


def make_question_features(question: str) -> list[float]:
    normalized = question.lower()
    return [
        len(normalized.split()),
        float(any(token in normalized for token in ["today", "tomorrow", "yesterday", "week", "month", "year"])),
        float(any(token in normalized for token in ["change", "updated", "new", "now", "instead"])),
        float(any(token in normalized for token in ["prefer", "favorite", "like", "love", "enjoy"])),
    ]


def build_context(example: dict, budget_frac: float, embedder: DenseEmbedder) -> ExampleContext:
    question = example["question"]
    question_embedding = embedder.encode([question], prefix="query")[0]
    budget_words = max(256, int(full_budget_words(example) * budget_frac))
    candidates_by_session: dict[int, dict[str, CounterfactualCandidate]] = defaultdict(dict)

    all_texts: list[str] = []
    metadata: list[tuple[int, str, str, int]] = []
    for index, (session_id, session) in enumerate(zip(example["haystack_session_ids"], example["haystack_sessions"])):
        for action in ("replay", "cache", "consolidate"):
            entry = make_entry(session, session_id, index, action)
            assert entry is not None
            all_texts.append(entry.text)
            metadata.append((index, action, session_id, entry.cost_words))

    embeddings = embedder.encode(all_texts, prefix="passage")
    similarities = embeddings @ question_embedding
    for (index, action, session_id, cost_words), similarity, text in zip(metadata, similarities, all_texts):
        candidates_by_session[index][action] = CounterfactualCandidate(
            session_id=session_id,
            session_index=index,
            action=action,
            text=text,
            cost_words=cost_words,
            similarity=float(similarity),
        )
    return ExampleContext(
        question_id=example["question_id"],
        question_type=example["question_type"],
        question=question,
        gold_answer=str(example["answer"]),
        gold_session_ids=set(example["answer_session_ids"]),
        budget_words=budget_words,
        candidates_by_session=candidates_by_session,
    )


def objective_for_candidates(selected: list[CounterfactualCandidate], context: ExampleContext, topk: int) -> tuple[float, dict]:
    if not selected:
        return 0.0, {"recall": 0.0, "mrr": 0.0, "answer_support": 0.0}
    ranked = sorted(selected, key=lambda item: item.similarity, reverse=True)[:topk]
    predicted_ids = [item.session_id for item in ranked]
    hit_positions = [rank for rank, session_id in enumerate(predicted_ids, start=1) if session_id in context.gold_session_ids]
    recall = len(set(predicted_ids) & context.gold_session_ids) / max(len(context.gold_session_ids), 1)
    mrr = 0.0 if not hit_positions else 1.0 / min(hit_positions)
    combined_text = "\n".join(item.text for item in ranked)
    answer_support = token_f1(combined_text, context.gold_answer)
    score = 2.6 * recall + 1.1 * mrr + 1.0 * answer_support
    return score, {"recall": recall, "mrr": mrr, "answer_support": answer_support}


def candidate_gain(
    selected: list[CounterfactualCandidate],
    context: ExampleContext,
    candidate: CounterfactualCandidate,
    topk: int,
    used_words: int = 0,
) -> float:
    if used_words + candidate.cost_words > context.budget_words:
        return float("-inf")
    current_score, _ = objective_for_candidates(selected, context, topk)
    new_score, _ = objective_for_candidates(selected + [candidate], context, topk)
    mem_penalty = 0.25 * (candidate.cost_words / max(context.budget_words, 1))
    compute_penalty = ACTION_COMPUTE_PENALTY[candidate.action]
    return new_score - current_score - mem_penalty - compute_penalty


def counterfactual_oracle_select(context: ExampleContext, topk: int) -> tuple[list[CounterfactualCandidate], list[str], list[float]]:
    selected: list[CounterfactualCandidate] = []
    chosen_sessions: set[int] = set()
    decisions = ["discard"] * len(context.candidates_by_session)
    gains = [0.0] * len(context.candidates_by_session)
    used_words = 0

    while True:
        best_gain = 0.0
        best_candidate: CounterfactualCandidate | None = None
        best_session: int | None = None
        remaining = sorted(set(context.candidates_by_session.keys()) - chosen_sessions)
        for session_index in remaining:
            for action, candidate in context.candidates_by_session[session_index].items():
                gain = candidate_gain(selected, context, candidate, topk, used_words=used_words)
                if gain > best_gain:
                    best_gain = gain
                    best_candidate = candidate
                    best_session = session_index
        if best_candidate is None:
            break
        selected.append(best_candidate)
        chosen_sessions.add(best_session)
        decisions[best_session] = best_candidate.action
        gains[best_session] = best_gain
        used_words += best_candidate.cost_words
    return selected, decisions, gains


def action_utilities_for_session(context: ExampleContext, session_index: int, topk: int) -> np.ndarray:
    utilities = []
    for action in POSITIVE_ACTIONS:
        candidate = context.candidates_by_session[session_index][action]
        gain = candidate_gain([], context, candidate, topk)
        utilities.append(gain if math.isfinite(gain) else -1.0)
    return np.asarray(utilities, dtype=np.float32)


def feature_vector(example: dict, context: ExampleContext, session_index: int) -> list[float]:
    session = example["haystack_sessions"][session_index]
    total = len(example["haystack_sessions"])
    feat = session_features(session, session_index, total)
    qfeat = make_question_features(example["question"])
    replay_cand = context.candidates_by_session[session_index]["replay"]
    cache_cand = context.candidates_by_session[session_index]["cache"]
    consolidate_cand = context.candidates_by_session[session_index]["consolidate"]
    return [
        math.log1p(feat["words"]),
        feat["user_turns"],
        feat["assistant_turns"],
        feat["fact_hits"],
        feat["update_hits"],
        feat["time_hits"],
        feat["number_hits"],
        feat["fact_lines"],
        feat["recent_frac"],
        feat["assistant_only"],
        feat["generic_assistant"],
        *qfeat,
        replay_cand.similarity,
        cache_cand.similarity,
        consolidate_cand.similarity,
        replay_cand.cost_words / context.budget_words,
        cache_cand.cost_words / context.budget_words,
        consolidate_cand.cost_words / context.budget_words,
    ]


def oversample_keep_rows(features: np.ndarray, utilities: np.ndarray, seed: int) -> tuple[np.ndarray, np.ndarray]:
    rng = np.random.default_rng(seed)
    keep_mask = np.max(utilities, axis=1) > 0.0
    keep_indices = np.where(keep_mask)[0]
    discard_indices = np.where(~keep_mask)[0]
    if len(keep_indices) == 0 or len(discard_indices) == 0:
        return features, utilities
    target = max(len(keep_indices), len(discard_indices))
    chosen_indices: list[int] = discard_indices.tolist()
    if len(discard_indices) < target:
        chosen_indices.extend(rng.choice(discard_indices, size=target - len(discard_indices), replace=True).tolist())
    chosen_indices.extend(keep_indices.tolist())
    if len(keep_indices) < target:
        chosen_indices.extend(rng.choice(keep_indices, size=target - len(keep_indices), replace=True).tolist())
    rng.shuffle(chosen_indices)
    return features[chosen_indices], utilities[chosen_indices]


def decisions_from_utilities(action_utilities: np.ndarray, threshold: float) -> np.ndarray:
    best_action_ids = np.argmax(action_utilities, axis=1)
    best_scores = np.max(action_utilities, axis=1)
    decisions = np.zeros(len(action_utilities), dtype=np.int64)
    keep_mask = best_scores > threshold
    decisions[keep_mask] = best_action_ids[keep_mask] + 1
    return decisions


def build_training_rows(
    examples: list[dict],
    contexts: dict[str, ExampleContext],
    topk: int,
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    features: list[list[float]] = []
    utility_targets: list[np.ndarray] = []
    oracle_labels: list[int] = []
    for example in examples:
        context = contexts[example["question_id"]]
        _, decisions, _ = counterfactual_oracle_select(context, topk)
        for session_index in range(len(example["haystack_sessions"])):
            features.append(feature_vector(example, context, session_index))
            utility_targets.append(action_utilities_for_session(context, session_index, topk))
            oracle_labels.append(ACTION_TO_ID[decisions[session_index]])
    return (
        np.asarray(features, dtype=np.float32),
        np.asarray(utility_targets, dtype=np.float32),
        np.asarray(oracle_labels, dtype=np.int64),
    )


def train_controller(
    train_examples: list[dict],
    val_examples: list[dict],
    contexts: dict[str, ExampleContext],
    topk: int,
    seeds: list[int],
) -> tuple[ControllerBundle, list[dict]]:
    train_x, train_y, train_oracle = build_training_rows(train_examples, contexts, topk)
    val_x, val_y, val_oracle = build_training_rows(val_examples, contexts, topk)
    bundles: list[ControllerBundle] = []
    metrics: list[dict] = []
    for seed in seeds:
        sampled_x, sampled_y = oversample_keep_rows(train_x, train_y, seed)
        pipeline = Pipeline(
            [
                ("scale", StandardScaler()),
                (
                    "mlp",
                    MLPRegressor(
                        hidden_layer_sizes=(128, 128),
                        activation="relu",
                        solver="adam",
                        alpha=1e-4,
                        learning_rate_init=1e-3,
                        batch_size=256,
                        max_iter=250,
                        random_state=seed,
                        early_stopping=True,
                        validation_fraction=0.1,
                        n_iter_no_change=15,
                    ),
                ),
            ]
        )
        pipeline.fit(sampled_x, sampled_y)
        train_pred_util = np.asarray(pipeline.predict(train_x), dtype=np.float32)
        val_pred_util = np.asarray(pipeline.predict(val_x), dtype=np.float32)
        candidate_thresholds = sorted(
            {
                -0.05,
                0.0,
                0.01,
                0.02,
                0.03,
                0.05,
                *np.quantile(np.max(val_pred_util, axis=1), [0.1, 0.25, 0.5, 0.75]).tolist(),
            }
        )
        best_threshold = 0.0
        best_val_macro_f1 = -1.0
        best_val_accuracy = -1.0
        for threshold in candidate_thresholds:
            val_pred = decisions_from_utilities(val_pred_util, float(threshold))
            val_macro_f1 = f1_score(val_oracle, val_pred, average="macro")
            val_accuracy = accuracy_score(val_oracle, val_pred)
            if (val_macro_f1, val_accuracy) > (best_val_macro_f1, best_val_accuracy):
                best_threshold = float(threshold)
                best_val_macro_f1 = val_macro_f1
                best_val_accuracy = val_accuracy
        train_pred = decisions_from_utilities(train_pred_util, best_threshold)
        val_pred = decisions_from_utilities(val_pred_util, best_threshold)
        bundle = ControllerBundle(
            pipeline=pipeline,
            seed=seed,
            threshold=best_threshold,
            train_mae=mean_absolute_error(train_y, train_pred_util),
            val_mae=mean_absolute_error(val_y, val_pred_util),
            train_macro_f1=f1_score(train_oracle, train_pred, average="macro"),
            val_macro_f1=f1_score(val_oracle, val_pred, average="macro"),
            train_accuracy=accuracy_score(train_oracle, train_pred),
            val_accuracy=accuracy_score(val_oracle, val_pred),
        )
        bundles.append(bundle)
        metrics.append(
            {
                "seed": seed,
                "threshold": bundle.threshold,
                "train_mae": bundle.train_mae,
                "val_mae": bundle.val_mae,
                "train_accuracy": bundle.train_accuracy,
                "val_accuracy": bundle.val_accuracy,
                "train_macro_f1": bundle.train_macro_f1,
                "val_macro_f1": bundle.val_macro_f1,
            }
        )
    best = max(bundles, key=lambda bundle: (bundle.val_macro_f1, bundle.val_accuracy))
    return best, metrics


def build_learned_selection(
    example: dict,
    context: ExampleContext,
    controller: ControllerBundle,
) -> tuple[list[CounterfactualCandidate], list[str], list[float]]:
    selected: list[CounterfactualCandidate] = []
    decisions = []
    confidences = []
    used_words = 0
    candidates = []
    for session_index in range(len(example["haystack_sessions"])):
        features = np.asarray([feature_vector(example, context, session_index)], dtype=np.float32)
        utilities = np.asarray(controller.pipeline.predict(features)[0], dtype=np.float32)
        positive_id = int(np.argmax(utilities))
        confidence = float(utilities[positive_id])
        action = POSITIVE_ACTIONS[positive_id]
        if confidence <= controller.threshold:
            action = "discard"
        decisions.append(action)
        confidences.append(confidence)
        if action == "discard":
            continue
        candidate = context.candidates_by_session[session_index][action]
        density = (confidence - controller.threshold) / max(candidate.cost_words, 1)
        candidates.append((density, confidence, -session_index, candidate))
    for _, _, _, candidate in sorted(candidates, reverse=True):
        if used_words + candidate.cost_words > context.budget_words:
            continue
        selected.append(candidate)
        used_words += candidate.cost_words
    return selected, decisions, confidences


def dense_predict_ids_from_candidates(context: ExampleContext, candidates: list[CounterfactualCandidate], topk: int) -> list[str]:
    ranked = sorted(candidates, key=lambda item: item.similarity, reverse=True)[:topk]
    return [item.session_id for item in ranked]


def prompt_from_dense_candidates(question: str, candidates: list[CounterfactualCandidate], topk: int, prompt_word_budget: int) -> str:
    ranked = sorted(candidates, key=lambda item: item.similarity, reverse=True)[:topk]
    blocks = []
    used = 0
    for rank, candidate in enumerate(ranked, start=1):
        words = candidate.text.split()
        clipped = " ".join(words[: min(len(words), 250)])
        block = f"[{rank}] action={candidate.action} session={candidate.session_id}\n{clipped}"
        block_cost = count_words(block)
        if blocks and used + block_cost > prompt_word_budget:
            break
        blocks.append(block)
        used += block_cost
    memory_text = "\n\n".join(blocks) if blocks else "[no memory]"
    return textwrap.dedent(
        f"""
        You answer a user question using retrieved long-term memory.
        Use only the memory below.
        Reply with a short direct answer and no explanation.
        If the answer is not supported, reply with "unknown".

        Question:
        {question}

        Memory:
        {memory_text}

        Answer:
        """
    ).strip()


def evaluate_retrieval(
    examples: list[dict],
    contexts: dict[str, ExampleContext],
    controller: ControllerBundle,
    dense_embedder: DenseEmbedder,
    topk: int,
) -> tuple[dict, dict, dict]:
    metrics: dict[str, dict] = {}
    rows_by_method: dict[str, list[dict]] = {}
    candidate_store: dict[str, dict[str, list[CounterfactualCandidate]]] = defaultdict(dict)

    def finalize(method: str, predicted_ids_by_example: list[list[str]], decision_usage: Counter[str] | None = None):
        recalls = []
        reciprocal_ranks = []
        per_type = defaultdict(list)
        rows = []
        for example, predicted_ids in zip(examples, predicted_ids_by_example):
            gold = set(example["answer_session_ids"])
            hits = [rank for rank, sid in enumerate(predicted_ids, start=1) if sid in gold]
            recall = len(set(predicted_ids) & gold) / max(len(gold), 1)
            rr = 0.0 if not hits else 1.0 / min(hits)
            recalls.append(recall)
            reciprocal_ranks.append(rr)
            per_type[example["question_type"]].append(recall)
            rows.append(
                {
                    "question_id": example["question_id"],
                    "question_type": example["question_type"],
                    "gold_session_ids": example["answer_session_ids"],
                    "predicted_session_ids": predicted_ids,
                }
            )
        metrics[method] = {
            "recall_at_5": float(sum(recalls) / len(recalls)),
            "mrr_at_5": float(sum(reciprocal_ranks) / len(reciprocal_ranks)),
            "per_type_recall_at_5": {
                question_type: float(sum(values) / len(values)) for question_type, values in per_type.items()
            },
        }
        if decision_usage is not None:
            metrics[method]["decision_usage"] = dict(decision_usage)
        rows_by_method[method] = rows

    replay_preds = []
    heuristic_preds = []
    oracle_preds = []
    learned_preds = []
    rag_preds = []
    oracle_usage = Counter()
    learned_usage = Counter()
    for example in examples:
        context = contexts[example["question_id"]]
        replay_entries = build_replay_only_router(example, 0.20)
        dense_replay = dense_items_from_entries(example, replay_entries, dense_embedder, topk)
        replay_preds.append([item.session_id for item in dense_replay])
        candidate_store[example["question_id"]]["dense_budgeted_replay"] = [
            context.candidates_by_session[entry.session_index]["replay"] for entry in replay_entries
        ]

        heuristic_entries = build_bsc(example, 0.20)
        dense_heuristic = dense_items_from_entries(example, heuristic_entries, dense_embedder, topk)
        heuristic_preds.append([item.session_id for item in dense_heuristic])
        heuristic_candidates = [context.candidates_by_session[entry.session_index][entry.action] for entry in heuristic_entries]
        candidate_store[example["question_id"]]["heuristic_dense_bsc"] = heuristic_candidates

        oracle_candidates, oracle_decisions, _ = counterfactual_oracle_select(context, topk)
        oracle_usage.update(oracle_decisions)
        oracle_preds.append(dense_predict_ids_from_candidates(context, oracle_candidates, topk))
        candidate_store[example["question_id"]]["counterfactual_oracle_bsc"] = oracle_candidates

        learned_candidates, learned_decisions, _ = build_learned_selection(example, context, controller)
        learned_usage.update(learned_decisions)
        learned_preds.append(dense_predict_ids_from_candidates(context, learned_candidates, topk))
        candidate_store[example["question_id"]]["counterfactual_learned_bsc"] = learned_candidates

        rag_items = dense_rag_retrieve(example, dense_embedder, topk)
        rag_preds.append([item.session_id for item in rag_items])
        candidate_store[example["question_id"]]["dense_rag_e5"] = [
            CounterfactualCandidate(
                session_id=item.session_id,
                session_index=-1,
                action="replay",
                text=item.text,
                cost_words=count_words(item.text),
                similarity=item.score,
            )
            for item in rag_items
        ]

    finalize("dense_budgeted_replay", replay_preds)
    finalize("heuristic_dense_bsc", heuristic_preds)
    finalize("counterfactual_oracle_bsc", oracle_preds, oracle_usage)
    finalize("counterfactual_learned_bsc", learned_preds, learned_usage)
    finalize("dense_rag_e5", rag_preds)
    return metrics, rows_by_method, candidate_store


def evaluate_controller_test(
    examples: list[dict],
    contexts: dict[str, ExampleContext],
    topk: int,
    controller: ControllerBundle,
) -> dict:
    labels = []
    preds = []
    for example in examples:
        context = contexts[example["question_id"]]
        _, decisions, _ = counterfactual_oracle_select(context, topk)
        for session_index in range(len(example["haystack_sessions"])):
            labels.append(ACTION_TO_ID[decisions[session_index]])
            features = np.asarray([feature_vector(example, context, session_index)], dtype=np.float32)
            utilities = np.asarray(controller.pipeline.predict(features)[0], dtype=np.float32)
            pred = int(decisions_from_utilities(utilities.reshape(1, -1), controller.threshold)[0])
            preds.append(pred)
    return {
        "test_accuracy": accuracy_score(labels, preds),
        "test_macro_f1": f1_score(labels, preds, average="macro"),
        "label_distribution": dict(Counter(ACTIONS[label] for label in labels)),
        "prediction_distribution": dict(Counter(ACTIONS[pred] for pred in preds)),
    }


def run_generation(
    examples: list[dict],
    candidate_store: dict[str, dict[str, list[CounterfactualCandidate]]],
    reader_model: str,
    methods: list[str],
    topk: int,
    prompt_word_budget: int,
    max_new_tokens: int,
) -> dict:
    tokenizer = AutoTokenizer.from_pretrained(reader_model, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    model = AutoModelForCausalLM.from_pretrained(
        reader_model,
        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
        device_map="auto",
        trust_remote_code=True,
    )
    model.eval()

    generation_metrics: dict[str, dict] = {}
    predictions_by_method: dict[str, list[dict]] = {}
    for method in methods:
        em_scores = []
        f1_scores = []
        per_type_em = defaultdict(list)
        per_type_f1 = defaultdict(list)
        predictions = []
        for example in examples:
            candidates = candidate_store[example["question_id"]][method]
            prompt = prompt_from_dense_candidates(
                question=example["question"],
                candidates=candidates,
                topk=topk,
                prompt_word_budget=prompt_word_budget,
            )
            model_inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
            with torch.no_grad():
                generated = model.generate(
                    **model_inputs,
                    max_new_tokens=max_new_tokens,
                    do_sample=False,
                    pad_token_id=tokenizer.eos_token_id,
                )
            completion_tokens = generated[0][model_inputs["input_ids"].shape[1]:]
            prediction = tokenizer.decode(completion_tokens, skip_special_tokens=True).strip().split("\n")[0].strip()
            gold = str(example["answer"])
            em = exact_match(prediction, gold)
            f1 = token_f1(prediction, gold)
            em_scores.append(em)
            f1_scores.append(f1)
            per_type_em[example["question_type"]].append(em)
            per_type_f1[example["question_type"]].append(f1)
            predictions.append(
                {
                    "question_id": example["question_id"],
                    "question_type": example["question_type"],
                    "gold_answer": gold,
                    "prediction": prediction,
                    "exact_match": em,
                    "token_f1": f1,
                }
            )
        generation_metrics[method] = {
            "exact_match": float(sum(em_scores) / len(em_scores)),
            "token_f1": float(sum(f1_scores) / len(f1_scores)),
            "per_type_exact_match": {
                question_type: float(sum(values) / len(values)) for question_type, values in per_type_em.items()
            },
            "per_type_token_f1": {
                question_type: float(sum(values) / len(values)) for question_type, values in per_type_f1.items()
            },
            "model_name": reader_model,
        }
        predictions_by_method[method] = predictions
    return {"metrics": generation_metrics, "predictions": predictions_by_method}


def plot_metrics(output_dir: Path, retrieval_metrics: dict, generation_metrics: dict) -> None:
    methods = METHOD_ORDER
    labels = [name.replace("_", "\n") for name in methods]
    x = np.arange(len(methods))
    width = 0.38

    plt.figure(figsize=(11, 4.8))
    recall = [retrieval_metrics[method]["recall_at_5"] for method in methods]
    mrr = [retrieval_metrics[method]["mrr_at_5"] for method in methods]
    plt.bar(x - width / 2, recall, width=width, label="Recall@5")
    plt.bar(x + width / 2, mrr, width=width, label="MRR@5")
    plt.xticks(x, labels)
    plt.ylim(0.0, 1.0)
    plt.ylabel("Score")
    plt.title("Counterfactual Dense Retrieval Results")
    plt.legend()
    plt.tight_layout()
    plt.savefig(output_dir / "retrieval_metrics.png", dpi=200)
    plt.close()

    plt.figure(figsize=(11, 4.8))
    em = [generation_metrics[method]["exact_match"] for method in methods]
    f1 = [generation_metrics[method]["token_f1"] for method in methods]
    plt.bar(x - width / 2, em, width=width, label="Exact Match")
    plt.bar(x + width / 2, f1, width=width, label="Token F1")
    plt.xticks(x, labels)
    plt.ylim(0.0, max(max(f1), max(em), 0.05) * 1.25)
    plt.ylabel("Score")
    plt.title("End-to-End Answer Accuracy")
    plt.legend()
    plt.tight_layout()
    plt.savefig(output_dir / "generation_metrics.png", dpi=200)
    plt.close()


def write_report(
    output_dir: Path,
    split_sizes: dict,
    budget_frac: float,
    controller_train_val: list[dict],
    controller_test: dict,
    retrieval_metrics: dict,
    generation_metrics: dict,
) -> None:
    lines = [
        "# Counterfactual Dense BSC",
        "",
        f"- Split sizes: `{split_sizes}`",
        f"- Budget fraction: `{budget_frac:.0%}`",
        "- Oracle: greedy counterfactual selection using dense retrieval + answer-support objective",
        "- Controller: `MLPRegressor(128, 128)` trained on dense per-action counterfactual utilities",
        "- Inference: discard if all predicted action utilities are below the validation-selected threshold",
        "",
        "## Controller",
        "",
    ]
    for row in controller_train_val:
        lines.extend(
            [
                f"### Seed {row['seed']}",
                f"- Threshold: `{row['threshold']:.4f}`",
                f"- Train MAE: `{row['train_mae']:.4f}`",
                f"- Val MAE: `{row['val_mae']:.4f}`",
                f"- Train accuracy: `{row['train_accuracy']:.4f}`",
                f"- Val accuracy: `{row['val_accuracy']:.4f}`",
                f"- Train macro-F1: `{row['train_macro_f1']:.4f}`",
                f"- Val macro-F1: `{row['val_macro_f1']:.4f}`",
                "",
            ]
        )
    lines.extend(
        [
            f"- Test accuracy: `{controller_test['test_accuracy']:.4f}`",
            f"- Test macro-F1: `{controller_test['test_macro_f1']:.4f}`",
            f"- Oracle label distribution: `{controller_test['label_distribution']}`",
            f"- Predicted label distribution: `{controller_test['prediction_distribution']}`",
            "",
            "## Retrieval",
            "",
        ]
    )
    for method in METHOD_ORDER:
        metrics = retrieval_metrics[method]
        lines.extend(
            [
                f"### {method}",
                f"- Recall@5: `{metrics['recall_at_5']:.4f}`",
                f"- MRR@5: `{metrics['mrr_at_5']:.4f}`",
                "",
            ]
        )
    lines.extend(["## Generation", ""])
    for method in METHOD_ORDER:
        metrics = generation_metrics[method]
        lines.extend(
            [
                f"### {method}",
                f"- Exact Match: `{metrics['exact_match']:.4f}`",
                f"- Token F1: `{metrics['token_f1']:.4f}`",
                "",
            ]
        )
    (output_dir / "REPORT.md").write_text("\n".join(lines), encoding="utf-8")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--budget-frac", type=float, default=0.20)
    parser.add_argument("--topk", type=int, default=5)
    parser.add_argument("--split-seed", type=int, default=11)
    parser.add_argument("--controller-seeds", type=int, nargs="+", default=[0, 1, 2])
    parser.add_argument("--retriever-model", type=str, default="intfloat/e5-base-v2")
    parser.add_argument("--reader-model", type=str, default="Qwen/Qwen2.5-3B-Instruct")
    parser.add_argument("--prompt-word-budget", type=int, default=1600)
    parser.add_argument("--max-new-tokens", type=int, default=48)
    args = parser.parse_args()

    args.output_dir.mkdir(parents=True, exist_ok=True)
    examples = load_dataset()
    train_examples, val_examples, test_examples = split_examples(examples, seed=args.split_seed)

    embedder = DenseEmbedder(model_name=args.retriever_model)
    contexts = {example["question_id"]: build_context(example, args.budget_frac, embedder) for example in examples}

    best_controller, controller_train_val = train_controller(
        train_examples=train_examples,
        val_examples=val_examples,
        contexts=contexts,
        topk=args.topk,
        seeds=args.controller_seeds,
    )
    controller_test = evaluate_controller_test(
        examples=test_examples,
        contexts=contexts,
        topk=args.topk,
        controller=best_controller,
    )
    retrieval_metrics, retrieval_rows, candidate_store = evaluate_retrieval(
        examples=test_examples,
        contexts=contexts,
        controller=best_controller,
        dense_embedder=embedder,
        topk=args.topk,
    )

    del embedder
    if torch.cuda.is_available():
        torch.cuda.empty_cache()

    generation_payload = run_generation(
        examples=test_examples,
        candidate_store=candidate_store,
        reader_model=args.reader_model,
        methods=METHOD_ORDER,
        topk=args.topk,
        prompt_word_budget=args.prompt_word_budget,
        max_new_tokens=args.max_new_tokens,
    )
    generation_metrics = generation_payload["metrics"]

    summary = {
        "budget_frac": args.budget_frac,
        "topk": args.topk,
        "split_seed": args.split_seed,
        "controller_seeds": args.controller_seeds,
        "retriever_model": args.retriever_model,
        "reader_model": args.reader_model,
        "split_sizes": {
            "train": len(train_examples),
            "val": len(val_examples),
            "test": len(test_examples),
        },
        "controller_train_val": controller_train_val,
        "controller_test": controller_test,
        "retrieval": retrieval_metrics,
        "generation": generation_metrics,
        "best_controller_seed": best_controller.seed,
    }
    (args.output_dir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
    (args.output_dir / "retrieval_rows.json").write_text(json.dumps(retrieval_rows, indent=2), encoding="utf-8")
    (args.output_dir / "generation_predictions.json").write_text(json.dumps(generation_payload["predictions"], indent=2), encoding="utf-8")
    plot_metrics(args.output_dir, retrieval_metrics, generation_metrics)
    write_report(
        output_dir=args.output_dir,
        split_sizes=summary["split_sizes"],
        budget_frac=args.budget_frac,
        controller_train_val=controller_train_val,
        controller_test=controller_test,
        retrieval_metrics=retrieval_metrics,
        generation_metrics=generation_metrics,
    )
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()