| |
| |
| """Score a semantic-cache matcher against the EchoCache correctness benchmark. |
| |
| python3 evaluate.py # scores the EchoCache matcher from the Hub |
| python3 evaluate.py --matcher ./echocache_matcher.py |
| |
| The headline number is WRONG REUSE: the share of "must not reuse" pairs that a |
| matcher would serve from cache anyway. Every one of those is a wrong answer |
| shipped to a user. Reuse recall (how many safe pairs it does reuse) is only |
| worth reading once wrong reuse is near zero. |
| |
| Requires: numpy. Optional: huggingface_hub (to fetch the matcher and the data). |
| """ |
| import argparse |
| import importlib.util |
| import json |
| import os |
| import sys |
|
|
|
|
| def load_matcher(path=None): |
| """Guarantees: returns an imported matcher module, fetching it from the Hub when no path is given.""" |
| if path is None: |
| from huggingface_hub import hf_hub_download |
| path = hf_hub_download("NagaYu/echocache-matcher", "echocache_matcher.py") |
| spec = importlib.util.spec_from_file_location("echocache_matcher", path) |
| module = importlib.util.module_from_spec(spec) |
| sys.modules["echocache_matcher"] = module |
| spec.loader.exec_module(module) |
| return module |
|
|
|
|
| def load_pairs(path=None): |
| """Guarantees: returns the benchmark rows, fetching them from the Hub when no path is given.""" |
| if path is None: |
| candidate = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pairs.jsonl") |
| if os.path.exists(candidate): |
| path = candidate |
| else: |
| from huggingface_hub import hf_hub_download |
| path = hf_hub_download("NagaYu/echocache-guard-benchmark", "pairs.jsonl", repo_type="dataset") |
| with open(path, encoding="utf-8") as handle: |
| return [json.loads(line) for line in handle if line.strip()] |
|
|
|
|
| def score(matcher, pairs, threshold, use_guard): |
| """Guarantees: returns the confusion counts and per-relation breakdown for one configuration.""" |
| stats = {"reused_safe": 0, "missed_safe": 0, "wrong_reuse": 0, "correct_refusal": 0} |
| per_relation = {} |
| wrong = [] |
| for row in pairs: |
| verdict = matcher.match(row["query"], row["candidate"], threshold, use_guard) |
| reused = bool(verdict["reuse"]) |
| bucket = per_relation.setdefault(row["relation"], {"n": 0, "ok": 0}) |
| bucket["n"] += 1 |
| if row["expect_reuse"]: |
| if reused: |
| stats["reused_safe"] += 1 |
| bucket["ok"] += 1 |
| else: |
| stats["missed_safe"] += 1 |
| else: |
| if reused: |
| stats["wrong_reuse"] += 1 |
| wrong.append((row["id"], round(verdict["similarity"], 4), row["query"][:48])) |
| else: |
| stats["correct_refusal"] += 1 |
| bucket["ok"] += 1 |
| safe = stats["reused_safe"] + stats["missed_safe"] |
| unsafe = stats["wrong_reuse"] + stats["correct_refusal"] |
| stats["reuse_recall"] = round(stats["reused_safe"] / safe, 4) if safe else 0.0 |
| stats["wrong_reuse_rate"] = round(stats["wrong_reuse"] / unsafe, 4) if unsafe else 0.0 |
| stats["accuracy"] = round((stats["reused_safe"] + stats["correct_refusal"]) / len(pairs), 4) if pairs else 0.0 |
| return stats, per_relation, wrong |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--matcher", default=None, help="path to echocache_matcher.py (default: fetch from the Hub)") |
| parser.add_argument("--pairs", default=None, help="path to pairs.jsonl (default: next to this file, else the Hub)") |
| parser.add_argument("--thresholds", default="0.70,0.80,0.86,0.90,0.92,0.95,0.98") |
| args = parser.parse_args() |
|
|
| matcher = load_matcher(args.matcher) |
| pairs = load_pairs(args.pairs) |
| print("benchmark: %d pairs (%d may reuse, %d must not)\n" % ( |
| len(pairs), sum(1 for p in pairs if p["expect_reuse"]), sum(1 for p in pairs if not p["expect_reuse"]))) |
|
|
| print("%-7s %-7s %9s %12s %16s %9s" % ("thresh", "guard", "accuracy", "reuse_recall", "wrong_reuse_rate", "wrong_n")) |
| print("-" * 66) |
| for raw in args.thresholds.split(","): |
| threshold = float(raw) |
| for use_guard in (True, False): |
| stats, _, _ = score(matcher, pairs, threshold, use_guard) |
| print("%-7.2f %-7s %9.4f %12.4f %16.4f %9d" % ( |
| threshold, "on" if use_guard else "off", stats["accuracy"], |
| stats["reuse_recall"], stats["wrong_reuse_rate"], stats["wrong_reuse"])) |
|
|
| default = getattr(matcher, "DEFAULT_THRESHOLD", 0.92) |
| stats, per_relation, wrong = score(matcher, pairs, default, True) |
| print("\nper relation at threshold %.2f, guard on:" % default) |
| for name in sorted(per_relation): |
| bucket = per_relation[name] |
| print(" %-26s %3d/%3d correct" % (name, bucket["ok"], bucket["n"])) |
| if wrong: |
| print("\nwrong reuse at threshold %.2f:" % default) |
| for entry in wrong: |
| print(" ", entry) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
