| |
| import argparse |
| import json |
| from pathlib import Path |
|
|
| from sentence_transformers import SentenceTransformer |
|
|
|
|
| def load_cases(path: Path): |
| cases = [] |
| with path.open() as f: |
| for line in f: |
| line = line.strip() |
| if line: |
| cases.append(json.loads(line)) |
| return cases |
|
|
|
|
| def cosine_rank(model, query: str, entries: list[dict]): |
| texts = [query] + [entry["text"] for entry in entries] |
| embs = model.encode(texts, normalize_embeddings=True) |
| query_emb = embs[0] |
| doc_embs = embs[1:] |
| scores = (doc_embs @ query_emb).tolist() |
| ranked = sorted(zip(scores, entries), key=lambda item: (-item[0], item[1]["id"])) |
| return [entry["id"] for _, entry in ranked] |
|
|
|
|
| def score_case(case: dict, ranked_ids: list[str]): |
| relevant = set(case["relevant_ids"]) |
| hit_at_1 = bool(ranked_ids[:1] and ranked_ids[0] in relevant) |
| hit_at_5 = any(item in relevant for item in ranked_ids[:5]) |
| mrr = 0.0 |
| for i, item in enumerate(ranked_ids): |
| if item in relevant: |
| mrr = 1.0 / float(i + 1) |
| break |
| return { |
| "id": case["id"], |
| "adversary_type": case["adversary_type"], |
| "query": case["query"], |
| "relevant_ids": case["relevant_ids"], |
| "ranked_ids": ranked_ids, |
| "hit_at_1": hit_at_1, |
| "hit_at_5": hit_at_5, |
| "mrr": mrr, |
| } |
|
|
|
|
| def summarize(results): |
| hits1 = hits5 = 0 |
| total_mrr = 0.0 |
| per_category = {} |
| for item in results: |
| hits1 += 1 if item["hit_at_1"] else 0 |
| hits5 += 1 if item["hit_at_5"] else 0 |
| total_mrr += item["mrr"] |
| bucket = per_category.setdefault(item["adversary_type"], {"hit": 0, "total": 0}) |
| bucket["total"] += 1 |
| bucket["hit"] += 1 if item["hit_at_5"] else 0 |
| return { |
| "cases": len(results), |
| "recall_at_1": hits1 / len(results) if results else 0, |
| "recall_at_5": hits5 / len(results) if results else 0, |
| "mrr": total_mrr / len(results) if results else 0, |
| "per_category": {key: value["hit"] / value["total"] for key, value in per_category.items()}, |
| "results": results, |
| } |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description="Run a dense retriever baseline on FalseMemBench") |
| parser.add_argument("--data", default=str(Path(__file__).resolve().parents[1] / "data" / "cases.jsonl")) |
| parser.add_argument("--model", required=True) |
| parser.add_argument("--out", default="") |
| args = parser.parse_args() |
| model = SentenceTransformer(args.model) |
| cases = load_cases(Path(args.data)) |
| results = [] |
| for case in cases: |
| ranked_ids = cosine_rank(model, case["query"], case["entries"]) |
| results.append(score_case(case, ranked_ids)) |
| report = summarize(results) |
| print(json.dumps({key: report[key] for key in ["cases", "recall_at_1", "recall_at_5", "mrr"]}, indent=2)) |
| if args.out: |
| out = Path(args.out) |
| out.parent.mkdir(parents=True, exist_ok=True) |
| out.write_text(json.dumps(report, indent=2)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
