| |
| """Run a zero-dependency XL-DocBench release smoke test.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
| sys.dont_write_bytecode = True |
|
|
| import evaluate as evaluator |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--release-root", |
| type=Path, |
| default=Path(__file__).resolve().parent.parent, |
| help="Release directory; defaults to the parent of code/", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def require(condition: bool, message: str) -> None: |
| if not condition: |
| raise ValueError(message) |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| rows: list[dict[str, Any]] = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, start=1): |
| if not line.strip(): |
| continue |
| value = json.loads(line) |
| require(isinstance(value, dict), f"Expected object on {path}:{line_number}") |
| rows.append(value) |
| return rows |
|
|
|
|
| def row_documents(row: dict[str, Any]) -> list[dict[str, Any]]: |
| if row.get("task_type") == "single_doc": |
| document = row.get("document") |
| require( |
| isinstance(document, dict), f"Missing document in {row.get('question_id')}" |
| ) |
| return [document] |
| documents = row.get("documents") |
| require( |
| isinstance(documents, list), f"Missing documents in {row.get('question_id')}" |
| ) |
| return documents |
|
|
|
|
| def validate_release(release_root: Path) -> dict[str, int]: |
| manifest_path = release_root / "manifest.json" |
| require(manifest_path.is_file(), f"Missing {manifest_path}") |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
|
|
| release_files = manifest.get("release_files", {}) |
| paths = { |
| name: release_root / release_files[name] |
| for name in ("documents", "single_doc_questions", "cross_doc_questions") |
| } |
| for path in paths.values(): |
| require(path.is_file(), f"Missing release file: {path}") |
|
|
| documents = read_jsonl(paths["documents"]) |
| single = read_jsonl(paths["single_doc_questions"]) |
| cross = read_jsonl(paths["cross_doc_questions"]) |
| questions = single + cross |
|
|
| require(len(documents) == manifest["document_count"], "Document count mismatch") |
| require(len(single) == manifest["single_doc_qa_count"], "Single-doc count mismatch") |
| require(len(cross) == manifest["cross_doc_qa_count"], "Cross-doc count mismatch") |
| require(len(questions) == manifest["qa_count"], "QA count mismatch") |
|
|
| document_ids = [str(document.get("document_id") or "") for document in documents] |
| question_ids = [str(row.get("question_id") or "") for row in questions] |
| require(all(document_ids), "Empty document_id") |
| require(all(question_ids), "Empty question_id") |
| require(len(set(document_ids)) == len(document_ids), "Duplicate document_id") |
| require(len(set(question_ids)) == len(question_ids), "Duplicate question_id") |
|
|
| known_documents = set(document_ids) |
| referenced_documents: set[str] = set() |
| evidence_item_count = 0 |
| for row in questions: |
| question_id = row["question_id"] |
| require( |
| str(row.get("question") or "").strip(), f"Empty question: {question_id}" |
| ) |
| require(isinstance(row.get("answer"), dict), f"Missing answer: {question_id}") |
| documents_for_row = row_documents(row) |
| metadata = row.get("metadata") |
| require(isinstance(metadata, dict), f"Missing metadata: {question_id}") |
| require( |
| metadata.get("n_context_documents") == len(documents_for_row), |
| f"Context-document count mismatch: {question_id}", |
| ) |
|
|
| actual_evidence_documents = 0 |
| for document in documents_for_row: |
| document_id = str(document.get("document_id") or "") |
| require(document_id in known_documents, f"Unknown document: {document_id}") |
| referenced_documents.add(document_id) |
| require( |
| document.get("evidence_page_numbering") == "pdf_index", |
| f"Missing evidence page semantics: {question_id}", |
| ) |
| evidence_pages = document.get("evidence_pages") |
| evidence_items = document.get("evidence_items") |
| require( |
| isinstance(evidence_pages, list), |
| f"Invalid evidence_pages: {question_id}", |
| ) |
| require( |
| isinstance(evidence_items, list), |
| f"Invalid evidence_items: {question_id}", |
| ) |
| actual_evidence_documents += bool(evidence_pages or evidence_items) |
| evidence_item_count += len(evidence_items) |
| for item in evidence_items: |
| require( |
| str(item.get("locator") or "").strip(), |
| f"Empty locator: {question_id}", |
| ) |
| require(bool(item.get("pages")), f"Empty item pages: {question_id}") |
| require( |
| item.get("page_numbering") == "annotator_supplied", |
| f"Missing item page semantics: {question_id}", |
| ) |
| require( |
| item.get("evidence_kind") |
| in {"supporting_excerpt", "annotator_rationale"}, |
| f"Invalid evidence kind: {question_id}", |
| ) |
|
|
| require( |
| metadata.get("n_evidence_documents") == actual_evidence_documents, |
| f"Evidence-document count mismatch: {question_id}", |
| ) |
| for item in row.get("unassigned_evidence_items", []): |
| require( |
| item.get("evidence_kind") == "unassigned_annotation", |
| f"Invalid unassigned evidence kind: {question_id}", |
| ) |
|
|
| require(referenced_documents == known_documents, "Unreferenced released documents") |
| require( |
| evidence_item_count == manifest["evidence_item_count"], |
| "Evidence-item count mismatch", |
| ) |
|
|
| score_path = release_root / release_files["per_question_scores"] |
| summary_path = release_root / release_files["score_summary"] |
| require(score_path.is_file(), f"Missing score file: {score_path}") |
| require(summary_path.is_file(), f"Missing score summary: {summary_path}") |
| score_rows = read_jsonl(score_path) |
| score_ids = [str(row.get("question_id") or "") for row in score_rows] |
| require(len(score_rows) == len(questions), "Per-question score count mismatch") |
| require(set(score_ids) == set(question_ids), "Per-question score IDs mismatch") |
| score_summary = json.loads(summary_path.read_text(encoding="utf-8")) |
| systems = score_summary.get("systems", {}) |
| require( |
| len(systems) == manifest["scored_system_count"], "Scored-system count mismatch" |
| ) |
| expected_systems = set(systems) |
| for row in score_rows: |
| row_scores = row.get("scores") |
| require(isinstance(row_scores, dict), "Invalid per-question scores") |
| require(set(row_scores) == expected_systems, "Per-question system mismatch") |
| for metrics in row_scores.values(): |
| require(isinstance(metrics, dict), "Invalid metric record") |
| for metric in ("accuracy", "token_f1", "anls"): |
| value = metrics.get(metric) |
| require( |
| isinstance(value, (int, float)) and 0 <= value <= 1, |
| f"Invalid {metric} score", |
| ) |
| return { |
| "documents": len(documents), |
| "single_doc": len(single), |
| "cross_doc": len(cross), |
| "questions": len(questions), |
| "evidence_items": evidence_item_count, |
| "systems": len(systems), |
| } |
|
|
|
|
| def evaluate_examples(code_dir: Path) -> dict[str, float | int]: |
| examples = code_dir / "examples" |
| gold = evaluator.load_gold_records([examples / "gold_sample.jsonl"]) |
| predictions, statuses = evaluator.load_predictions( |
| examples / "predictions_sample.jsonl" |
| ) |
| report = evaluator.evaluate(gold, predictions, statuses) |
| overall = report["overall"] |
| require(report["evaluated_count"] == 5, "Example evaluation count mismatch") |
| require(overall["accuracy"] == 1.0, "Example Accuracy regression") |
| require(overall["token_f1"] == 1.0, "Example Token F1 regression") |
| require(overall["anls"] == 1.0, "Example ANLS regression") |
| return overall |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| release_root = args.release_root.resolve() |
| counts = validate_release(release_root) |
| metrics = evaluate_examples(Path(__file__).resolve().parent) |
|
|
| print("XL-DocBench smoke test: PASS") |
| print( |
| f" data: {counts['documents']:,} documents, " |
| f"{counts['questions']:,} QA " |
| f"({counts['single_doc']:,} single + {counts['cross_doc']:,} cross)" |
| ) |
| print(f" evidence items: {counts['evidence_items']:,}") |
| print(f" per-question scores: {counts['systems']} systems") |
| print( |
| f" sample metrics: Accuracy={metrics['accuracy'] * 100:.1f}, " |
| f"F1={metrics['token_f1'] * 100:.1f}, ANLS={metrics['anls'] * 100:.1f}" |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| main() |
| except (KeyError, OSError, TypeError, ValueError, json.JSONDecodeError) as exc: |
| print(f"XL-DocBench smoke test: FAIL — {exc}", file=sys.stderr) |
| sys.exit(1) |
|
|
