llm_memory_validation/bsc_longmemeval.py

from __future__ import annotations

import argparse
import json
import math
import random
import re
import statistics
import string
import textwrap
import urllib.request
from collections import Counter, defaultdict
from dataclasses import dataclass
from pathlib import Path
from typing import Iterable

import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity


DATA_URL = "https://huggingface.co/datasets/LIXINYI33/longmemeval-s/resolve/main/longmemeval_s_cleaned.json"
QUESTION_TYPES = [
    "single-session-user",
    "single-session-preference",
    "single-session-assistant",
    "knowledge-update",
    "temporal-reasoning",
    "multi-session",
]
METHOD_SPECS = {
    "fifo_replay": "Newest raw sessions until the shared budget fills.",
    "uniform_replay": "Evenly spaced raw sessions under the same budget.",
    "replay_only_router": "Heuristic segment scoring, but memory can only keep raw replay entries.",
    "bsc": "OracleMem-style budgeted writer with discard / replay / cache / consolidate.",
}
METHOD_LABELS = {
    "fifo_replay": "FIFO raw replay",
    "uniform_replay": "Uniform raw replay",
    "replay_only_router": "Budgeted raw replay router",
    "bsc": "OracleMem writer",
}

FIRST_PERSON_PATTERNS = [
    r"\bi am\b",
    r"\bi'm\b",
    r"\bi work\b",
    r"\bi live\b",
    r"\bi study\b",
    r"\bi like\b",
    r"\bi love\b",
    r"\bi prefer\b",
    r"\bmy favorite\b",
    r"\bmy name is\b",
    r"\bi usually\b",
    r"\bi always\b",
    r"\bi often\b",
    r"\bi hate\b",
    r"\bi enjoy\b",
    r"\bmy job\b",
    r"\bmy birthday\b",
    r"\bmy address\b",
    r"\bmy phone\b",
    r"\bi need\b",
    r"\bi have\b",
]
UPDATE_PATTERNS = [
    r"\bactually\b",
    r"\binstead\b",
    r"\bchange\b",
    r"\bchanged\b",
    r"\bupdate\b",
    r"\bupdated\b",
    r"\bfrom now on\b",
    r"\bgoing forward\b",
    r"\bnew\b",
    r"\bnot anymore\b",
]
TIME_PATTERNS = [
    r"\btoday\b",
    r"\btomorrow\b",
    r"\byesterday\b",
    r"\btonight\b",
    r"\bthis week\b",
    r"\bnext week\b",
    r"\bnext month\b",
    r"\bnext year\b",
    r"\bmonday\b",
    r"\btuesday\b",
    r"\bwednesday\b",
    r"\bthursday\b",
    r"\bfriday\b",
    r"\bsaturday\b",
    r"\bsunday\b",
    r"\bjan(?:uary)?\b",
    r"\bfeb(?:ruary)?\b",
    r"\bmar(?:ch)?\b",
    r"\bapr(?:il)?\b",
    r"\bmay\b",
    r"\bjun(?:e)?\b",
    r"\bjul(?:y)?\b",
    r"\baug(?:ust)?\b",
    r"\bsep(?:tember)?\b",
    r"\boct(?:ober)?\b",
    r"\bnov(?:ember)?\b",
    r"\bdec(?:ember)?\b",
]

FIRST_PERSON_RE = re.compile("|".join(FIRST_PERSON_PATTERNS), re.IGNORECASE)
UPDATE_RE = re.compile("|".join(UPDATE_PATTERNS), re.IGNORECASE)
TIME_RE = re.compile("|".join(TIME_PATTERNS), re.IGNORECASE)
NUMBER_RE = re.compile(r"\b\d{1,4}\b")
GENERIC_ASSISTANT_RE = re.compile(
    r"\b(certainty|confidence score|here are|i can help|let me know|feel free)\b",
    re.IGNORECASE,
)


@dataclass
class MemoryEntry:
    session_id: str
    session_index: int
    action: str
    text: str
    cost_words: int
    priority: float


def load_dataset() -> list[dict]:
    with urllib.request.urlopen(DATA_URL) as handle:
        return json.load(handle)


def session_text(session: list[dict]) -> str:
    return "\n".join(f"{turn['role']}: {turn['content']}" for turn in session)


def count_words(text: str) -> int:
    return len(text.split())


def extract_fact_lines(session: list[dict]) -> list[str]:
    facts: list[str] = []
    for turn in session:
        if turn["role"] != "user":
            continue
        content = turn["content"].strip()
        if FIRST_PERSON_RE.search(content):
            facts.append(content)
    return facts[:6]


def tail_snippet(session: list[dict], turns: int = 4) -> str:
    sub_session = session[-turns:]
    return session_text(sub_session)


def session_features(session: list[dict], index: int, total: int) -> dict[str, float]:
    raw_text = session_text(session)
    user_turns = sum(1 for turn in session if turn["role"] == "user")
    assistant_turns = len(session) - user_turns
    fact_lines = extract_fact_lines(session)
    features = {
        "words": count_words(raw_text),
        "user_turns": user_turns,
        "assistant_turns": assistant_turns,
        "fact_hits": len(FIRST_PERSON_RE.findall(raw_text)),
        "update_hits": len(UPDATE_RE.findall(raw_text)),
        "time_hits": len(TIME_RE.findall(raw_text)),
        "number_hits": len(NUMBER_RE.findall(raw_text)),
        "fact_lines": len(fact_lines),
        "recent_rank": float(total - 1 - index),
        "recent_frac": float(total - index) / max(float(total), 1.0),
        "assistant_only": float(user_turns == 0),
        "generic_assistant": float(bool(GENERIC_ASSISTANT_RE.search(raw_text))),
    }
    return features


def classify_action(session: list[dict], index: int, total: int) -> str:
    features = session_features(session, index, total)
    raw_text = session_text(session).lower()

    if features["assistant_only"] and features["generic_assistant"]:
        return "discard"
    if features["fact_lines"] > 0 and (
        features["fact_hits"] > 0 or "favorite" in raw_text or "prefer" in raw_text
    ):
        return "consolidate"
    if features["recent_rank"] <= 4 or features["update_hits"] > 0:
        return "cache"
    if features["time_hits"] > 0 or features["number_hits"] >= 6:
        return "replay"
    if features["words"] < 80:
        return "discard"
    return "replay"


def make_entry(session: list[dict], session_id: str, session_index: int, action: str) -> MemoryEntry | None:
    raw_text = session_text(session)
    if action == "discard":
        return None
    if action == "replay":
        text = raw_text
        priority = 2.0
    elif action == "cache":
        text = tail_snippet(session, turns=4)
        priority = 3.0
    elif action == "consolidate":
        facts = extract_fact_lines(session)
        text = "\n".join(f"fact: {line}" for line in facts) if facts else tail_snippet(session, turns=2)
        priority = 4.0
    else:
        raise ValueError(f"Unknown action: {action}")
    return MemoryEntry(
        session_id=session_id,
        session_index=session_index,
        action=action,
        text=text,
        cost_words=count_words(text),
        priority=priority,
    )


def full_budget_words(example: dict) -> int:
    return sum(count_words(session_text(session)) for session in example["haystack_sessions"])


def build_fifo_replay(example: dict, budget_frac: float) -> list[MemoryEntry]:
    budget_words = max(256, int(full_budget_words(example) * budget_frac))
    candidates = [
        MemoryEntry(
            session_id=session_id,
            session_index=index,
            action="replay",
            text=session_text(session),
            cost_words=count_words(session_text(session)),
            priority=1.0,
        )
        for index, (session_id, session) in enumerate(
            zip(example["haystack_session_ids"], example["haystack_sessions"])
        )
    ]
    ordered = list(reversed(candidates))
    return take_under_budget(ordered, budget_words)


def build_uniform_replay(example: dict, budget_frac: float) -> list[MemoryEntry]:
    budget_words = max(256, int(full_budget_words(example) * budget_frac))
    candidates = [
        MemoryEntry(
            session_id=session_id,
            session_index=index,
            action="replay",
            text=session_text(session),
            cost_words=count_words(session_text(session)),
            priority=1.0,
        )
        for index, (session_id, session) in enumerate(
            zip(example["haystack_session_ids"], example["haystack_sessions"])
        )
    ]
    approx_mean = max(1.0, statistics.mean(entry.cost_words for entry in candidates))
    target_count = max(1, int(budget_words / approx_mean))
    if target_count == 1:
        selected_indices = [len(candidates) - 1]
    else:
        step = (len(candidates) - 1) / max(target_count - 1, 1)
        selected_indices = [round(step * i) for i in range(target_count)]
    selected = [candidates[i] for i in selected_indices]
    leftovers = [entry for idx, entry in enumerate(candidates) if idx not in set(selected_indices)]
    return take_under_budget(selected + leftovers, budget_words)


def build_replay_only_router(example: dict, budget_frac: float) -> list[MemoryEntry]:
    budget_words = max(256, int(full_budget_words(example) * budget_frac))
    total = len(example["haystack_sessions"])
    candidates: list[tuple[float, MemoryEntry]] = []
    for index, (session_id, session) in enumerate(
        zip(example["haystack_session_ids"], example["haystack_sessions"])
    ):
        raw_text = session_text(session)
        features = session_features(session, index, total)
        score = (
            2.0 * features["fact_hits"]
            + 1.5 * features["update_hits"]
            + 1.0 * features["time_hits"]
            + 0.3 * features["number_hits"]
            + 1.2 * features["recent_frac"]
        )
        entry = MemoryEntry(
            session_id=session_id,
            session_index=index,
            action="replay",
            text=raw_text,
            cost_words=count_words(raw_text),
            priority=score,
        )
        candidates.append((score / max(entry.cost_words, 1), entry))
    ordered = [entry for _, entry in sorted(candidates, key=lambda item: item[0], reverse=True)]
    return take_under_budget(ordered, budget_words)


def build_bsc(example: dict, budget_frac: float) -> list[MemoryEntry]:
    budget_words = max(256, int(full_budget_words(example) * budget_frac))
    total = len(example["haystack_sessions"])
    candidates: list[tuple[float, float, int, MemoryEntry]] = []
    for index, (session_id, session) in enumerate(
        zip(example["haystack_session_ids"], example["haystack_sessions"])
    ):
        action = classify_action(session, index, total)
        entry = make_entry(session, session_id, index, action)
        if entry is None:
            continue
        density = entry.priority / max(entry.cost_words, 1)
        candidates.append((density, entry.priority, -index, entry))
    ordered = [entry for _, _, _, entry in sorted(candidates, reverse=True)]
    return take_under_budget(ordered, budget_words)


def take_under_budget(entries: Iterable[MemoryEntry], budget_words: int) -> list[MemoryEntry]:
    kept: list[MemoryEntry] = []
    used = 0
    for entry in entries:
        if used + entry.cost_words > budget_words:
            continue
        kept.append(entry)
        used += entry.cost_words
    return kept


def retrieve_entries(question: str, entries: list[MemoryEntry], topk: int) -> list[MemoryEntry]:
    if not entries:
        return []
    documents = [entry.text for entry in entries]
    vectorizer = TfidfVectorizer(stop_words="english", max_features=20000)
    matrix = vectorizer.fit_transform(documents + [question])
    similarities = cosine_similarity(matrix[:-1], matrix[-1]).reshape(-1)
    ranked: list[tuple[float, MemoryEntry]] = []
    for similarity, entry in zip(similarities, entries):
        recency_bonus = {"cache": 0.03, "consolidate": 0.02, "replay": 0.0}.get(entry.action, 0.0)
        ranked.append((float(similarity) + recency_bonus, entry))
    ranked.sort(key=lambda item: item[0], reverse=True)
    return [entry for _, entry in ranked[:topk]]


def normalize_answer(text: str) -> str:
    lowered = str(text).lower()
    no_punct = lowered.translate(str.maketrans("", "", string.punctuation))
    tokens = no_punct.split()
    return " ".join(tokens)


def exact_match(prediction: str, gold: str) -> float:
    return float(normalize_answer(prediction) == normalize_answer(gold))


def token_f1(prediction: str, gold: str) -> float:
    pred_tokens = normalize_answer(prediction).split()
    gold_tokens = normalize_answer(gold).split()
    if not pred_tokens and not gold_tokens:
        return 1.0
    if not pred_tokens or not gold_tokens:
        return 0.0
    pred_counter = Counter(pred_tokens)
    gold_counter = Counter(gold_tokens)
    common = sum((pred_counter & gold_counter).values())
    if common == 0:
        return 0.0
    precision = common / len(pred_tokens)
    recall = common / len(gold_tokens)
    return 2 * precision * recall / (precision + recall)


def generation_subset(examples: list[dict], per_type: int, seed: int) -> list[int]:
    rng = random.Random(seed)
    by_type: dict[str, list[int]] = defaultdict(list)
    for index, example in enumerate(examples):
        by_type[example["question_type"]].append(index)
    selected: list[int] = []
    for question_type in QUESTION_TYPES:
        indices = list(by_type[question_type])
        rng.shuffle(indices)
        selected.extend(indices[:per_type])
    selected.sort()
    return selected


def prompt_from_entries(question: str, entries: list[MemoryEntry], prompt_word_budget: int) -> str:
    used = 0
    rendered_entries: list[str] = []
    for rank, entry in enumerate(entries, start=1):
        text_words = entry.text.split()
        max_words_for_item = min(len(text_words), 400)
        clipped = " ".join(text_words[:max_words_for_item])
        block = f"[{rank}] action={entry.action} session={entry.session_id}\n{clipped}"
        block_cost = count_words(block)
        if rendered_entries and used + block_cost > prompt_word_budget:
            break
        rendered_entries.append(block)
        used += block_cost
    memory_block = "\n\n".join(rendered_entries) if rendered_entries else "[no memory retained]"
    return textwrap.dedent(
        f"""
        You answer questions from a compressed long-term memory store.
        Use only the memory below.
        Give a short factual answer.
        If the memory is insufficient, answer with "unknown".

        Question:
        {question}

        Memory:
        {memory_block}

        Answer:
        """
    ).strip()


def evaluate_retrieval(examples: list[dict], budget_frac: float, topk: int) -> tuple[dict, dict]:
    builders = {
        "fifo_replay": build_fifo_replay,
        "uniform_replay": build_uniform_replay,
        "replay_only_router": build_replay_only_router,
        "bsc": build_bsc,
    }
    metrics_by_method: dict[str, dict] = {}
    artifacts: dict[str, list[dict]] = {}
    for method_name, builder in builders.items():
        recall_scores: list[float] = []
        reciprocal_ranks: list[float] = []
        action_counter: Counter[str] = Counter()
        actions_by_question_type: dict[str, Counter[str]] = defaultdict(Counter)
        decision_counter: Counter[str] = Counter()
        decision_by_question_type: dict[str, Counter[str]] = defaultdict(Counter)
        per_type_recall: dict[str, list[float]] = defaultdict(list)
        rows: list[dict] = []
        for example in examples:
            entries = builder(example, budget_frac)
            retrieved = retrieve_entries(example["question"], entries, topk=topk)
            gold_ids = set(example["answer_session_ids"])
            predicted_ids = [entry.session_id for entry in retrieved]
            hit_positions = [rank for rank, session_id in enumerate(predicted_ids, start=1) if session_id in gold_ids]
            recall_value = len(set(predicted_ids) & gold_ids) / max(len(gold_ids), 1)
            rr_value = 0.0 if not hit_positions else 1.0 / min(hit_positions)
            recall_scores.append(recall_value)
            reciprocal_ranks.append(rr_value)
            per_type_recall[example["question_type"]].append(recall_value)
            if method_name == "bsc":
                total = len(example["haystack_sessions"])
                for index, session in enumerate(example["haystack_sessions"]):
                    action = classify_action(session, index, total)
                    decision_counter[action] += 1
                    decision_by_question_type[example["question_type"]][action] += 1
            else:
                replay_decisions = len(example["haystack_sessions"])
                decision_counter["replay"] += replay_decisions
                decision_by_question_type[example["question_type"]]["replay"] += replay_decisions
            for entry in entries:
                action_counter[entry.action] += 1
                actions_by_question_type[example["question_type"]][entry.action] += 1
            rows.append(
                {
                    "question_id": example["question_id"],
                    "question_type": example["question_type"],
                    "gold_session_ids": example["answer_session_ids"],
                    "predicted_session_ids": predicted_ids,
                    "retrieved_entries": [
                        {
                            "session_id": entry.session_id,
                            "action": entry.action,
                            "cost_words": entry.cost_words,
                        }
                        for entry in retrieved
                    ],
                }
            )
        metrics_by_method[method_name] = {
            "recall_at_5": sum(recall_scores) / len(recall_scores),
            "mrr_at_5": sum(reciprocal_ranks) / len(reciprocal_ranks),
            "avg_retained_entries": statistics.mean(
                len(builder(example, budget_frac)) for example in examples
            ),
            "avg_full_words": statistics.mean(full_budget_words(example) for example in examples),
            "avg_budget_words": statistics.mean(max(256, int(full_budget_words(example) * budget_frac)) for example in examples),
            "action_usage": dict(action_counter),
            "per_type_recall_at_5": {
                question_type: sum(values) / len(values) for question_type, values in per_type_recall.items()
            },
            "decision_usage": dict(decision_counter),
            "action_usage_by_question_type": {
                question_type: dict(counter) for question_type, counter in actions_by_question_type.items()
            },
            "decision_usage_by_question_type": {
                question_type: dict(counter) for question_type, counter in decision_by_question_type.items()
            },
        }
        artifacts[method_name] = rows
    return metrics_by_method, artifacts


def run_generation(
    examples: list[dict],
    retrieval_rows: dict[str, list[dict]],
    budget_frac: float,
    model_name: str,
    per_type_subset: int,
    seed: int,
    prompt_word_budget: int,
    max_new_tokens: int,
) -> tuple[dict, dict]:
    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer

    subset_indices = generation_subset(examples, per_type=per_type_subset, seed=seed)
    subset_lookup = {index: examples[index] for index in subset_indices}
    rows_by_method = {method: {row["question_id"]: row for row in rows} for method, rows in retrieval_rows.items()}

    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        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] = {}
    generation_artifacts: dict[str, list[dict]] = {}
    for method_name, row_lookup in rows_by_method.items():
        predictions: list[dict] = []
        em_scores: list[float] = []
        f1_scores: list[float] = []
        per_type_em: dict[str, list[float]] = defaultdict(list)
        per_type_f1: dict[str, list[float]] = defaultdict(list)
        for index in subset_indices:
            example = subset_lookup[index]
            question_id = example["question_id"]
            retrieval_row = row_lookup[question_id]
            entry_lookup = {}
            if method_name == "fifo_replay":
                entries = build_fifo_replay(example, budget_frac)
            elif method_name == "uniform_replay":
                entries = build_uniform_replay(example, budget_frac)
            elif method_name == "replay_only_router":
                entries = build_replay_only_router(example, budget_frac)
            else:
                entries = build_bsc(example, budget_frac)
            for entry in entries:
                entry_lookup[entry.session_id] = entry
            retrieved_entries = [entry_lookup[item["session_id"]] for item in retrieval_row["retrieved_entries"] if item["session_id"] in entry_lookup]
            prompt = prompt_from_entries(
                question=example["question"],
                entries=retrieved_entries,
                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()
            prediction = prediction.split("\n")[0].strip()
            gold = example["answer"]
            em_value = exact_match(prediction, gold)
            f1_value = token_f1(prediction, gold)
            em_scores.append(em_value)
            f1_scores.append(f1_value)
            per_type_em[example["question_type"]].append(em_value)
            per_type_f1[example["question_type"]].append(f1_value)
            predictions.append(
                {
                    "question_id": question_id,
                    "question_type": example["question_type"],
                    "gold_answer": gold,
                    "prediction": prediction,
                    "exact_match": em_value,
                    "token_f1": f1_value,
                }
            )
        generation_metrics[method_name] = {
            "subset_size": len(subset_indices),
            "exact_match": sum(em_scores) / len(em_scores),
            "token_f1": sum(f1_scores) / len(f1_scores),
            "per_type_exact_match": {
                question_type: sum(values) / len(values) for question_type, values in per_type_em.items()
            },
            "per_type_token_f1": {
                question_type: sum(values) / len(values) for question_type, values in per_type_f1.items()
            },
            "model_name": model_name,
        }
        generation_artifacts[method_name] = predictions
    return generation_metrics, {"subset_indices": subset_indices, "predictions": generation_artifacts}


def plot_metrics(output_dir: Path, retrieval_metrics: dict, generation_metrics: dict | None) -> None:
    methods = list(METHOD_SPECS.keys())
    labels = [METHOD_LABELS.get(name, name).replace(" ", "\n") for name in methods]

    plt.figure(figsize=(8, 4.5))
    recall_values = [retrieval_metrics[name]["recall_at_5"] for name in methods]
    mrr_values = [retrieval_metrics[name]["mrr_at_5"] for name in methods]
    x = list(range(len(methods)))
    width = 0.38
    plt.bar([value - width / 2 for value in x], recall_values, width=width, label="Recall@5")
    plt.bar([value + width / 2 for value in x], mrr_values, width=width, label="MRR@5")
    plt.xticks(x, labels)
    plt.ylim(0.0, 1.0)
    plt.ylabel("Score")
    plt.title("LongMemEval-S Retrieval Under Equal Memory Budget")
    plt.legend()
    plt.tight_layout()
    plt.savefig(output_dir / "retrieval_metrics.png", dpi=200)
    plt.close()

    if generation_metrics is not None:
        plt.figure(figsize=(8, 4.5))
        em_values = [generation_metrics[name]["exact_match"] for name in methods]
        f1_values = [generation_metrics[name]["token_f1"] for name in methods]
        plt.bar([value - width / 2 for value in x], em_values, width=width, label="Exact Match")
        plt.bar([value + width / 2 for value in x], f1_values, width=width, label="Token F1")
        plt.xticks(x, labels)
        plt.ylim(0.0, 1.0)
        plt.ylabel("Score")
        plt.title("Reader EM/F1 on Stratified Generation Subset")
        plt.legend()
        plt.tight_layout()
        plt.savefig(output_dir / "generation_metrics.png", dpi=200)
        plt.close()

    plt.figure(figsize=(8, 5))
    actions = ["discard", "replay", "cache", "consolidate"]
    bottom = [0.0] * len(methods)
    for action in actions:
        values = []
        for method in methods:
            usage = retrieval_metrics[method]["decision_usage"]
            total = sum(usage.values()) or 1
            values.append(usage.get(action, 0) / total)
        plt.bar(labels, values, bottom=bottom, label=action)
        bottom = [current + value for current, value in zip(bottom, values)]
    plt.ylim(0.0, 1.0)
    plt.ylabel("Fraction of Stored Items")
    plt.title("Memory Action Distribution")
    plt.legend()
    plt.tight_layout()
    plt.savefig(output_dir / "action_distribution.png", dpi=200)
    plt.close()


def write_report(
    output_dir: Path,
    budget_frac: float,
    retrieval_metrics: dict,
    generation_metrics: dict | None,
    generation_subset_size: int,
) -> None:
    best_retrieval = max(retrieval_metrics.items(), key=lambda item: item[1]["recall_at_5"])
    report_lines = [
        "# Fast LLM Memory Validation",
        "",
        f"- Dataset: `LongMemEval-S` (`{len(QUESTION_TYPES)}` question types, 500 examples)",
        f"- Shared memory budget: `{budget_frac:.0%}` of the original haystack words per example",
        "- Methods: FIFO raw replay, uniform raw replay, budgeted raw replay router, OracleMem writer",
        "- Retrieval metric: `Recall@5` and `MRR@5` against the gold `answer_session_ids`",
        f"- Reader metric: stratified subset with `{generation_subset_size}` examples per question type" if generation_metrics is not None else "- Reader metric: not run",
        "",
        "## Retrieval",
        "",
    ]
    for method_name, metrics in retrieval_metrics.items():
        label = METHOD_LABELS.get(method_name, method_name)
        report_lines.extend(
            [
                f"### {label}",
                f"- Artifact key: `{method_name}`",
                f"- Recall@5: `{metrics['recall_at_5']:.4f}`",
                f"- MRR@5: `{metrics['mrr_at_5']:.4f}`",
                f"- Avg retained entries: `{metrics['avg_retained_entries']:.2f}`",
                f"- Action usage: `{metrics['action_usage']}`",
                "",
            ]
        )
    report_lines.extend(
        [
            "## Takeaway",
            "",
            f"- Best retrieval method: `{METHOD_LABELS.get(best_retrieval[0], best_retrieval[0])}` with Recall@5 `{best_retrieval[1]['recall_at_5']:.4f}` and MRR@5 `{best_retrieval[1]['mrr_at_5']:.4f}`.",
        ]
    )
    if generation_metrics is not None:
        best_generation = max(generation_metrics.items(), key=lambda item: item[1]["token_f1"])
        report_lines.extend(
            [
                f"- Best reader token F1: `{METHOD_LABELS.get(best_generation[0], best_generation[0])}` with Token F1 `{best_generation[1]['token_f1']:.4f}` and EM `{best_generation[1]['exact_match']:.4f}`.",
                "",
                "## Reader",
                "",
            ]
        )
        for method_name, metrics in generation_metrics.items():
            label = METHOD_LABELS.get(method_name, method_name)
            report_lines.extend(
                [
                    f"### {label}",
                    f"- Artifact key: `{method_name}`",
                    f"- Exact Match: `{metrics['exact_match']:.4f}`",
                    f"- Token F1: `{metrics['token_f1']:.4f}`",
                    f"- Model: `{metrics['model_name']}`",
                    "",
                ]
            )
    (output_dir / "REPORT.md").write_text("\n".join(report_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("--run-generation", action="store_true")
    parser.add_argument("--generation-per-type", type=int, default=20)
    parser.add_argument("--generation-seed", type=int, default=7)
    parser.add_argument("--prompt-word-budget", type=int, default=1600)
    parser.add_argument("--max-new-tokens", type=int, default=48)
    parser.add_argument("--reader-model", type=str, default="Qwen/Qwen2.5-1.5B-Instruct")
    args = parser.parse_args()

    args.output_dir.mkdir(parents=True, exist_ok=True)
    examples = load_dataset()

    retrieval_metrics, retrieval_rows = evaluate_retrieval(
        examples=examples,
        budget_frac=args.budget_frac,
        topk=args.topk,
    )
    generation_metrics = None
    generation_payload = None
    if args.run_generation:
        generation_metrics, generation_payload = run_generation(
            examples=examples,
            retrieval_rows=retrieval_rows,
            budget_frac=args.budget_frac,
            model_name=args.reader_model,
            per_type_subset=args.generation_per_type,
            seed=args.generation_seed,
            prompt_word_budget=args.prompt_word_budget,
            max_new_tokens=args.max_new_tokens,
        )

    summary = {
        "dataset_url": DATA_URL,
        "budget_frac": args.budget_frac,
        "topk": args.topk,
        "methods": METHOD_SPECS,
        "retrieval": retrieval_metrics,
        "generation": generation_metrics,
    }
    (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")
    if generation_payload is not None:
        (args.output_dir / "generation_payload.json").write_text(
            json.dumps(generation_payload, indent=2),
            encoding="utf-8",
        )

    plot_metrics(args.output_dir, retrieval_metrics=retrieval_metrics, generation_metrics=generation_metrics)
    write_report(
        output_dir=args.output_dir,
        budget_frac=args.budget_frac,
        retrieval_metrics=retrieval_metrics,
        generation_metrics=generation_metrics,
        generation_subset_size=args.generation_per_type,
    )

    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()