from __future__ import annotations import argparse import json import math import statistics from collections import Counter, defaultdict from dataclasses import dataclass from pathlib import Path import matplotlib.pyplot as plt import numpy as np from sklearn.metrics import accuracy_score, f1_score from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPClassifier from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler from llm_memory_validation.bsc_longmemeval import ( QUESTION_TYPES, MemoryEntry, TIME_RE, UPDATE_RE, build_bsc, build_fifo_replay, build_replay_only_router, build_uniform_replay, classify_action, count_words, extract_fact_lines, full_budget_words, load_dataset, make_entry, normalize_answer, retrieve_entries, session_features, session_text, tail_snippet, token_f1, ) ACTIONS = ["discard", "replay", "cache", "consolidate"] ACTION_TO_ID = {name: index for index, name in enumerate(ACTIONS)} PREFERENCE_HINTS = ("prefer", "favorite", "like", "love", "enjoy") METHOD_ORDER = [ "fifo_replay", "uniform_replay", "replay_only_router", "heuristic_bsc", "oracle_bsc", "learned_bsc", ] @dataclass class ControllerBundle: pipeline: Pipeline seed: int train_accuracy: float val_accuracy: float train_macro_f1: float val_macro_f1: float @dataclass class OracleDecision: action: str best_utility: float utility_by_action: dict[str, float] def keyword_overlap(lhs: str, rhs: str) -> float: lhs_tokens = set(normalize_answer(lhs).split()) rhs_tokens = set(normalize_answer(rhs).split()) if not lhs_tokens or not rhs_tokens: return 0.0 return len(lhs_tokens & rhs_tokens) / len(lhs_tokens | rhs_tokens) def question_features(question: str) -> dict[str, float]: normalized = normalize_answer(question) return { "question_words": len(normalized.split()), "question_time_hits": float(bool(TIME_RE.search(question))), "question_update_hits": float(bool(UPDATE_RE.search(question))), "question_pref_hits": float(any(token in normalized for token in PREFERENCE_HINTS)), } def action_renderings(session: list[dict], session_id: str, index: int) -> dict[str, MemoryEntry | None]: return { action: make_entry(session, session_id, index, action) if action != "discard" else None for action in ACTIONS } def oracle_action_for_session(example: dict, index: int, budget_frac: float) -> OracleDecision: session = example["haystack_sessions"][index] session_id = example["haystack_session_ids"][index] renderings = action_renderings(session, session_id, index) budget_words = max(256, int(full_budget_words(example) * budget_frac)) gold_ids = set(example["answer_session_ids"]) gold_answer = str(example["answer"]) question = example["question"] question_type = example["question_type"] session_id_is_gold = float(session_id in gold_ids) question_is_temporal = float(question_type == "temporal-reasoning" or bool(TIME_RE.search(question))) question_is_update = float(question_type == "knowledge-update" or bool(UPDATE_RE.search(question))) question_is_preference = float(question_type in {"single-session-user", "single-session-preference"}) multi_session_need = float(len(gold_ids) > 1 or question_type == "multi-session") utilities: dict[str, float] = {"discard": 0.0} for action in ("replay", "cache", "consolidate"): entry = renderings[action] assert entry is not None mem_cost = entry.cost_words / max(budget_words, 1) compute_cost = {"replay": 1.0, "cache": 0.35, "consolidate": 0.20}[action] answer_overlap = token_f1(entry.text, gold_answer) question_overlap = keyword_overlap(entry.text, question) temporal_detail = float(bool(TIME_RE.search(entry.text))) update_detail = float(bool(UPDATE_RE.search(entry.text))) preference_detail = float(any(token in normalize_answer(entry.text) for token in PREFERENCE_HINTS)) utility = ( 2.8 * session_id_is_gold + 1.4 * answer_overlap + 0.8 * question_overlap + 0.55 * question_is_temporal * temporal_detail * float(action in {"replay", "cache"}) + 0.45 * question_is_update * update_detail * float(action in {"cache", "consolidate"}) + 0.40 * question_is_preference * preference_detail * float(action == "consolidate") + 0.30 * multi_session_need * float(action in {"replay", "cache"}) - 0.65 * mem_cost - 0.18 * compute_cost ) if action == "consolidate" and question_is_temporal and not temporal_detail: utility -= 0.25 if action == "cache" and not (question_is_temporal or question_is_update): utility -= 0.05 if action == "replay" and question_is_preference and answer_overlap < 0.1: utility -= 0.10 utilities[action] = utility best_action, best_utility = max(utilities.items(), key=lambda item: item[1]) if best_utility <= 0.0: best_action = "discard" best_utility = 0.0 return OracleDecision(action=best_action, best_utility=best_utility, utility_by_action=utilities) def feature_vector(example: dict, index: int, budget_frac: float) -> list[float]: session = example["haystack_sessions"][index] session_id = example["haystack_session_ids"][index] total = len(example["haystack_sessions"]) feat = session_features(session, index, total) qfeat = question_features(example["question"]) renderings = action_renderings(session, session_id, index) raw_text = session_text(session) cache_text = renderings["cache"].text if renderings["cache"] is not None else tail_snippet(session, turns=4) consolidate_text = ( renderings["consolidate"].text if renderings["consolidate"] is not None else "\n".join(f"fact: {line}" for line in extract_fact_lines(session)) ) budget_words = max(256, int(full_budget_words(example) * budget_frac)) vector = [ 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["question_words"], qfeat["question_time_hits"], qfeat["question_update_hits"], qfeat["question_pref_hits"], keyword_overlap(raw_text, example["question"]), keyword_overlap(cache_text, example["question"]), keyword_overlap(consolidate_text, example["question"]), count_words(raw_text) / budget_words, count_words(cache_text) / budget_words, count_words(consolidate_text) / budget_words, float(bool(TIME_RE.search(raw_text))), float(bool(UPDATE_RE.search(raw_text))), ] return vector def build_oracle_bsc(example: dict, budget_frac: float) -> tuple[list[MemoryEntry], list[str], list[float]]: budget_words = max(256, int(full_budget_words(example) * budget_frac)) candidates: list[tuple[float, float, int, MemoryEntry]] = [] decisions: list[str] = [] utilities: list[float] = [] for index, session_id in enumerate(example["haystack_session_ids"]): decision = oracle_action_for_session(example, index, budget_frac) decisions.append(decision.action) utilities.append(decision.best_utility) if decision.action == "discard": continue entry = make_entry(example["haystack_sessions"][index], session_id, index, decision.action) assert entry is not None density = decision.best_utility / max(entry.cost_words, 1) candidates.append((density, decision.best_utility, -index, entry)) kept = [] used = 0 for _, _, _, entry in sorted(candidates, reverse=True): if used + entry.cost_words > budget_words: continue kept.append(entry) used += entry.cost_words return kept, decisions, utilities def build_dataset_rows(examples: list[dict], budget_frac: float) -> tuple[np.ndarray, np.ndarray]: features: list[list[float]] = [] labels: list[int] = [] for example in examples: for index in range(len(example["haystack_sessions"])): decision = oracle_action_for_session(example, index, budget_frac) features.append(feature_vector(example, index, budget_frac)) labels.append(ACTION_TO_ID[decision.action]) return np.asarray(features, dtype=np.float32), np.asarray(labels, dtype=np.int64) def train_controller( train_examples: list[dict], val_examples: list[dict], budget_frac: float, seeds: list[int], ) -> tuple[ControllerBundle, list[dict]]: train_x, train_y = build_dataset_rows(train_examples, budget_frac) val_x, val_y = build_dataset_rows(val_examples, budget_frac) bundles: list[ControllerBundle] = [] metrics: list[dict] = [] for seed in seeds: pipeline = Pipeline( [ ("scale", StandardScaler()), ( "mlp", MLPClassifier( hidden_layer_sizes=(128, 128), activation="relu", solver="adam", alpha=1e-4, learning_rate_init=1e-3, batch_size=256, max_iter=200, random_state=seed, early_stopping=True, validation_fraction=0.1, n_iter_no_change=15, ), ), ] ) pipeline.fit(train_x, train_y) train_pred = pipeline.predict(train_x) val_pred = pipeline.predict(val_x) bundle = ControllerBundle( pipeline=pipeline, seed=seed, train_accuracy=accuracy_score(train_y, train_pred), val_accuracy=accuracy_score(val_y, val_pred), train_macro_f1=f1_score(train_y, train_pred, average="macro"), val_macro_f1=f1_score(val_y, val_pred, average="macro"), ) bundles.append(bundle) metrics.append( { "seed": seed, "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 item: (item.val_macro_f1, item.val_accuracy)) return best, metrics def build_learned_bsc( example: dict, budget_frac: float, controller: ControllerBundle, ) -> tuple[list[MemoryEntry], list[str], list[float]]: budget_words = max(256, int(full_budget_words(example) * budget_frac)) candidates: list[tuple[float, float, int, MemoryEntry]] = [] decisions: list[str] = [] confidences: list[float] = [] for index, session_id in enumerate(example["haystack_session_ids"]): features = np.asarray([feature_vector(example, index, budget_frac)], dtype=np.float32) probabilities = controller.pipeline.predict_proba(features)[0] action_id = int(np.argmax(probabilities)) action = ACTIONS[action_id] confidence = float(probabilities[action_id]) decisions.append(action) confidences.append(confidence) if action == "discard": continue entry = make_entry(example["haystack_sessions"][index], session_id, index, action) assert entry is not None density = confidence / max(entry.cost_words, 1) candidates.append((density, confidence, -index, entry)) kept = [] used = 0 for _, _, _, entry in sorted(candidates, reverse=True): if used + entry.cost_words > budget_words: continue kept.append(entry) used += entry.cost_words return kept, decisions, confidences 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 evaluate_methods( examples: list[dict], budget_frac: float, topk: int, controller: ControllerBundle, ) -> tuple[dict, dict]: metrics_by_method: dict[str, dict] = {} artifacts: dict[str, list[dict]] = {} def evaluate_builder(name: str, builder_fn): recall_scores: list[float] = [] reciprocal_ranks: list[float] = [] action_counter: Counter[str] = Counter() decision_counter: Counter[str] = Counter() per_type_recall: dict[str, list[float]] = defaultdict(list) retained_counts: list[int] = [] rows: list[dict] = [] for example in examples: result = builder_fn(example) if isinstance(result, tuple): entries, decisions, aux_values = result else: entries = result decisions = ["replay"] * len(example["haystack_sessions"]) aux_values = [] retrieved = retrieve_entries(example["question"], entries, topk=topk) retained_counts.append(len(entries)) gold_ids = set(example["answer_session_ids"]) predicted_ids = [entry.session_id for entry in retrieved] hit_positions = [rank for rank, sid in enumerate(predicted_ids, start=1) if sid 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) decision_counter.update(decisions) action_counter.update(entry.action for entry in entries) row = { "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 ], } if aux_values: row["decision_scores"] = aux_values rows.append(row) metrics_by_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(retained_counts), "action_usage": dict(action_counter), "decision_usage": dict(decision_counter), "per_type_recall_at_5": { question_type: sum(values) / len(values) for question_type, values in per_type_recall.items() }, } artifacts[name] = rows evaluate_builder("fifo_replay", lambda example: build_fifo_replay(example, budget_frac)) evaluate_builder("uniform_replay", lambda example: build_uniform_replay(example, budget_frac)) evaluate_builder("replay_only_router", lambda example: build_replay_only_router(example, budget_frac)) evaluate_builder( "heuristic_bsc", lambda example: ( build_bsc(example, budget_frac), [classify_action(session, index, len(example["haystack_sessions"])) for index, session in enumerate(example["haystack_sessions"])], [], ), ) evaluate_builder("oracle_bsc", lambda example: build_oracle_bsc(example, budget_frac)) evaluate_builder("learned_bsc", lambda example: build_learned_bsc(example, budget_frac, controller)) return metrics_by_method, artifacts def controller_test_metrics( examples: list[dict], budget_frac: float, controller: ControllerBundle, ) -> dict: labels: list[int] = [] predictions: list[int] = [] for example in examples: for index in range(len(example["haystack_sessions"])): oracle = oracle_action_for_session(example, index, budget_frac) labels.append(ACTION_TO_ID[oracle.action]) probs = controller.pipeline.predict_proba( np.asarray([feature_vector(example, index, budget_frac)], dtype=np.float32) )[0] predictions.append(int(np.argmax(probs))) return { "test_accuracy": accuracy_score(labels, predictions), "test_macro_f1": f1_score(labels, predictions, average="macro"), "label_distribution": dict(Counter(ACTIONS[label] for label in labels)), "prediction_distribution": dict(Counter(ACTIONS[pred] for pred in predictions)), } def plot_results(output_dir: Path, 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=(10, 4.8)) recall = [metrics[name]["recall_at_5"] for name in methods] mrr = [metrics[name]["mrr_at_5"] for name 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("Held-Out LongMemEval-S Retrieval") plt.legend() plt.tight_layout() plt.savefig(output_dir / "learned_controller_metrics.png", dpi=200) plt.close() def write_report( output_dir: Path, split_seed: int, budget_frac: float, controller_metrics: list[dict], controller_test: dict, retrieval_metrics: dict, ) -> None: lines = [ "# Learned Controller Validation", "", f"- Split seed: `{split_seed}`", f"- Budget fraction: `{budget_frac:.0%}`", "- Split: `60% train / 20% val / 20% test`, stratified by `question_type`", "- Controller: `MLPClassifier(128, 128)` over session and question-conditioned features", "- Oracle labels: hindsight action chosen by utility = answer/session usefulness minus memory and compute cost", "", "## Controller Training", "", ] for row in controller_metrics: lines.extend( [ f"### Seed {row['seed']}", 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( [ "## Controller Test", "", 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 On Held-Out Test Split", "", ] ) for method in METHOD_ORDER: row = retrieval_metrics[method] lines.extend( [ f"### {method}", f"- Recall@5: `{row['recall_at_5']:.4f}`", f"- MRR@5: `{row['mrr_at_5']:.4f}`", f"- Avg retained entries: `{row['avg_retained_entries']:.2f}`", f"- Decision usage: `{row['decision_usage']}`", "", ] ) (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]) 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) best_controller, controller_metrics = train_controller( train_examples=train_examples, val_examples=val_examples, budget_frac=args.budget_frac, seeds=args.controller_seeds, ) controller_test = controller_test_metrics(test_examples, args.budget_frac, best_controller) retrieval_metrics, retrieval_rows = evaluate_methods( examples=test_examples, budget_frac=args.budget_frac, topk=args.topk, controller=best_controller, ) summary = { "budget_frac": args.budget_frac, "topk": args.topk, "split_seed": args.split_seed, "controller_seeds": args.controller_seeds, "split_sizes": { "train": len(train_examples), "val": len(val_examples), "test": len(test_examples), }, "controller_train_val": controller_metrics, "controller_test": controller_test, "retrieval": retrieval_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") plot_results(args.output_dir, retrieval_metrics) write_report( output_dir=args.output_dir, split_seed=args.split_seed, budget_frac=args.budget_frac, controller_metrics=controller_metrics, controller_test=controller_test, retrieval_metrics=retrieval_metrics, ) print(json.dumps(summary, indent=2)) if __name__ == "__main__": main()