| from __future__ import annotations
|
|
|
| import argparse
|
| import hashlib
|
| import json
|
| import random
|
| import re
|
| import statistics
|
| import string
|
| import time
|
| import urllib.request
|
| from collections import Counter
|
| from dataclasses import dataclass
|
| from pathlib import Path
|
| from typing import Iterable
|
|
|
| DATA_URL = "https://huggingface.co/datasets/LIXINYI33/longmemeval-s/resolve/main/longmemeval_s_cleaned.json"
|
| DEFAULT_METHODS = [
|
| "dense_budgeted_bsc",
|
| "dense_rag_e5",
|
| "dense_budgeted_replay",
|
| "fifo_replay",
|
| ]
|
|
|
| PROMPT_MODES = (
|
| "answer_if_supported",
|
| "evidence_extraction_first",
|
| "extractive_answer",
|
| )
|
|
|
| METHOD_LABELS = {
|
| "dense_budgeted_bsc": "OracleMem writer + dense retrieval",
|
| "heuristic_bsc": "OracleMem writer + lexical retrieval",
|
| "dense_rag_e5": "Full raw-store dense retrieval",
|
| "dense_budgeted_replay": "Budgeted raw replay + dense retrieval",
|
| "replay_only_router": "Budgeted raw replay router",
|
| "fifo_replay": "FIFO raw replay",
|
| "uniform_replay": "Uniform raw replay",
|
| "memorybank_proxy": "MemoryBank proxy",
|
| "ld_agent_proxy": "LD-Agent proxy",
|
| }
|
|
|
| METHOD_ALIASES = {
|
| "oraclemem_dense": "dense_budgeted_bsc",
|
| "oracle_dense": "dense_budgeted_bsc",
|
| "full_raw_dense": "dense_rag_e5",
|
| "budgeted_raw_dense": "dense_budgeted_replay",
|
| "budgeted_raw_replay": "dense_budgeted_replay",
|
| "fifo_raw": "fifo_replay",
|
| }
|
|
|
| FOCUS_TYPES = {"knowledge-update", "temporal-reasoning"}
|
|
|
| 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
|
|
|
|
|
| @dataclass
|
| class ContextEntry:
|
| session_id: str
|
| action: str
|
| text: str
|
| source: str
|
|
|
|
|
| def csv_arg(value: str) -> list[str]:
|
| return [part.strip() for part in value.split(",") if part.strip()]
|
|
|
|
|
| def canonical_method_name(method: str) -> str:
|
| return METHOD_ALIASES.get(method, method)
|
|
|
|
|
| def canonical_method_list(methods: Iterable[str]) -> list[str]:
|
| canonical: list[str] = []
|
| for method in methods:
|
| name = canonical_method_name(method)
|
| if name not in canonical:
|
| canonical.append(name)
|
| return canonical
|
|
|
|
|
| def validate_prompt_modes(prompt_modes: Iterable[str]) -> list[str]:
|
| modes = [mode.strip() for mode in prompt_modes if mode.strip()]
|
| allowed = {"strict", *PROMPT_MODES}
|
| unknown = [mode for mode in modes if mode not in allowed]
|
| if unknown:
|
| raise ValueError(f"Unknown prompt mode(s): {', '.join(unknown)}")
|
| return modes
|
|
|
|
|
| def load_env_file(path: Path) -> dict[str, str]:
|
| values: dict[str, str] = {}
|
| if not path.exists():
|
| return values
|
| for line in path.read_text(encoding="utf-8").splitlines():
|
| stripped = line.strip()
|
| if not stripped or stripped.startswith("#") or "=" not in stripped:
|
| continue
|
| key, value = stripped.split("=", 1)
|
| values[key.strip()] = value.strip().strip('"').strip("'")
|
| return values
|
|
|
|
|
| def stable_hash(text: str) -> str:
|
| return hashlib.sha256(text.encode("utf-8")).hexdigest()
|
|
|
|
|
| def normalize_text(text: str) -> str:
|
| text = text.lower()
|
| text = text.translate(str.maketrans("", "", string.punctuation))
|
| return " ".join(text.split())
|
|
|
|
|
| def load_examples(dataset_json: Path | None, cache_json: Path | None) -> list[dict]:
|
| if dataset_json is not None:
|
| return json.loads(dataset_json.read_text(encoding="utf-8"))
|
| if cache_json is not None and cache_json.exists():
|
| return json.loads(cache_json.read_text(encoding="utf-8"))
|
| with urllib.request.urlopen(DATA_URL) as handle:
|
| examples = json.load(handle)
|
| if cache_json is not None:
|
| cache_json.parent.mkdir(parents=True, exist_ok=True)
|
| cache_json.write_text(json.dumps(examples), encoding="utf-8")
|
| return examples
|
|
|
|
|
| def read_jsonl(path: Path) -> list[dict]:
|
| rows: list[dict] = []
|
| with path.open(encoding="utf-8") as handle:
|
| for line in handle:
|
| stripped = line.strip()
|
| if stripped:
|
| rows.append(json.loads(stripped))
|
| return rows
|
|
|
|
|
| def write_jsonl(path: Path, rows: Iterable[dict]) -> None:
|
| path.parent.mkdir(parents=True, exist_ok=True)
|
| with path.open("w", encoding="utf-8") as handle:
|
| for row in rows:
|
| handle.write(json.dumps(row, sort_keys=True) + "\n")
|
|
|
|
|
| def split_question_rows(source: Path) -> list[dict]:
|
| seen: dict[str, dict] = {}
|
| for row in read_jsonl(source):
|
| question_id = str(row.get("question_id", "")).strip()
|
| if not question_id:
|
| continue
|
| question_type = str(row.get("question_type", "")).strip()
|
| existing = seen.get(question_id)
|
| if existing is not None:
|
| if question_type and existing["question_type"] != question_type:
|
| raise ValueError(f"Conflicting question_type for {question_id}: {existing['question_type']} vs {question_type}")
|
| continue
|
| seen[question_id] = {
|
| "question_id": question_id,
|
| "question_type": question_type,
|
| }
|
| if not seen:
|
| raise ValueError(f"No question_id rows found in {source}")
|
| return sorted(seen.values(), key=lambda row: row["question_id"])
|
|
|
|
|
| def stratified_dev_counts(by_type: dict[str, list[dict]], dev_size: int) -> dict[str, int]:
|
| total = sum(len(rows) for rows in by_type.values())
|
| if dev_size <= 0 or dev_size >= total:
|
| raise ValueError(f"dev_size must be between 1 and {total - 1}; got {dev_size}")
|
| raw_targets = {
|
| question_type: dev_size * len(rows) / total for question_type, rows in by_type.items()
|
| }
|
| counts = {
|
| question_type: min(len(by_type[question_type]), int(raw_targets[question_type]))
|
| for question_type in by_type
|
| }
|
| remainder = dev_size - sum(counts.values())
|
| order = sorted(
|
| by_type,
|
| key=lambda question_type: (
|
| raw_targets[question_type] - int(raw_targets[question_type]),
|
| len(by_type[question_type]),
|
| question_type,
|
| ),
|
| reverse=True,
|
| )
|
| while remainder > 0:
|
| changed = False
|
| for question_type in order:
|
| if counts[question_type] < len(by_type[question_type]):
|
| counts[question_type] += 1
|
| remainder -= 1
|
| changed = True
|
| if remainder == 0:
|
| break
|
| if not changed:
|
| raise ValueError("Could not allocate stratified dev split")
|
| return counts
|
|
|
|
|
| def make_focus_dev_eval_split(source: Path, dev_size: int, out_dir: Path) -> dict:
|
| rows = split_question_rows(source)
|
| by_type: dict[str, list[dict]] = {}
|
| for row in rows:
|
| by_type.setdefault(row["question_type"], []).append(row)
|
| counts = stratified_dev_counts(by_type, dev_size)
|
|
|
| dev_ids: set[str] = set()
|
| for question_type, type_rows in sorted(by_type.items()):
|
| ordered = sorted(
|
| type_rows,
|
| key=lambda row: stable_hash(f"longmemeval-focus-dev-v1:{row['question_id']}"),
|
| )
|
| dev_ids.update(row["question_id"] for row in ordered[: counts[question_type]])
|
|
|
| dev_rows = sorted((row for row in rows if row["question_id"] in dev_ids), key=lambda row: row["question_id"])
|
| eval_rows = sorted((row for row in rows if row["question_id"] not in dev_ids), key=lambda row: row["question_id"])
|
| out_dir.mkdir(parents=True, exist_ok=True)
|
| dev_path = out_dir / f"focus_dev_{len(dev_rows)}.jsonl"
|
| eval_path = out_dir / f"focus_eval_{len(eval_rows)}.jsonl"
|
| write_jsonl(dev_path, dev_rows)
|
| write_jsonl(eval_path, eval_rows)
|
|
|
| summary = {
|
| "source": str(source),
|
| "algorithm": "question_id SHA-256 hash within question_type strata",
|
| "dev_path": str(dev_path),
|
| "eval_path": str(eval_path),
|
| "total_questions": len(rows),
|
| "dev_size": len(dev_rows),
|
| "eval_size": len(eval_rows),
|
| "counts_by_type": {
|
| question_type: {
|
| "total": len(type_rows),
|
| "dev": sum(1 for row in dev_rows if row["question_type"] == question_type),
|
| "eval": sum(1 for row in eval_rows if row["question_type"] == question_type),
|
| }
|
| for question_type, type_rows in sorted(by_type.items())
|
| },
|
| }
|
| (out_dir / "split_summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
|
| return summary
|
|
|
|
|
| def load_split_question_ids(split_path: Path) -> set[str]:
|
| rows = read_jsonl(split_path)
|
| ids = {str(row.get("question_id", "")).strip() for row in rows}
|
| ids.discard("")
|
| if not ids:
|
| raise ValueError(f"No question_id values found in split file {split_path}")
|
| return ids
|
|
|
|
|
| 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:
|
| return session_text(session[-turns:])
|
|
|
|
|
| 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)
|
| return {
|
| "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))),
|
| }
|
|
|
|
|
| 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 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 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"])
|
| )
|
| ]
|
| return take_under_budget(reversed(candidates), 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 normalize_answer(text: str) -> str:
|
| lowered = str(text).lower()
|
| no_punct = lowered.translate(str.maketrans("", "", string.punctuation))
|
| return " ".join(no_punct.split())
|
|
|
|
|
| def normalize_answer_articles(text: str) -> str:
|
| tokens = normalize_answer(text).split()
|
| return " ".join(token for token in tokens if token not in {"a", "an", "the"})
|
|
|
|
|
| def exact_match(prediction: str, gold: str) -> float:
|
| return float(normalize_answer(prediction) == normalize_answer(gold))
|
|
|
|
|
| def article_stripped_exact_match(prediction: str, gold: str) -> float:
|
| return float(normalize_answer_articles(prediction) == normalize_answer_articles(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 is_insufficient_answer(text: str) -> bool:
|
| compact = re.sub(r"[\W_]+", "", str(text).lower())
|
| return compact in {"insufficientevidence", "insufficientinfo", "notenoughinformation"}
|
|
|
|
|
| def summarize_session_for_memorybank(session: list[dict]) -> str:
|
| facts = extract_fact_lines(session)
|
| if facts:
|
| return "\n".join(f"fact: {line}" for line in facts[:4])
|
| return tail_snippet(session, turns=3)
|
|
|
|
|
| def summarize_session_for_ld_long(session: list[dict]) -> str:
|
| facts = extract_fact_lines(session)
|
| if facts:
|
| return "\n".join(f"persona: {line}" for line in facts[:3])
|
| return tail_snippet(session, turns=2)
|
|
|
|
|
| def entries_from_full_raw(example: dict) -> dict[str, ContextEntry]:
|
| return {
|
| session_id: ContextEntry(
|
| session_id=session_id,
|
| action="raw",
|
| text=session_text(session),
|
| source="full_raw_store",
|
| )
|
| for session_id, session in zip(example["haystack_session_ids"], example["haystack_sessions"])
|
| }
|
|
|
|
|
| def entries_from_memory_entries(entries: list[MemoryEntry], source: str) -> dict[str, ContextEntry]:
|
| return {
|
| entry.session_id: ContextEntry(
|
| session_id=entry.session_id,
|
| action=entry.action,
|
| text=entry.text,
|
| source=source,
|
| )
|
| for entry in entries
|
| }
|
|
|
|
|
| def entries_from_memorybank(example: dict) -> dict[str, ContextEntry]:
|
| return {
|
| session_id: ContextEntry(
|
| session_id=session_id,
|
| action="fact_summary",
|
| text=summarize_session_for_memorybank(session),
|
| source="memorybank_proxy",
|
| )
|
| for session_id, session in zip(example["haystack_session_ids"], example["haystack_sessions"])
|
| }
|
|
|
|
|
| def entries_from_ld_agent(example: dict) -> dict[str, ContextEntry]:
|
| total = len(example["haystack_sessions"])
|
| short_cutoff = max(total - 6, 0)
|
| entries = {}
|
| for index, (session_id, session) in enumerate(zip(example["haystack_session_ids"], example["haystack_sessions"])):
|
| if index >= short_cutoff:
|
| action = "short_term_raw"
|
| text = tail_snippet(session, turns=4)
|
| else:
|
| action = "long_term_summary"
|
| text = summarize_session_for_ld_long(session)
|
| entries[session_id] = ContextEntry(
|
| session_id=session_id,
|
| action=action,
|
| text=text,
|
| source="ld_agent_proxy",
|
| )
|
| return entries
|
|
|
|
|
| def method_entry_lookup(example: dict, method: str, budget_frac: float) -> dict[str, ContextEntry]:
|
| if method == "dense_rag_e5":
|
| return entries_from_full_raw(example)
|
| if method == "memorybank_proxy":
|
| return entries_from_memorybank(example)
|
| if method == "ld_agent_proxy":
|
| return entries_from_ld_agent(example)
|
| if method == "fifo_replay":
|
| return entries_from_memory_entries(build_fifo_replay(example, budget_frac), "fifo_replay")
|
| if method == "uniform_replay":
|
| return entries_from_memory_entries(build_uniform_replay(example, budget_frac), "uniform_replay")
|
| if method in {"replay_only_router", "dense_budgeted_replay"}:
|
| return entries_from_memory_entries(build_replay_only_router(example, budget_frac), "budgeted_raw_replay")
|
| if method in {"heuristic_bsc", "dense_budgeted_bsc"}:
|
| return entries_from_memory_entries(build_bsc(example, budget_frac), "oraclemem_writer")
|
| raise KeyError(f"Unknown method: {method}")
|
|
|
|
|
| def reconstruct_context(example: dict, retrieval_row: dict, method: str, budget_frac: float, max_context_words: int) -> tuple[list[ContextEntry], int]:
|
| lookup = method_entry_lookup(example, method, budget_frac)
|
| full_raw = entries_from_full_raw(example)
|
| context: list[ContextEntry] = []
|
| fallback_count = 0
|
| used_words = 0
|
| for session_id in retrieval_row.get("predicted_session_ids", []):
|
| entry = lookup.get(session_id)
|
| if entry is None:
|
| entry = full_raw.get(session_id)
|
| fallback_count += 1
|
| if entry is None:
|
| continue
|
| words = entry.text.split()
|
| clipped = " ".join(words[: min(len(words), 400)])
|
| block_words = count_words(clipped) + 8
|
| if context and used_words + block_words > max_context_words:
|
| break
|
| context.append(ContextEntry(session_id=entry.session_id, action=entry.action, text=clipped, source=entry.source))
|
| used_words += block_words
|
| return context, fallback_count
|
|
|
|
|
| def context_prompt(question: str, context: list[ContextEntry], prompt_style: str = "strict") -> str:
|
| blocks = []
|
| for index, entry in enumerate(context, start=1):
|
| blocks.append(
|
| f"[{index}] memory_id={entry.session_id} action={entry.action} source={entry.source}\n{entry.text}"
|
| )
|
| memory = "\n\n".join(blocks) if blocks else "[no memory]"
|
| if prompt_style == "answer_if_supported":
|
| return (
|
| "You are answering a long-term memory question using only the provided memory context.\n\n"
|
| "Rules:\n"
|
| "1. If the context directly supports an answer, answer it.\n"
|
| "2. If the answer is supported but phrased differently from the question, still answer.\n"
|
| "3. If multiple memories conflict, prefer the most recent/current memory or a memory that explicitly supersedes an older one.\n"
|
| '4. Only output "INSUFFICIENT_EVIDENCE" if no provided memory supports an answer.\n'
|
| "5. Cite the memory ids used.\n\n"
|
| f"Question:\n{question}\n\n"
|
| f"Memory context:\n{memory}\n\n"
|
| "Return exactly this JSON and no extra text:\n"
|
| "{\n"
|
| ' "answer": "...",\n'
|
| ' "abstained": true,\n'
|
| ' "used_memory_ids": ["..."]\n'
|
| "}"
|
| )
|
| if prompt_style == "evidence_extraction_first":
|
| return (
|
| "You are answering a long-term memory question using only the provided memory context.\n\n"
|
| "Rules:\n"
|
| "1. First decide whether any provided memory directly or partially supports an answer.\n"
|
| "2. If at least one memory supports the answer, answer concisely.\n"
|
| '3. Use "INSUFFICIENT_EVIDENCE" only if no memory supports an answer.\n'
|
| "4. Do not require exact wording; paraphrased support is enough.\n"
|
| "5. Prefer the most recent/current memory when memories conflict.\n"
|
| "6. Cite the memory ids used.\n"
|
| "7. Do not reveal chain-of-thought or explanatory reasoning; return only the JSON object.\n\n"
|
| f"Question:\n{question}\n\n"
|
| f"Memory context:\n{memory}\n\n"
|
| "Return exactly this JSON and no extra text:\n"
|
| "{\n"
|
| ' "support_status": "SUPPORTED",\n'
|
| ' "answer": "...",\n'
|
| ' "abstained": false,\n'
|
| ' "used_memory_ids": ["..."]\n'
|
| "}\n"
|
| 'Use support_status "SUPPORTED", "PARTIAL", or "UNSUPPORTED".'
|
| )
|
| if prompt_style == "extractive_answer":
|
| return (
|
| "You are answering a long-term memory question using only the provided memory context.\n\n"
|
| "Rules:\n"
|
| "1. If the memory contains a relevant value, name, date, event, or fact, extract it.\n"
|
| "2. A short answer span or concise paraphrase is preferred over a full sentence.\n"
|
| "3. Do not abstain merely because the answer is phrased differently from the question.\n"
|
| "4. Prefer current facts over historical facts when the question asks about the current state.\n"
|
| '5. Use "INSUFFICIENT_EVIDENCE" only if no provided memory contains a relevant answer.\n'
|
| "6. Cite the memory ids used.\n\n"
|
| f"Question:\n{question}\n\n"
|
| f"Memory context:\n{memory}\n\n"
|
| "Return exactly this JSON and no extra text:\n"
|
| "{\n"
|
| ' "answer": "...",\n'
|
| ' "abstained": false,\n'
|
| ' "used_memory_ids": ["..."]\n'
|
| "}"
|
| )
|
| if prompt_style != "strict":
|
| raise ValueError(f"Unknown prompt style: {prompt_style}")
|
| return (
|
| "You are answering a long-term memory question using only the provided memory context.\n"
|
| "Rules:\n"
|
| "1. Use only the memory context.\n"
|
| "2. If the context does not support the answer, output INSUFFICIENT_EVIDENCE.\n"
|
| "3. Prefer current facts over historical facts.\n"
|
| "4. If a memory says a prior fact was corrected, superseded, invalidated, or deleted, do not answer using the old fact as current truth.\n"
|
| "5. Cite the memory ids you used.\n\n"
|
| f"Question:\n{question}\n\n"
|
| f"Memory context:\n{memory}\n\n"
|
| "Return exactly this JSON and no extra text:\n"
|
| "{\n"
|
| ' "answer": "...",\n'
|
| ' "abstained": true,\n'
|
| ' "used_memory_ids": ["..."]\n'
|
| "}"
|
| )
|
|
|
|
|
| def extractive_presence_reader(example: dict, context: list[ContextEntry]) -> dict:
|
| """A deterministic smoke-test reader, not a substitute for an LLM reader."""
|
| gold = str(example["answer"]).strip()
|
| normalized_gold = normalize_text(gold)
|
| used_ids = []
|
| if normalized_gold:
|
| for entry in context:
|
| if normalized_gold in normalize_text(entry.text):
|
| used_ids.append(entry.session_id)
|
| if used_ids:
|
| return {
|
| "answer": gold,
|
| "abstained": False,
|
| "used_memory_ids": used_ids,
|
| "parse_failure": False,
|
| }
|
| return {
|
| "answer": "INSUFFICIENT_EVIDENCE",
|
| "abstained": True,
|
| "used_memory_ids": [],
|
| "parse_failure": False,
|
| }
|
|
|
|
|
| def parse_reader_json(text: str | None) -> dict:
|
| raw_text = "" if text is None else str(text)
|
| raw = raw_text.strip()
|
| if raw.startswith("```"):
|
| raw = re.sub(r"^```(?:json)?", "", raw).strip()
|
| raw = re.sub(r"```$", "", raw).strip()
|
| match = re.search(r"\{.*\}", raw, flags=re.DOTALL)
|
| candidate = match.group(0) if match else raw
|
| try:
|
| parsed = json.loads(candidate)
|
| except json.JSONDecodeError:
|
| return {
|
| "answer": raw.splitlines()[0].strip() if raw else "",
|
| "abstained": False,
|
| "used_memory_ids": [],
|
| "support_status": None,
|
| "parse_failure": True,
|
| "raw_response": raw_text,
|
| }
|
| answer = str(parsed.get("answer", "")).strip()
|
| abstained = bool(parsed.get("abstained", is_insufficient_answer(answer)))
|
| used = parsed.get("used_memory_ids", [])
|
| if not isinstance(used, list):
|
| used = []
|
| support_status = parsed.get("support_status")
|
| if support_status is not None:
|
| support_status = str(support_status).strip().upper()
|
| return {
|
| "answer": answer,
|
| "abstained": abstained or is_insufficient_answer(answer),
|
| "used_memory_ids": [str(item) for item in used],
|
| "support_status": support_status,
|
| "parse_failure": False,
|
| "raw_response": raw_text,
|
| }
|
|
|
|
|
| def normalize_used_memory_ids(raw_ids: Iterable[str], context: list[ContextEntry]) -> list[str]:
|
| normalized: list[str] = []
|
| context_ids = [entry.session_id for entry in context]
|
| context_id_set = set(context_ids)
|
| context_lower = {session_id.lower(): session_id for session_id in context_ids}
|
| for raw_id in raw_ids:
|
| value = str(raw_id).strip()
|
| cleaned = value.strip("[]# '\"")
|
| if cleaned.isdigit():
|
| index = int(cleaned) - 1
|
| if 0 <= index < len(context):
|
| normalized.append(context[index].session_id)
|
| continue
|
| if cleaned in context_id_set:
|
| normalized.append(cleaned)
|
| continue
|
| lowered = cleaned.lower()
|
| if lowered in context_lower:
|
| normalized.append(context_lower[lowered])
|
| continue
|
|
|
|
|
|
|
|
|
| compact = re.sub(r"^(memory_id|memory|id)\s*[:=#-]?\s*", "", lowered).strip()
|
| if len(compact) >= 4:
|
| matches = [
|
| session_id
|
| for session_id in context_ids
|
| if session_id.lower().endswith(compact) or compact in session_id.lower()
|
| ]
|
| if len(matches) == 1:
|
| normalized.append(matches[0])
|
| continue
|
| normalized.append(value)
|
|
|
| deduped: list[str] = []
|
| seen: set[str] = set()
|
| for memory_id in normalized:
|
| if memory_id not in seen:
|
| deduped.append(memory_id)
|
| seen.add(memory_id)
|
| return deduped
|
|
|
|
|
| class OpenRouterReader:
|
| def __init__(
|
| self,
|
| api_key: str,
|
| model: str,
|
| cache_path: Path,
|
| *,
|
| max_tokens: int = 160,
|
| temperature: float = 0.0,
|
| request_sleep: float = 0.0,
|
| timeout: int = 90,
|
| reasoning_effort: str | None = None,
|
| verbosity: str | None = None,
|
| ) -> None:
|
| self.api_key = api_key
|
| self.model = model
|
| self.cache_path = cache_path
|
| self.max_tokens = max_tokens
|
| self.temperature = temperature
|
| self.request_sleep = request_sleep
|
| self.timeout = timeout
|
| self.reasoning_effort = reasoning_effort
|
| self.verbosity = verbosity
|
| self.cache: dict[str, dict] = {}
|
| if cache_path.exists():
|
| self.cache = json.loads(cache_path.read_text(encoding="utf-8"))
|
|
|
| def _write_cache(self) -> None:
|
| self.cache_path.parent.mkdir(parents=True, exist_ok=True)
|
| self.cache_path.write_text(json.dumps(self.cache, indent=2), encoding="utf-8")
|
|
|
| def __call__(self, prompt: str) -> dict:
|
| cache_settings = {
|
| "model": self.model,
|
| "temperature": self.temperature,
|
| "max_tokens": self.max_tokens,
|
| "reasoning_effort": self.reasoning_effort,
|
| "verbosity": self.verbosity,
|
| }
|
| prompt_hash = stable_hash(f"{json.dumps(cache_settings, sort_keys=True)}\n{prompt}")
|
| if prompt_hash in self.cache:
|
| cached = dict(self.cache[prompt_hash])
|
| cached["cache_hit"] = True
|
| cached["prompt_hash"] = prompt_hash
|
| return cached
|
| payload = {
|
| "model": self.model,
|
| "messages": [
|
| {
|
| "role": "user",
|
| "content": prompt,
|
| }
|
| ],
|
| "temperature": self.temperature,
|
| "max_tokens": self.max_tokens,
|
| "max_completion_tokens": self.max_tokens,
|
| "response_format": {"type": "json_object"},
|
| }
|
| if self.reasoning_effort:
|
| payload["reasoning"] = {"effort": self.reasoning_effort, "exclude": True}
|
| if self.verbosity:
|
| payload["verbosity"] = self.verbosity
|
| request = urllib.request.Request(
|
| "https://openrouter.ai/api/v1/chat/completions",
|
| data=json.dumps(payload).encode("utf-8"),
|
| headers={
|
| "Authorization": f"Bearer {self.api_key}",
|
| "Content-Type": "application/json",
|
| "HTTP-Referer": "https://localhost/oraclemem",
|
| "X-Title": "OracleMem LongMemEval Reader",
|
| },
|
| method="POST",
|
| )
|
| try:
|
| with urllib.request.urlopen(request, timeout=self.timeout) as response:
|
| body = json.loads(response.read().decode("utf-8"))
|
| except urllib.error.HTTPError as error:
|
| details = error.read().decode("utf-8", errors="replace")
|
| raise RuntimeError(f"OpenRouter HTTP {error.code}: {details}") from error
|
| content = body["choices"][0]["message"].get("content")
|
| parsed = parse_reader_json(content)
|
| parsed.update(
|
| {
|
| "cache_hit": False,
|
| "prompt_hash": prompt_hash,
|
| "model": self.model,
|
| "usage": body.get("usage", {}),
|
| "provider": body.get("provider"),
|
| }
|
| )
|
| self.cache[prompt_hash] = parsed
|
| self._write_cache()
|
| if self.request_sleep > 0:
|
| time.sleep(self.request_sleep)
|
| return parsed
|
|
|
|
|
| def score_predictions(rows: list[dict]) -> dict:
|
| if not rows:
|
| return {
|
| "n": 0,
|
| "exact_match": 0.0,
|
| "token_f1": 0.0,
|
| "evidence_use": 0.0,
|
| "insufficient_evidence_rate": 0.0,
|
| "unsupported_answer_rate": 0.0,
|
| "parse_failure_rate": 0.0,
|
| "avg_context_words": 0.0,
|
| "avg_context_tokens_est": 0.0,
|
| "avg_fallback_contexts": 0.0,
|
| "cache_hit_rate": 0.0,
|
| "total_api_cost": 0.0,
|
| "avg_prompt_tokens": 0.0,
|
| "avg_completion_tokens": 0.0,
|
| }
|
| prompt_tokens = [float(row.get("usage", {}).get("prompt_tokens", 0.0) or 0.0) for row in rows]
|
| completion_tokens = [float(row.get("usage", {}).get("completion_tokens", 0.0) or 0.0) for row in rows]
|
| costs = [float(row.get("usage", {}).get("cost", 0.0) or 0.0) for row in rows]
|
| return {
|
| "n": len(rows),
|
| "exact_match": sum(row["exact_match"] for row in rows) / len(rows),
|
| "token_f1": sum(row["token_f1"] for row in rows) / len(rows),
|
| "evidence_use": sum(row["evidence_use"] for row in rows) / len(rows),
|
| "insufficient_evidence_rate": sum(row["abstained"] for row in rows) / len(rows),
|
| "unsupported_answer_rate": sum(row["unsupported_answer"] for row in rows) / len(rows),
|
| "parse_failure_rate": sum(row["parse_failure"] for row in rows) / len(rows),
|
| "avg_context_words": sum(row["context_words"] for row in rows) / len(rows),
|
| "avg_context_tokens_est": sum(row["context_tokens_est"] for row in rows) / len(rows),
|
| "avg_fallback_contexts": sum(row["fallback_contexts"] for row in rows) / len(rows),
|
| "cache_hit_rate": sum(row.get("cache_hit", False) for row in rows) / len(rows),
|
| "total_api_cost": sum(costs),
|
| "avg_prompt_tokens": sum(prompt_tokens) / len(prompt_tokens),
|
| "avg_completion_tokens": sum(completion_tokens) / len(completion_tokens),
|
| }
|
|
|
|
|
| def retrieval_stats(rows: list[dict]) -> dict:
|
| if not rows:
|
| return {
|
| "n": 0,
|
| "any_gold_retrieved": 0.0,
|
| "gold_recall": 0.0,
|
| "retrieved_count": 0,
|
| }
|
| any_hits = []
|
| recalls = []
|
| retrieved_count = 0
|
| for row in rows:
|
| gold = set(row.get("gold_session_ids", []))
|
| context = set(row.get("context_session_ids", []))
|
| hit_count = len(gold & context)
|
| any_hit = bool(hit_count)
|
| any_hits.append(float(any_hit))
|
| if any_hit:
|
| retrieved_count += 1
|
| recalls.append(hit_count / max(len(gold), 1))
|
| return {
|
| "n": len(rows),
|
| "any_gold_retrieved": sum(any_hits) / len(any_hits),
|
| "gold_recall": sum(recalls) / len(recalls),
|
| "retrieved_count": retrieved_count,
|
| }
|
|
|
|
|
| def score_conditioned_on_retrieved(rows: list[dict]) -> dict:
|
| retrieved_rows = [
|
| row for row in rows if set(row.get("gold_session_ids", [])) & set(row.get("context_session_ids", []))
|
| ]
|
| result = score_predictions(retrieved_rows)
|
| result.update(retrieval_stats(rows))
|
| return result
|
|
|
|
|
| def paired_bootstrap_delta(rows_a: list[dict], rows_b: list[dict], metric: str, *, n_bootstrap: int, seed: int) -> dict:
|
| by_a = {row["question_id"]: row for row in rows_a}
|
| by_b = {row["question_id"]: row for row in rows_b}
|
| ids = sorted(set(by_a) & set(by_b))
|
| if not ids:
|
| return {"n": 0, "mean_delta": 0.0, "ci95": [0.0, 0.0]}
|
| diffs = [float(by_a[item][metric]) - float(by_b[item][metric]) for item in ids]
|
| mean_delta = sum(diffs) / len(diffs)
|
| rng = random.Random(seed)
|
| if len(diffs) == 1 or n_bootstrap <= 0:
|
| return {"n": len(diffs), "mean_delta": mean_delta, "ci95": [mean_delta, mean_delta]}
|
| means = []
|
| for _ in range(n_bootstrap):
|
| sample = [diffs[rng.randrange(len(diffs))] for _ in diffs]
|
| means.append(sum(sample) / len(sample))
|
| means.sort()
|
| return {
|
| "n": len(diffs),
|
| "mean_delta": mean_delta,
|
| "ci95": [
|
| means[int(0.025 * (len(means) - 1))],
|
| means[int(0.975 * (len(means) - 1))],
|
| ],
|
| }
|
|
|
|
|
| def filter_examples(examples: list[dict], focus_types: set[str], *, focus_only: bool, per_type_limit: int, seed: int) -> list[dict]:
|
| pool = [example for example in examples if (not focus_only or example["question_type"] in focus_types)]
|
| if per_type_limit <= 0:
|
| return pool
|
| rng = random.Random(seed)
|
| by_type: dict[str, list[dict]] = {}
|
| for example in pool:
|
| by_type.setdefault(example["question_type"], []).append(example)
|
| selected: list[dict] = []
|
| for question_type in sorted(by_type):
|
| rows = list(by_type[question_type])
|
| rng.shuffle(rows)
|
| selected.extend(rows[:per_type_limit])
|
| selected.sort(key=lambda item: item["question_id"])
|
| return selected
|
|
|
|
|
| def evaluate(
|
| examples: list[dict],
|
| retrieval_rows: dict[str, list[dict]],
|
| methods: list[str],
|
| focus_types: set[str],
|
| budget_frac: float,
|
| max_context_words: int,
|
| save_prompts: bool,
|
| reader_name: str,
|
| openrouter_reader: OpenRouterReader | None,
|
| shuffle_jobs: bool,
|
| seed: int,
|
| bootstrap: int,
|
| prompt_style: str,
|
| ) -> tuple[dict, dict]:
|
| examples_by_id = {example["question_id"]: example for example in examples}
|
| allowed_ids = set(examples_by_id)
|
| method_rows_by_id: dict[str, dict[str, dict]] = {}
|
| for method in methods:
|
| method_rows = retrieval_rows.get(method)
|
| if method_rows is None:
|
| raise KeyError(f"Method not found in retrieval rows: {method}")
|
| method_rows_by_id[method] = {
|
| row["question_id"]: row for row in method_rows if row["question_id"] in allowed_ids
|
| }
|
|
|
| jobs = [
|
| (method, question_id)
|
| for method in methods
|
| for question_id in sorted(method_rows_by_id[method])
|
| ]
|
| if shuffle_jobs:
|
| random.Random(seed).shuffle(jobs)
|
|
|
| artifacts: dict[str, list[dict]] = {method: [] for method in methods}
|
| for method, question_id in jobs:
|
| example = examples_by_id[question_id]
|
| retrieval_row = method_rows_by_id[method][question_id]
|
| context, fallback_count = reconstruct_context(
|
| example=example,
|
| retrieval_row=retrieval_row,
|
| method=method,
|
| budget_frac=budget_frac,
|
| max_context_words=max_context_words,
|
| )
|
| prompt = context_prompt(example["question"], context, prompt_style=prompt_style)
|
| if reader_name == "extractive_presence_smoke":
|
| reader_output = extractive_presence_reader(example, context)
|
| elif reader_name == "openrouter":
|
| if openrouter_reader is None:
|
| raise ValueError("openrouter_reader is required for reader=openrouter")
|
| reader_output = openrouter_reader(prompt)
|
| else:
|
| raise ValueError(f"Unknown reader: {reader_name}")
|
| prediction = reader_output["answer"]
|
| gold = example["answer"]
|
| gold_ids = set(example.get("answer_session_ids", []))
|
| used_ids = set(normalize_used_memory_ids(reader_output.get("used_memory_ids", []), context))
|
| evidence_use = float(bool(used_ids & gold_ids))
|
| context_words = sum(count_words(entry.text) for entry in context)
|
| row = {
|
| "question_id": question_id,
|
| "question_type": example["question_type"],
|
| "method": method,
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "gold_answer": gold,
|
| "prediction": prediction,
|
| "abstained": bool(reader_output["abstained"]),
|
| "used_memory_ids": sorted(used_ids),
|
| "gold_session_ids": sorted(gold_ids),
|
| "exact_match": exact_match(prediction, gold),
|
| "token_f1": token_f1(prediction, gold),
|
| "evidence_use": evidence_use,
|
| "unsupported_answer": float((not bool(reader_output["abstained"])) and evidence_use == 0.0),
|
| "parse_failure": bool(reader_output["parse_failure"]),
|
| "context_session_ids": [entry.session_id for entry in context],
|
| "context_words": context_words,
|
| "context_tokens_est": int(round(context_words * 1.33)),
|
| "fallback_contexts": fallback_count,
|
| "prompt_hash": stable_hash(prompt),
|
| "cache_hit": bool(reader_output.get("cache_hit", False)),
|
| "reader_model": reader_output.get("model"),
|
| "support_status": reader_output.get("support_status"),
|
| "usage": reader_output.get("usage", {}),
|
| }
|
| if save_prompts:
|
| row["prompt"] = prompt
|
| artifacts[method].append(row)
|
|
|
| summary: dict[str, dict] = {}
|
| for method in methods:
|
| predictions = sorted(artifacts[method], key=lambda row: row["question_id"])
|
| focus_rows = [row for row in predictions if row["question_type"] in focus_types]
|
| by_type = {}
|
| for question_type in sorted({row["question_type"] for row in predictions}):
|
| by_type[question_type] = score_predictions(
|
| [row for row in predictions if row["question_type"] == question_type]
|
| )
|
| summary[method] = {
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "reader": reader_name,
|
| "scope": "API reader" if reader_name == "openrouter" else "deterministic smoke; not an LLM reader",
|
| "overall": score_predictions(predictions),
|
| "focus": score_predictions(focus_rows),
|
| "per_type": by_type,
|
| }
|
| if "dense_budgeted_bsc" in artifacts:
|
| oracle_focus = [row for row in artifacts["dense_budgeted_bsc"] if row["question_type"] in focus_types]
|
| deltas = {}
|
| for baseline in methods:
|
| if baseline == "dense_budgeted_bsc":
|
| continue
|
| baseline_focus = [row for row in artifacts[baseline] if row["question_type"] in focus_types]
|
| deltas[baseline] = {
|
| "baseline_label": METHOD_LABELS.get(baseline, baseline),
|
| "exact_match": paired_bootstrap_delta(oracle_focus, baseline_focus, "exact_match", n_bootstrap=bootstrap, seed=seed),
|
| "token_f1": paired_bootstrap_delta(oracle_focus, baseline_focus, "token_f1", n_bootstrap=bootstrap, seed=seed + 1),
|
| "evidence_use": paired_bootstrap_delta(oracle_focus, baseline_focus, "evidence_use", n_bootstrap=bootstrap, seed=seed + 2),
|
| }
|
| summary["_paired_focus_deltas_vs_oraclemem_dense"] = deltas
|
| return summary, artifacts
|
|
|
|
|
| def load_reader_outputs(run_dir: Path) -> list[dict]:
|
| path = run_dir / "reader_outputs.jsonl"
|
| if not path.exists():
|
| predictions = run_dir / "predictions.json"
|
| if not predictions.exists():
|
| raise FileNotFoundError(f"Expected {path} or {predictions}")
|
| artifacts = json.loads(predictions.read_text(encoding="utf-8"))
|
| rows = []
|
| for method_rows in artifacts.values():
|
| rows.extend(method_rows)
|
| return rows
|
| rows = []
|
| with path.open(encoding="utf-8") as handle:
|
| for line in handle:
|
| stripped = line.strip()
|
| if stripped:
|
| rows.append(json.loads(stripped))
|
| return rows
|
|
|
|
|
| def bucket_reader_errors(rows: list[dict]) -> dict[str, list[dict]]:
|
| buckets = {
|
| "retrieval_hit_but_abstained": [],
|
| "insufficient_despite_support": [],
|
| "evidence_used_but_wrong_answer": [],
|
| "high_f1_em_zero": [],
|
| "full_raw_retrieved_but_abstained": [],
|
| "oraclemem_missing_evidence": [],
|
| "unsupported_answer": [],
|
| "schema_conflict_answer_and_abstained": [],
|
| "abstain_with_gold_citation": [],
|
| }
|
| for row in rows:
|
| gold = set(row.get("gold_session_ids", []))
|
| context = set(row.get("context_session_ids", []))
|
| retrieved = bool(gold & context)
|
| answer_text = normalize_text(str(row.get("prediction", "")))
|
| answer_looks_substantive = bool(answer_text) and not is_insufficient_answer(row.get("prediction", ""))
|
| if retrieved and row.get("abstained"):
|
| buckets["retrieval_hit_but_abstained"].append(row)
|
| buckets["insufficient_despite_support"].append(row)
|
| if (
|
| row.get("evidence_use", 0.0) > 0.0
|
| and row.get("exact_match", 0.0) < 1.0
|
| and not row.get("abstained")
|
| ):
|
| buckets["evidence_used_but_wrong_answer"].append(row)
|
| if (
|
| row.get("exact_match", 0.0) == 0.0
|
| and row.get("token_f1", 0.0) >= 0.5
|
| and not row.get("abstained")
|
| ):
|
| buckets["high_f1_em_zero"].append(row)
|
| if row.get("method") == "dense_rag_e5" and retrieved and row.get("abstained"):
|
| buckets["full_raw_retrieved_but_abstained"].append(row)
|
| if row.get("method") == "dense_budgeted_bsc" and not retrieved:
|
| buckets["oraclemem_missing_evidence"].append(row)
|
| if row.get("unsupported_answer", 0.0) > 0.0:
|
| buckets["unsupported_answer"].append(row)
|
| if row.get("abstained") and answer_looks_substantive:
|
| buckets["schema_conflict_answer_and_abstained"].append(row)
|
| if row.get("abstained") and row.get("evidence_use", 0.0) > 0.0:
|
| buckets["abstain_with_gold_citation"].append(row)
|
| return buckets
|
|
|
|
|
| def compact_error_row(row: dict, max_text: int = 160) -> dict:
|
| prediction = str(row.get("prediction", ""))
|
| gold = str(row.get("gold_answer", ""))
|
| return {
|
| "question_id": row.get("question_id"),
|
| "question_type": row.get("question_type"),
|
| "method": row.get("method"),
|
| "method_label": row.get("method_label"),
|
| "gold_answer": gold[:max_text],
|
| "prediction": prediction[:max_text],
|
| "abstained": row.get("abstained"),
|
| "exact_match": row.get("exact_match"),
|
| "token_f1": row.get("token_f1"),
|
| "evidence_use": row.get("evidence_use"),
|
| "gold_session_ids": row.get("gold_session_ids", []),
|
| "context_session_ids": row.get("context_session_ids", []),
|
| "used_memory_ids": row.get("used_memory_ids", []),
|
| "prompt_hash": row.get("prompt_hash"),
|
| }
|
|
|
|
|
| def derive_audit_row(row: dict) -> dict:
|
| gold = set(row.get("gold_session_ids", []))
|
| context = set(row.get("context_session_ids", []))
|
| support_in_context = bool(gold & context)
|
| answer_looks_substantive = bool(normalize_answer(row.get("prediction", ""))) and not is_insufficient_answer(
|
| row.get("prediction", "")
|
| )
|
| return {
|
| **compact_error_row(row, max_text=240),
|
| "retrieved_at_5": support_in_context,
|
| "support_in_context": support_in_context,
|
| "gold_recall_in_context": len(gold & context) / max(len(gold), 1),
|
| "retrieval_hit_but_abstained": bool(support_in_context and row.get("abstained")),
|
| "insufficient_despite_support": bool(support_in_context and row.get("abstained")),
|
| "evidence_used_but_wrong_answer": bool(
|
| row.get("evidence_use", 0.0) > 0.0
|
| and row.get("exact_match", 0.0) < 1.0
|
| and not row.get("abstained")
|
| ),
|
| "high_f1_em_zero": bool(
|
| row.get("exact_match", 0.0) == 0.0 and row.get("token_f1", 0.0) >= 0.5 and not row.get("abstained")
|
| ),
|
| "oraclemem_missing_evidence": bool(row.get("method") == "dense_budgeted_bsc" and not support_in_context),
|
| "unsupported_answer": bool(row.get("unsupported_answer", 0.0) > 0.0),
|
| "abstain_answer_conflict": bool(row.get("abstained") and answer_looks_substantive),
|
| "abstain_with_gold_citation": bool(row.get("abstained") and row.get("evidence_use", 0.0) > 0.0),
|
| "article_stripped_exact_match": article_stripped_exact_match(row.get("prediction", ""), row.get("gold_answer", "")),
|
| }
|
|
|
|
|
| def method_bucket_summary(rows: list[dict], bucket_names: list[str]) -> dict:
|
| by_method: dict[str, list[dict]] = {}
|
| for row in rows:
|
| by_method.setdefault(row["method"], []).append(row)
|
| summary = {}
|
| for method, method_rows in sorted(by_method.items()):
|
| method_summary = {
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "n": len(method_rows),
|
| "buckets": {},
|
| }
|
| for bucket in bucket_names:
|
| count = sum(1 for row in method_rows if row.get(bucket))
|
| method_summary["buckets"][bucket] = {
|
| "count": count,
|
| "rate": count / max(len(method_rows), 1),
|
| }
|
| summary[method] = method_summary
|
| return summary
|
|
|
|
|
| def normalized_scoring_summary(rows: list[dict], focus_types: set[str]) -> dict:
|
| by_method: dict[str, list[dict]] = {}
|
| for row in rows:
|
| by_method.setdefault(row["method"], []).append(row)
|
| summary = {}
|
| for method, method_rows in sorted(by_method.items()):
|
| focus_rows = [row for row in method_rows if row.get("question_type") in focus_types]
|
| for row in method_rows:
|
| row["article_stripped_exact_match"] = article_stripped_exact_match(
|
| row.get("prediction", ""), row.get("gold_answer", "")
|
| )
|
| summary[method] = {
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "overall_article_stripped_em": sum(row["article_stripped_exact_match"] for row in method_rows)
|
| / max(len(method_rows), 1),
|
| "focus_article_stripped_em": sum(row["article_stripped_exact_match"] for row in focus_rows)
|
| / max(len(focus_rows), 1),
|
| "overall_script_em": sum(row.get("exact_match", 0.0) for row in method_rows) / max(len(method_rows), 1),
|
| "focus_script_em": sum(row.get("exact_match", 0.0) for row in focus_rows) / max(len(focus_rows), 1),
|
| }
|
| return {
|
| "definition": "article_stripped_em lowercases, strips punctuation/articles, and collapses whitespace.",
|
| "metrics": summary,
|
| }
|
|
|
|
|
| def analyze_error_run(run_dir: Path, *, focus_types: set[str], top_n: int = 50) -> dict:
|
| rows = load_reader_outputs(run_dir)
|
| derived_rows = [derive_audit_row(row) for row in rows]
|
| rows_by_method: dict[str, list[dict]] = {}
|
| for row in rows:
|
| rows_by_method.setdefault(row["method"], []).append(row)
|
|
|
| conditional = {}
|
| for method, method_rows in sorted(rows_by_method.items()):
|
| focus_rows = [row for row in method_rows if row.get("question_type") in focus_types]
|
| conditional[method] = {
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "overall": score_conditioned_on_retrieved(method_rows),
|
| "focus": score_conditioned_on_retrieved(focus_rows),
|
| }
|
|
|
| buckets = bucket_reader_errors(rows)
|
| bucket_names = list(buckets)
|
| bucket_summary = {
|
| name: {
|
| "count": len(bucket_rows),
|
| "examples": [
|
| compact_error_row(row)
|
| for row in sorted(
|
| bucket_rows,
|
| key=lambda item: (
|
| item.get("method", ""),
|
| item.get("question_type", ""),
|
| item.get("token_f1", 0.0),
|
| ),
|
| reverse=True,
|
| )[:top_n]
|
| ],
|
| }
|
| for name, bucket_rows in buckets.items()
|
| }
|
| audit = {
|
| "run_dir": str(run_dir),
|
| "n_rows": len(rows),
|
| "focus_types": sorted(focus_types),
|
| "conditional_reader_analysis": conditional,
|
| "error_buckets": bucket_summary,
|
| "per_method_error_buckets": method_bucket_summary(derived_rows, bucket_names),
|
| "normalized_scoring": normalized_scoring_summary(rows, focus_types),
|
| "notes": [
|
| "retrieved means at least one gold answer-session id appears in the frozen context ids.",
|
| "Evidence use means the reader cited at least one gold answer-session id.",
|
| "high_f1_em_zero is a heuristic proxy for semantically plausible but exact-match-zero cases; it is not an LLM judge.",
|
| ],
|
| }
|
| (run_dir / "error_audit.json").write_text(json.dumps(audit, indent=2), encoding="utf-8")
|
| (run_dir / "error_audit_summary.json").write_text(json.dumps(audit, indent=2), encoding="utf-8")
|
| with (run_dir / "error_audit_rows.jsonl").open("w", encoding="utf-8") as handle:
|
| for row in derived_rows:
|
| handle.write(json.dumps(row) + "\n")
|
| with (run_dir / "failure_examples.jsonl").open("w", encoding="utf-8") as handle:
|
| for bucket, bucket_rows in buckets.items():
|
| for row in bucket_rows[:top_n]:
|
| handle.write(json.dumps({"bucket": bucket, **compact_error_row(row, max_text=240)}) + "\n")
|
| semantic_candidates = [
|
| row
|
| for row in derived_rows
|
| if row["high_f1_em_zero"] or (row["evidence_used_but_wrong_answer"] and row.get("token_f1", 0.0) >= 0.25)
|
| ]
|
| with (run_dir / "semantic_audit_sample_50.jsonl").open("w", encoding="utf-8") as handle:
|
| for row in semantic_candidates[:50]:
|
| handle.write(json.dumps(row) + "\n")
|
| (run_dir / "normalized_scoring.json").write_text(json.dumps(audit["normalized_scoring"], indent=2), encoding="utf-8")
|
| write_error_audit_report(run_dir, audit)
|
| return audit
|
|
|
|
|
| def write_error_audit_report(run_dir: Path, audit: dict) -> None:
|
| lines = [
|
| "# Reader Error Audit",
|
| "",
|
| f"- Run directory: `{audit['run_dir']}`",
|
| f"- Rows audited: `{audit['n_rows']}`",
|
| "- Retrieved evidence is defined as at least one gold answer-session id appearing in the frozen context ids.",
|
| "",
|
| "## Conditional Reader Analysis",
|
| "",
|
| "| Method | Any gold retrieved | Gold recall | EM given retrieved | F1 given retrieved | Abstain given retrieved | Evidence use given retrieved | n retrieved |",
|
| "|---|---:|---:|---:|---:|---:|---:|---:|",
|
| ]
|
| for method, row in audit["conditional_reader_analysis"].items():
|
| focus = row["focus"]
|
| lines.append(
|
| f"| {row['method_label']} | {focus['any_gold_retrieved']:.4f} | "
|
| f"{focus['gold_recall']:.4f} | {focus['exact_match']:.4f} | "
|
| f"{focus['token_f1']:.4f} | {focus['insufficient_evidence_rate']:.4f} | "
|
| f"{focus['evidence_use']:.4f} | {focus['retrieved_count']} |"
|
| )
|
| lines.extend(["", "## Error Buckets", "", "| Bucket | Count |", "|---|---:|"])
|
| for name, row in audit["error_buckets"].items():
|
| lines.append(f"| `{name}` | {row['count']} |")
|
| lines.extend(
|
| [
|
| "",
|
| "## Per-Method Error Rates",
|
| "",
|
| "| Method | Insufficient despite support | Evidence used but wrong | Unsupported answer | Abstain-answer conflict |",
|
| "|---|---:|---:|---:|---:|",
|
| ]
|
| )
|
| for _method, row in audit["per_method_error_buckets"].items():
|
| buckets = row["buckets"]
|
| lines.append(
|
| f"| {row['method_label']} | "
|
| f"{buckets['insufficient_despite_support']['rate']:.4f} | "
|
| f"{buckets['evidence_used_but_wrong_answer']['rate']:.4f} | "
|
| f"{buckets['unsupported_answer']['rate']:.4f} | "
|
| f"{buckets['schema_conflict_answer_and_abstained']['rate']:.4f} |"
|
| )
|
| lines.extend(
|
| [
|
| "",
|
| "## Secondary Scoring Check",
|
| "",
|
| "| Method | Script EM | Article-stripped EM |",
|
| "|---|---:|---:|",
|
| ]
|
| )
|
| for _method, row in audit["normalized_scoring"]["metrics"].items():
|
| lines.append(
|
| f"| {row['method_label']} | {row['focus_script_em']:.4f} | {row['focus_article_stripped_em']:.4f} |"
|
| )
|
| lines.extend(
|
| [
|
| "",
|
| "## Interpretation Notes",
|
| "",
|
| "- `retrieval_hit_but_abstained` is the main over-conservative-reader bucket.",
|
| "- `high_f1_em_zero` is a heuristic exact-match harshness bucket; use a blinded judge before reporting it as semantic correctness.",
|
| "- `oraclemem_missing_evidence` is the write/retrieval failure bucket for the OracleMem dense method.",
|
| "",
|
| "Detailed examples are in `error_audit_summary.json`, `error_audit_rows.jsonl`, `failure_examples.jsonl`, and `semantic_audit_sample_50.jsonl`.",
|
| ]
|
| )
|
| (run_dir / "ERROR_AUDIT.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
|
|
|
| def write_report(output_dir: Path, summary: dict, methods: list[str], reader_name: str, reader_model: str | None) -> None:
|
| is_api = reader_name == "openrouter"
|
| lines = [
|
| "# LongMemEval-S Frozen-Context Reader Evaluation",
|
| "",
|
| f"- Reader: `{reader_name}`" + (f" / `{reader_model}`." if reader_model else "."),
|
| "- Scope: API reader evaluation on frozen contexts." if is_api else "- Scope: deterministic reporting-path validation, not a replacement for an API or local LLM reader.",
|
| "- Contexts: reconstructed from frozen top-5 retrieval ids without re-retrieval.",
|
| "- Metrics: exact match and token F1 against LongMemEval-S answers; evidence-use checks whether cited memory ids overlap gold answer-session ids.",
|
| "",
|
| "## Focus Reader Results",
|
| "",
|
| "| Method | Overall EM | Focus EM | Focus F1 | Evidence use | Unsupported answer | Insufficient rate | Parse fail | Avg context words | Cost |",
|
| "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
|
| ]
|
| for method in methods:
|
| row = summary[method]
|
| focus = row["focus"]
|
| overall = row["overall"]
|
| lines.append(
|
| f"| {row['method_label']} | {overall['exact_match']:.4f} | {focus['exact_match']:.4f} | "
|
| f"{focus['token_f1']:.4f} | {focus['evidence_use']:.4f} | "
|
| f"{focus['unsupported_answer_rate']:.4f} | {focus['insufficient_evidence_rate']:.4f} | "
|
| f"{focus['parse_failure_rate']:.4f} | {focus['avg_context_words']:.1f} | "
|
| f"${focus['total_api_cost']:.4f} |"
|
| )
|
| deltas = summary.get("_paired_focus_deltas_vs_oraclemem_dense", {})
|
| if deltas:
|
| lines.extend(
|
| [
|
| "",
|
| "## Paired Focus Deltas",
|
| "",
|
| "| Baseline | EM delta | EM 95% CI | F1 delta | F1 95% CI | Evidence-use delta | Evidence-use 95% CI |",
|
| "|---|---:|---:|---:|---:|---:|---:|",
|
| ]
|
| )
|
| for baseline, row in deltas.items():
|
| em = row["exact_match"]
|
| f1 = row["token_f1"]
|
| ev = row["evidence_use"]
|
| lo, hi = em["ci95"]
|
| f1_lo, f1_hi = f1["ci95"]
|
| ev_lo, ev_hi = ev["ci95"]
|
| lines.append(
|
| f"| OracleMem writer + dense minus {row['baseline_label']} | {em['mean_delta']:+.4f} | "
|
| f"[{lo:+.4f}, {hi:+.4f}] | {f1['mean_delta']:+.4f} | "
|
| f"[{f1_lo:+.4f}, {f1_hi:+.4f}] | {ev['mean_delta']:+.4f} | "
|
| f"[{ev_lo:+.4f}, {ev_hi:+.4f}] |"
|
| )
|
| lines.extend(
|
| [
|
| "",
|
| "## Interpretation",
|
| "",
|
| "- Method names are hidden from the reader prompt; the prompt contains only the question and memory context.",
|
| "- `INSUFFICIENT_EVIDENCE` is reported as an insufficient-evidence output rate, not as abstention accuracy.",
|
| "- Old-answer/stale-answer rates require identifiable superseded-answer labels and are not reported here.",
|
| ]
|
| )
|
| if not is_api:
|
| lines.append("- This deterministic smoke reader is pipeline validation only, not a submission-grade LLM reader result.")
|
| output_dir.mkdir(parents=True, exist_ok=True)
|
| (output_dir / "REPORT.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
|
|
|
| def write_evaluation_outputs(
|
| output_dir: Path,
|
| output: dict,
|
| artifacts: dict,
|
| methods: list[str],
|
| reader_name: str,
|
| reader_model: str | None,
|
| ) -> None:
|
| output_dir.mkdir(parents=True, exist_ok=True)
|
| (output_dir / "summary.json").write_text(json.dumps(output, indent=2), encoding="utf-8")
|
| (output_dir / "predictions.json").write_text(json.dumps(artifacts, indent=2), encoding="utf-8")
|
| outputs_path = output_dir / "reader_outputs.jsonl"
|
| with outputs_path.open("w", encoding="utf-8") as handle:
|
| for method in methods:
|
| for row in artifacts[method]:
|
| handle.write(json.dumps(row) + "\n")
|
| write_report(
|
| output_dir,
|
| output["metrics"],
|
| methods,
|
| reader_name=reader_name,
|
| reader_model=reader_model,
|
| )
|
|
|
|
|
| def prompt_comparison_metrics(artifacts: dict[str, list[dict]], methods: list[str]) -> dict:
|
| comparison: dict[str, dict] = {}
|
| for method in methods:
|
| rows = sorted(artifacts[method], key=lambda row: row["question_id"])
|
| overall = score_predictions(rows)
|
| supported = score_conditioned_on_retrieved(rows)
|
| comparison[method] = {
|
| "method_label": METHOD_LABELS.get(method, method),
|
| "n": overall["n"],
|
| "exact_match": overall["exact_match"],
|
| "token_f1": overall["token_f1"],
|
| "evidence_use": overall["evidence_use"],
|
| "insufficient_evidence_rate": overall["insufficient_evidence_rate"],
|
| "abstain_given_supported": supported["insufficient_evidence_rate"],
|
| "gold_retrieved": supported["any_gold_retrieved"],
|
| "retrieved_count": supported["retrieved_count"],
|
| "unsupported_answer_rate": overall["unsupported_answer_rate"],
|
| "parse_failure_rate": overall["parse_failure_rate"],
|
| "total_api_cost": overall["total_api_cost"],
|
| }
|
| return comparison
|
|
|
|
|
| def choose_prompt_mode(comparison: dict[str, dict], methods: list[str]) -> dict:
|
| baseline_name = "answer_if_supported" if "answer_if_supported" in comparison else next(iter(comparison))
|
| baseline = comparison[baseline_name]
|
| fairness_methods = [method for method in ("dense_budgeted_bsc", "dense_rag_e5") if method in methods]
|
| if not fairness_methods:
|
| fairness_methods = methods
|
|
|
| candidates = []
|
| for prompt_mode, method_rows in comparison.items():
|
| parse_max = max(method_rows[method]["parse_failure_rate"] for method in methods)
|
| unsupported_increase = max(
|
| method_rows[method]["unsupported_answer_rate"] - baseline[method]["unsupported_answer_rate"]
|
| for method in methods
|
| )
|
| f1_stable = all(
|
| method_rows[method]["token_f1"] >= baseline[method]["token_f1"] - 0.01
|
| for method in fairness_methods
|
| )
|
| mean_abstain_supported = sum(
|
| method_rows[method]["abstain_given_supported"] for method in fairness_methods
|
| ) / len(fairness_methods)
|
| mean_f1 = sum(method_rows[method]["token_f1"] for method in fairness_methods) / len(fairness_methods)
|
| eligible = parse_max < 0.01 and unsupported_increase <= 0.05 and f1_stable
|
| candidates.append(
|
| {
|
| "prompt_mode": prompt_mode,
|
| "eligible": eligible,
|
| "parse_failure_max": parse_max,
|
| "unsupported_answer_max_increase_vs_baseline": unsupported_increase,
|
| "f1_stable_for_oraclemem_and_full_raw": f1_stable,
|
| "mean_abstain_given_supported_oraclemem_full_raw": mean_abstain_supported,
|
| "mean_f1_oraclemem_full_raw": mean_f1,
|
| }
|
| )
|
| eligible_candidates = [row for row in candidates if row["eligible"]]
|
| if not eligible_candidates:
|
| selected = baseline_name
|
| else:
|
| selected = sorted(
|
| eligible_candidates,
|
| key=lambda row: (
|
| row["mean_abstain_given_supported_oraclemem_full_raw"],
|
| -row["mean_f1_oraclemem_full_raw"],
|
| row["prompt_mode"],
|
| ),
|
| )[0]["prompt_mode"]
|
| return {
|
| "baseline_prompt": baseline_name,
|
| "selected_prompt": selected,
|
| "criteria": [
|
| "Minimize abstain_given_supported averaged over OracleMem dense and full raw dense, not OracleMem alone.",
|
| "Require parse failure below 1%.",
|
| "Require unsupported-answer rate not to increase by more than 5 absolute points versus answer_if_supported.",
|
| "Require OracleMem and full raw dense F1 to stay within 0.01 of baseline or improve.",
|
| ],
|
| "candidates": candidates,
|
| }
|
|
|
|
|
| def write_prompt_dev_report(output_dir: Path, comparison: dict[str, dict], selection: dict, methods: list[str]) -> None:
|
| (output_dir / "prompt_comparison_summary.json").write_text(
|
| json.dumps(
|
| {
|
| "selection": selection,
|
| "metrics": comparison,
|
| },
|
| indent=2,
|
| ),
|
| encoding="utf-8",
|
| )
|
| lines = [
|
| "# Prompt Dev Report",
|
| "",
|
| "- Split: deterministic 50-question LongMemEval-S focus dev split.",
|
| "- Reader: GPT-5.5 through OpenRouter when run with `--reader openrouter --reader-model openai/gpt-5.5`.",
|
| "- Selection rule: choose by the predeclared criteria from the sprint review, prioritizing lower supported-case abstention without increasing unsupported answers or harming full raw dense.",
|
| f"- Selected prompt by script criteria: `{selection['selected_prompt']}`.",
|
| "",
|
| "## Prompt Comparison",
|
| "",
|
| "| Prompt | Method | EM | F1 | Evidence use | Insufficient | Abstain given supported | Unsupported | Parse fail | Cost |",
|
| "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|",
|
| ]
|
| for prompt_mode in comparison:
|
| for method in methods:
|
| row = comparison[prompt_mode][method]
|
| lines.append(
|
| f"| `{prompt_mode}` | {row['method_label']} | "
|
| f"{row['exact_match']:.4f} | {row['token_f1']:.4f} | {row['evidence_use']:.4f} | "
|
| f"{row['insufficient_evidence_rate']:.4f} | {row['abstain_given_supported']:.4f} | "
|
| f"{row['unsupported_answer_rate']:.4f} | {row['parse_failure_rate']:.4f} | "
|
| f"${row['total_api_cost']:.4f} |"
|
| )
|
| lines.extend(
|
| [
|
| "",
|
| "## Selection Diagnostics",
|
| "",
|
| "| Prompt | Eligible | Max parse fail | Max unsupported increase | F1 stable for OracleMem/full raw | Mean abstain given supported | Mean F1 |",
|
| "|---|---:|---:|---:|---:|---:|---:|",
|
| ]
|
| )
|
| for row in selection["candidates"]:
|
| lines.append(
|
| f"| `{row['prompt_mode']}` | {str(row['eligible']).lower()} | "
|
| f"{row['parse_failure_max']:.4f} | {row['unsupported_answer_max_increase_vs_baseline']:.4f} | "
|
| f"{str(row['f1_stable_for_oraclemem_and_full_raw']).lower()} | "
|
| f"{row['mean_abstain_given_supported_oraclemem_full_raw']:.4f} | "
|
| f"{row['mean_f1_oraclemem_full_raw']:.4f} |"
|
| )
|
| lines.extend(
|
| [
|
| "",
|
| "## Artifacts",
|
| "",
|
| "- Per-prompt outputs are under `prompt_<mode>/` subdirectories.",
|
| "- Machine-readable comparison is in `prompt_comparison_summary.json`.",
|
| ]
|
| )
|
| (output_dir / "PROMPT_DEV_REPORT.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser()
|
| parser.add_argument("--analyze-errors", action="store_true")
|
| parser.add_argument("--make-split", action="store_true")
|
| parser.add_argument("--run-dir", type=Path, default=None)
|
| parser.add_argument("--source", type=Path, default=None)
|
| parser.add_argument("--dev-size", type=int, default=50)
|
| parser.add_argument("--dataset-json", type=Path, default=None)
|
| parser.add_argument("--cache-json", type=Path, default=Path("llm_memory_validation/cache/longmemeval_s_cleaned.json"))
|
| parser.add_argument("--retrieval-rows-json", type=Path, default=Path("llm_memory_validation/competitor_run_v2/retrieval_rows.json"))
|
| parser.add_argument("--output-dir", "--out", dest="output_dir", type=Path, default=Path("llm_memory_validation/longmemeval_reader_smoke"))
|
| parser.add_argument("--methods", type=csv_arg, default=DEFAULT_METHODS)
|
| parser.add_argument("--focus-types", type=csv_arg, default=sorted(FOCUS_TYPES))
|
| parser.add_argument("--split", type=Path, default=None)
|
| parser.add_argument("--focus-only", action="store_true")
|
| parser.add_argument("--per-type-limit", type=int, default=0)
|
| parser.add_argument("--budget-frac", type=float, default=0.20)
|
| parser.add_argument("--max-context-words", type=int, default=1800)
|
| parser.add_argument("--reader", "--provider", dest="reader", choices=["extractive_presence_smoke", "openrouter"], default="extractive_presence_smoke")
|
| parser.add_argument("--reader-model", "--model", dest="reader_model", type=str, default="openai/gpt-5.4-mini")
|
| parser.add_argument("--prompt-style", choices=["strict", *PROMPT_MODES], default=None)
|
| parser.add_argument("--prompt-mode", type=csv_arg, default=None)
|
| parser.add_argument("--api-env", type=Path, default=Path("api.env"))
|
| parser.add_argument("--api-cache", type=Path, default=None)
|
| parser.add_argument("--api-max-tokens", type=int, default=160)
|
| parser.add_argument("--api-timeout", type=int, default=90)
|
| parser.add_argument("--temperature", type=float, default=0.0)
|
| parser.add_argument("--reasoning-effort", choices=["minimal", "low", "medium", "high"], default=None)
|
| parser.add_argument("--verbosity", choices=["low", "medium", "high", "xhigh", "max"], default=None)
|
| parser.add_argument("--request-sleep", type=float, default=0.0)
|
| parser.add_argument("--shuffle-jobs", action="store_true")
|
| parser.add_argument("--seed", type=int, default=0)
|
| parser.add_argument("--bootstrap", type=int, default=2000)
|
| parser.add_argument("--save-prompts", action="store_true")
|
| args = parser.parse_args()
|
|
|
| focus_types = set(args.focus_types)
|
| if args.make_split:
|
| if args.source is None:
|
| raise SystemExit("--make-split requires --source")
|
| summary = make_focus_dev_eval_split(args.source, args.dev_size, args.output_dir)
|
| print(json.dumps(summary, indent=2))
|
| return
|
|
|
| if args.analyze_errors:
|
| if args.run_dir is None:
|
| raise SystemExit("--analyze-errors requires --run-dir")
|
| audit = analyze_error_run(args.run_dir, focus_types=focus_types)
|
| print(json.dumps(audit, indent=2))
|
| return
|
|
|
| all_examples = load_examples(args.dataset_json, args.cache_json)
|
| if args.split is not None:
|
| split_ids = load_split_question_ids(args.split)
|
| examples = [example for example in all_examples if example["question_id"] in split_ids]
|
| found_ids = {example["question_id"] for example in examples}
|
| missing_ids = sorted(split_ids - found_ids)
|
| if missing_ids:
|
| raise ValueError(f"{len(missing_ids)} split question_id values were not found in the dataset, e.g. {missing_ids[:5]}")
|
| examples.sort(key=lambda example: example["question_id"])
|
| else:
|
| examples = filter_examples(
|
| all_examples,
|
| focus_types,
|
| focus_only=args.focus_only,
|
| per_type_limit=args.per_type_limit,
|
| seed=args.seed,
|
| )
|
| retrieval_rows = json.loads(args.retrieval_rows_json.read_text(encoding="utf-8"))
|
| methods = canonical_method_list(args.methods)
|
| prompt_modes = validate_prompt_modes(args.prompt_mode or [args.prompt_style or "strict"])
|
| openrouter_reader = None
|
| if args.reader == "openrouter":
|
| env = load_env_file(args.api_env)
|
| api_key = env.get("OPENROUTER_API_KEY")
|
| if not api_key:
|
| raise RuntimeError(f"OPENROUTER_API_KEY not found in {args.api_env}")
|
| api_cache = args.api_cache or (args.output_dir / "openrouter_cache.json")
|
| openrouter_reader = OpenRouterReader(
|
| api_key=api_key,
|
| model=args.reader_model,
|
| cache_path=api_cache,
|
| max_tokens=args.api_max_tokens,
|
| temperature=args.temperature,
|
| request_sleep=args.request_sleep,
|
| timeout=args.api_timeout,
|
| reasoning_effort=args.reasoning_effort,
|
| verbosity=args.verbosity,
|
| )
|
| prompt_comparison: dict[str, dict] = {}
|
| final_outputs: dict[str, dict] = {}
|
| for prompt_mode in prompt_modes:
|
| summary, artifacts = evaluate(
|
| examples=examples,
|
| retrieval_rows=retrieval_rows,
|
| methods=methods,
|
| focus_types=focus_types,
|
| budget_frac=args.budget_frac,
|
| max_context_words=args.max_context_words,
|
| save_prompts=args.save_prompts,
|
| reader_name=args.reader,
|
| openrouter_reader=openrouter_reader,
|
| shuffle_jobs=args.shuffle_jobs,
|
| seed=args.seed,
|
| bootstrap=args.bootstrap,
|
| prompt_style=prompt_mode,
|
| )
|
| output = {
|
| "dataset": str(args.dataset_json or args.cache_json),
|
| "retrieval_rows": str(args.retrieval_rows_json),
|
| "split": str(args.split) if args.split else None,
|
| "reader": args.reader,
|
| "reader_model": args.reader_model if args.reader == "openrouter" else None,
|
| "scope": "API reader" if args.reader == "openrouter" else "deterministic smoke; not an LLM reader",
|
| "focus_types": args.focus_types,
|
| "focus_only": args.focus_only,
|
| "per_type_limit": args.per_type_limit,
|
| "prompt_style": prompt_mode,
|
| "prompt_mode": prompt_mode,
|
| "temperature": args.temperature,
|
| "api_max_tokens": args.api_max_tokens,
|
| "reasoning_effort": args.reasoning_effort,
|
| "verbosity": args.verbosity,
|
| "methods": methods,
|
| "requested_methods": args.methods,
|
| "metrics": summary,
|
| }
|
| run_output_dir = args.output_dir if len(prompt_modes) == 1 else args.output_dir / f"prompt_{prompt_mode}"
|
| write_evaluation_outputs(
|
| run_output_dir,
|
| output,
|
| artifacts,
|
| methods,
|
| reader_name=args.reader,
|
| reader_model=args.reader_model if args.reader == "openrouter" else None,
|
| )
|
| prompt_comparison[prompt_mode] = prompt_comparison_metrics(artifacts, methods)
|
| final_outputs[prompt_mode] = output
|
|
|
| if len(prompt_modes) > 1:
|
| selection = choose_prompt_mode(prompt_comparison, methods)
|
| write_prompt_dev_report(args.output_dir, prompt_comparison, selection, methods)
|
| final_outputs["_prompt_dev_selection"] = selection
|
| print(json.dumps(final_outputs, indent=2))
|
| else:
|
| print(json.dumps(next(iter(final_outputs.values())), indent=2))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
