Upload scripts/evaluate.py

scripts/evaluate.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""Evaluate retrieval runs and provide a deterministic lexical smoke baseline."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+from validate_dataset import ROOT, ValidationError, read_jsonl, validate
+
+
+TOKEN_RE = re.compile(r"[a-z0-9_]+|[\u3400-\u4dbf\u4e00-\u9fff]", re.IGNORECASE)
+METRIC_KEYS = ("ndcg@10", "recall@5", "success@1", "mrr@10", "hard_negative_inversion")
+
+
+def tokens(text: str) -> list[str]:
+    return TOKEN_RE.findall(text.casefold())
+
+
+def lexical_rank(
+    queries: Iterable[dict[str, Any]],
+    corpus: list[dict[str, Any]],
+) -> dict[str, list[str]]:
+    """Rank with a small BM25-style lexical scorer.
+
+    This intentionally performs no translation. Low cross-lingual scores are an
+    honest property of the smoke baseline rather than something hidden by
+    query-specific aliases.
+    """
+
+    document_tokens = {row["chunk_id"]: tokens(row["text"]) for row in corpus}
+    document_frequencies: Counter[str] = Counter()
+    for values in document_tokens.values():
+        document_frequencies.update(set(values))
+    document_count = len(corpus)
+    average_length = sum(map(len, document_tokens.values())) / max(document_count, 1)
+    k1 = 1.2
+    b = 0.75
+
+    rankings: dict[str, list[str]] = {}
+    for query in queries:
+        query_terms = Counter(tokens(query["query"]))
+        scored: list[tuple[float, str]] = []
+        for chunk_id, values in document_tokens.items():
+            frequencies = Counter(values)
+            length_normalization = k1 * (1 - b + b * len(values) / max(average_length, 1))
+            score = 0.0
+            for term, query_count in query_terms.items():
+                frequency = frequencies.get(term, 0)
+                if frequency == 0:
+                    continue
+                df = document_frequencies[term]
+                inverse_document_frequency = math.log(
+                    1 + (document_count - df + 0.5) / (df + 0.5)
+                )
+                score += (
+                    query_count
+                    * inverse_document_frequency
+                    * frequency
+                    * (k1 + 1)
+                    / (frequency + length_normalization)
+                )
+            scored.append((score, chunk_id))
+        scored.sort(key=lambda item: (-item[0], item[1]))
+        rankings[query["query_id"]] = [chunk_id for _, chunk_id in scored]
+    return rankings
+
+
+def load_run(path: Path, corpus_ids: set[str]) -> dict[str, list[str]]:
+    rows = read_jsonl(path)
+    rankings: dict[str, list[str]] = {}
+    for row in rows:
+        query_id = row.get("query_id")
+        ranked = row.get("ranked_chunk_ids")
+        if not isinstance(query_id, str) or query_id in rankings:
+            raise ValidationError(f"run: invalid or duplicate query_id {query_id!r}")
+        if not isinstance(ranked, list) or not all(isinstance(value, str) for value in ranked):
+            raise ValidationError(f"run {query_id}: ranked_chunk_ids must be a string list")
+        if len(ranked) != len(set(ranked)):
+            raise ValidationError(f"run {query_id}: duplicate ranked chunk")
+        unknown = set(ranked) - corpus_ids
+        if unknown:
+            raise ValidationError(f"run {query_id}: unknown chunks {sorted(unknown)}")
+        rankings[query_id] = ranked
+    return rankings
+
+
+def require_exact_query_set(
+    rankings: dict[str, list[str]],
+    queries: Iterable[dict[str, Any]],
+) -> None:
+    expected = {query["query_id"] for query in queries}
+    observed = set(rankings)
+    if observed != expected:
+        missing = sorted(expected - observed)
+        unexpected = sorted(observed - expected)
+        raise ValidationError(
+            f"run query set mismatch; missing={missing}, unexpected={unexpected}"
+        )
+
+
+def query_metrics(query: dict[str, Any], ranking: list[str]) -> dict[str, float]:
+    grades = {item["chunk_id"]: item["grade"] for item in query["relevance"]}
+    binary_relevant = {chunk_id for chunk_id, grade in grades.items() if grade >= 2}
+
+    def dcg(ordered_grades: Iterable[int], limit: int) -> float:
+        return sum(
+            (2**grade - 1) / math.log2(rank + 1)
+            for rank, grade in enumerate(list(ordered_grades)[:limit], 1)
+        )
+
+    observed_grades = [grades.get(chunk_id, 0) for chunk_id in ranking]
+    ideal_grades = sorted(grades.values(), reverse=True)
+    ideal = dcg(ideal_grades, 10)
+    ndcg = dcg(observed_grades, 10) / ideal if ideal else 0.0
+    found_at_five = binary_relevant.intersection(ranking[:5])
+    recall = len(found_at_five) / len(binary_relevant) if binary_relevant else 0.0
+    success = float(bool(ranking[:1] and ranking[0] in binary_relevant))
+
+    reciprocal_rank = 0.0
+    for rank, chunk_id in enumerate(ranking[:10], 1):
+        if chunk_id in binary_relevant:
+            reciprocal_rank = 1.0 / rank
+            break
+
+    positions = {chunk_id: rank for rank, chunk_id in enumerate(ranking, 1)}
+    missing_rank = len(ranking) + 1
+    best_direct = min(
+        (positions.get(chunk_id, missing_rank) for chunk_id, grade in grades.items() if grade == 3),
+        default=missing_rank,
+    )
+    best_negative = min(
+        (positions.get(chunk_id, missing_rank) for chunk_id in query["hard_negative_chunk_ids"]),
+        default=missing_rank,
+    )
+    inversion = float(best_negative < best_direct)
+    return {
+        "ndcg@10": ndcg,
+        "recall@5": recall,
+        "success@1": success,
+        "mrr@10": reciprocal_rank,
+        "hard_negative_inversion": inversion,
+    }
+
+
+def average(rows: list[dict[str, float]]) -> dict[str, float]:
+    if not rows:
+        return {key: 0.0 for key in METRIC_KEYS}
+    return {
+        key: sum(row[key] for row in rows) / len(rows)
+        for key in METRIC_KEYS
+    }
+
+
+def evaluate(
+    queries: list[dict[str, Any]],
+    rankings: dict[str, list[str]],
+    run_name: str,
+) -> dict[str, Any]:
+    per_query: list[dict[str, Any]] = []
+    by_language: dict[str, list[dict[str, float]]] = defaultdict(list)
+    for query in sorted(queries, key=lambda row: row["query_id"]):
+        metrics = query_metrics(query, rankings.get(query["query_id"], []))
+        per_query.append(
+            {
+                "query_id": query["query_id"],
+                "language": query["language"],
+                **metrics,
+            }
+        )
+        by_language[query["language"]].append(metrics)
+
+    overall = average([{key: row[key] for key in METRIC_KEYS} for row in per_query])
+    language_metrics = {
+        language: {"count": len(rows), **average(rows)}
+        for language, rows in sorted(by_language.items())
+    }
+    worst_language_ndcg = min(
+        (row["ndcg@10"] for row in language_metrics.values()),
+        default=0.0,
+    )
+    english = language_metrics.get("en", {}).get("ndcg@10", 0.0)
+    cantonese = language_metrics.get("yue-Hant", {}).get("ndcg@10", 0.0)
+    return {
+        "run": run_name,
+        "query_count": len(queries),
+        "primary_metric": "ndcg@10",
+        "overall": overall,
+        "per_language": language_metrics,
+        "worst_language_ndcg@10": worst_language_ndcg,
+        "english_minus_cantonese_ndcg@10": english - cantonese,
+        "per_query": per_query,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--split", choices=("validation", "test", "all"), default="validation")
+    parser.add_argument("--run", type=Path, help="Optional JSONL retrieval run")
+    args = parser.parse_args()
+
+    try:
+        validate()
+        corpus = read_jsonl(ROOT / "data" / "corpus.jsonl")
+        if args.split == "all":
+            queries = read_jsonl(ROOT / "data" / "validation.jsonl") + read_jsonl(
+                ROOT / "data" / "test.jsonl"
+            )
+        else:
+            queries = read_jsonl(ROOT / "data" / f"{args.split}.jsonl")
+        if args.run:
+            rankings = load_run(args.run, {row["chunk_id"] for row in corpus})
+            require_exact_query_set(rankings, queries)
+            run_name = str(args.run)
+        else:
+            rankings = lexical_rank(queries, corpus)
+            run_name = "stdlib-bm25-style-lexical-smoke"
+        result = evaluate(queries, rankings, run_name)
+    except (OSError, KeyError, TypeError, ValueError, ValidationError) as error:
+        print(f"ERROR: {error}")
+        return 1
+    print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())