| """Compare two natural OracleMem coverage packages. |
| |
| The comparison is intentionally conservative. Unit identifiers can differ |
| across annotators, so the report compares normalized required-unit text and |
| candidate-coverage text pairs in addition to exact ids. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| from pathlib import Path |
| from typing import Any, Iterable, Mapping |
|
|
|
|
| TOKEN_RE = re.compile(r"[a-z0-9]+") |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| if not path.exists(): |
| return [] |
| rows: list[dict[str, Any]] = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line in handle: |
| line = line.strip() |
| if line: |
| rows.append(json.loads(line)) |
| return rows |
|
|
|
|
| def norm_text(value: Any) -> str: |
| return " ".join(TOKEN_RE.findall(str(value).lower())) |
|
|
|
|
| def package_rows(path: Path) -> dict[str, list[dict[str, Any]]]: |
| return { |
| "queries": read_jsonl(path / "queries.jsonl"), |
| "evidence_units": read_jsonl(path / "evidence_units.jsonl"), |
| "candidate_memories": read_jsonl(path / "candidate_memories.jsonl"), |
| "coverage_matrix": read_jsonl(path / "coverage_matrix.jsonl"), |
| } |
|
|
|
|
| def unit_text_map(rows: Iterable[Mapping[str, Any]]) -> dict[str, str]: |
| return { |
| str(row.get("unit_id")): norm_text(row.get("canonical_text") or row.get("unit_id")) |
| for row in rows |
| if row.get("unit_id") |
| } |
|
|
|
|
| def candidate_text_map(rows: Iterable[Mapping[str, Any]]) -> dict[str, str]: |
| return { |
| str(row.get("candidate_id")): norm_text(row.get("text") or row.get("serialized") or row.get("candidate_id")) |
| for row in rows |
| if row.get("candidate_id") |
| } |
|
|
|
|
| def jaccard(left: set[str], right: set[str]) -> float: |
| if not left and not right: |
| return 1.0 |
| union = left | right |
| if not union: |
| return 0.0 |
| return len(left & right) / len(union) |
|
|
|
|
| def required_texts(query: Mapping[str, Any], unit_text: Mapping[str, str]) -> set[str]: |
| return { |
| unit_text.get(str(unit_id), norm_text(unit_id)) |
| for unit_id in query.get("required_unit_ids", []) or [] |
| if unit_text.get(str(unit_id), norm_text(unit_id)) |
| } |
|
|
|
|
| def coverage_text_edges( |
| coverage_rows: Iterable[Mapping[str, Any]], |
| unit_text: Mapping[str, str], |
| candidate_text: Mapping[str, str], |
| ) -> set[tuple[str, str]]: |
| edges: set[tuple[str, str]] = set() |
| for row in coverage_rows: |
| cov = float(row.get("coverage", 0.0) or 0.0) |
| if cov <= 0: |
| continue |
| ctext = candidate_text.get(str(row.get("candidate_id")), "") |
| utext = unit_text.get(str(row.get("unit_id")), "") |
| if ctext and utext: |
| edges.add((ctext, utext)) |
| return edges |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--primary", type=Path, required=True) |
| parser.add_argument("--secondary", type=Path, required=True) |
| parser.add_argument("--out-dir", type=Path, required=True) |
| args = parser.parse_args() |
|
|
| primary = package_rows(args.primary) |
| secondary = package_rows(args.secondary) |
| args.out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| p_unit_text = unit_text_map(primary["evidence_units"]) |
| s_unit_text = unit_text_map(secondary["evidence_units"]) |
| p_candidate_text = candidate_text_map(primary["candidate_memories"]) |
| s_candidate_text = candidate_text_map(secondary["candidate_memories"]) |
|
|
| p_queries = {str(row.get("query_id")): row for row in primary["queries"] if row.get("query_id")} |
| s_queries = {str(row.get("query_id")): row for row in secondary["queries"] if row.get("query_id")} |
| common_query_ids = sorted(set(p_queries) & set(s_queries)) |
|
|
| agreement_rows: list[dict[str, Any]] = [] |
| exact_required_agree = 0 |
| both_resolved = 0 |
| primary_resolved = 0 |
| secondary_resolved = 0 |
| for query_id in common_query_ids: |
| p_required = required_texts(p_queries[query_id], p_unit_text) |
| s_required = required_texts(s_queries[query_id], s_unit_text) |
| if p_required: |
| primary_resolved += 1 |
| if s_required: |
| secondary_resolved += 1 |
| if p_required and s_required: |
| both_resolved += 1 |
| if p_required == s_required: |
| exact_required_agree += 1 |
| agreement_rows.append( |
| { |
| "query_id": query_id, |
| "primary_required_texts": sorted(p_required), |
| "secondary_required_texts": sorted(s_required), |
| "required_text_jaccard": jaccard(p_required, s_required), |
| "agreement_class": ( |
| "AGREE" |
| if p_required == s_required |
| else "UNRESOLVED" |
| if not p_required or not s_required |
| else "MINOR_DISAGREEMENT" |
| if jaccard(p_required, s_required) >= 0.5 |
| else "MAJOR_DISAGREEMENT" |
| ), |
| } |
| ) |
|
|
| p_edges = coverage_text_edges(primary["coverage_matrix"], p_unit_text, p_candidate_text) |
| s_edges = coverage_text_edges(secondary["coverage_matrix"], s_unit_text, s_candidate_text) |
| summary = { |
| "schema_version": 1, |
| "primary": str(args.primary), |
| "secondary": str(args.secondary), |
| "common_queries": len(common_query_ids), |
| "primary_resolved": primary_resolved, |
| "secondary_resolved": secondary_resolved, |
| "both_resolved": both_resolved, |
| "exact_required_text_agreement_rate": (exact_required_agree / len(common_query_ids)) if common_query_ids else 0.0, |
| "mean_required_text_jaccard": ( |
| sum(float(row["required_text_jaccard"]) for row in agreement_rows) / len(agreement_rows) |
| if agreement_rows |
| else 0.0 |
| ), |
| "major_disagreement_count": sum(1 for row in agreement_rows if row["agreement_class"] == "MAJOR_DISAGREEMENT"), |
| "minor_disagreement_count": sum(1 for row in agreement_rows if row["agreement_class"] == "MINOR_DISAGREEMENT"), |
| "unresolved_disagreement_count": sum(1 for row in agreement_rows if row["agreement_class"] == "UNRESOLVED"), |
| "coverage_edge_text_jaccard": jaccard(p_edges, s_edges), |
| "primary_coverage_edges": len(p_edges), |
| "secondary_coverage_edges": len(s_edges), |
| } |
|
|
| (args.out_dir / "summary.json").write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8") |
| with (args.out_dir / "agreement_rows.jsonl").open("w", encoding="utf-8") as handle: |
| for row in agreement_rows: |
| handle.write(json.dumps(row, sort_keys=True) + "\n") |
|
|
| report = [ |
| "# Natural Coverage Annotation Agreement", |
| "", |
| f"- Primary: `{args.primary}`", |
| f"- Secondary: `{args.secondary}`", |
| f"- Common queries: {summary['common_queries']}", |
| f"- Primary resolved: {summary['primary_resolved']}", |
| f"- Secondary resolved: {summary['secondary_resolved']}", |
| f"- Both resolved: {summary['both_resolved']}", |
| f"- Exact required-text agreement: {summary['exact_required_text_agreement_rate']:.3f}", |
| f"- Mean required-text Jaccard: {summary['mean_required_text_jaccard']:.3f}", |
| f"- Coverage-edge text Jaccard: {summary['coverage_edge_text_jaccard']:.3f}", |
| f"- Major disagreements: {summary['major_disagreement_count']}", |
| f"- Minor disagreements: {summary['minor_disagreement_count']}", |
| f"- Unresolved disagreements: {summary['unresolved_disagreement_count']}", |
| "", |
| "This is a model-model agreement audit. It does not certify semantic truth; it identifies which examples need manual adjudication.", |
| ] |
| (args.out_dir / "REPORT.md").write_text("\n".join(report) + "\n", encoding="utf-8") |
| print(json.dumps(summary, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
