| """Compute annotation agreement, per-image evidence and summary tables offline.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| from collections import Counter |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| from metrics.annotation_agreement import (METHOD_VERSION, SEED, FIELDS, RATING_WIDTH, prepare_image, |
| image_statistics, agreement_summary, rating_summary, public_evidence, stable_seed) |
| from metrics.semantic import SemanticPolicy |
| from schemas.ground_truth import GoldDataset |
| from scripts.frontend.build_dataset_eda import GOLD_DIR, IAA_DIR, MANIFEST_PATH, DOMAIN_PATH, ROOT, _latest |
| from utils.io import sha256_file |
| from utils.release import release_paths, release_identity, release_config, validate_population |
|
|
| DEFAULT_OUTPUT = ROOT / "frontend/.generated/dataset_agreement.json" |
| DEFAULT_EVIDENCE = ROOT / "frontend/.generated/dataset_agreement_evidence.json" |
| DEFAULT_POLICY = ROOT / "data/semantic_similarity/bge-large-en-v1.5-description-v2.json" |
|
|
|
|
| def source(path, records=None): |
| return {"filename": path.name, "sha256": sha256_file(path), "records": records} |
|
|
|
|
| def build_agreement(*, gold_path, iaa_path, manifest_path, domain_path, policy_path, |
| output, evidence_output, replicates=2000, report_dir=None, release=None): |
| if replicates < 0: |
| raise ValueError("Bootstrap replicate count must be non-negative") |
| gold_raw = json.loads(gold_path.read_text()) |
| GoldDataset.from_file(gold_path) |
| raw = json.loads(iaa_path.read_text()) |
| if not isinstance(raw, list) or len({r["image_id"] for r in raw}) != len(raw): |
| raise ValueError("IAA requires unique image IDs") |
| for r in raw: |
| labels = r["first_pass"] |
| if len(labels) < 2 or len({a["annotator"] for a in labels}) != len(labels) or r["n_first_pass"] != len(labels): |
| raise ValueError("IAA requires at least two distinct first-pass annotators and matching counts") |
| manifest = [json.loads(line) for line in manifest_path.read_text().splitlines() if line.strip()] |
| by_id = {r["image_id"]: r for r in manifest} |
| if release: |
| validate_population(gold_raw, raw, manifest, release["expected"]) |
| if len(by_id) != len(manifest): |
| raise ValueError("Manifest requires unique image IDs") |
| if any(r["image_id"] not in by_id for r in raw + gold_raw): |
| raise ValueError("Gold/IAA images must resolve to the selected manifest") |
| domains = json.loads(domain_path.read_text()) |
| ids = [c for cs in domains.values() for c in cs] |
| if len(ids) != len(set(ids)): |
| raise ValueError("Each class must belong to exactly one domain") |
| payload = json.loads(policy_path.read_text()) |
| policy = SemanticPolicy.from_dict(payload) |
| if set(policy.class_ids) != set(ids): |
| raise ValueError("Semantic policy and domain taxonomy must agree") |
| matrix = np.asarray(policy.similarities) |
| accepted = np.asarray(policy.accepted) |
| if matrix.shape != (len(ids), len(ids)) or not np.isfinite(matrix).all() or not np.allclose(matrix, matrix.T): |
| raise ValueError("Semantic matrix must be finite and symmetric") |
| if not np.array_equal(accepted, (matrix > .8) | np.eye(len(ids), dtype=bool)): |
| raise ValueError("Agreement analysis requires the frozen strict cosine >0.80 policy") |
| gold = {} |
| names = {} |
| for r in gold_raw: |
| g = r["gold"] |
| if any(v["use_case_id"] not in ids for v in g["violations"]): |
| raise ValueError("Unknown gold class") |
| gold[r["image_id"]] = {k: g.get(k) for k in ("plausibility", "naturalness", "reported", "no_violation_detected")} |
| gold[r["image_id"]]["violations"] = [{"use_case_id": v["use_case_id"], "name": v["use_case_name"], "bbox": v["bbox"]} for v in g["violations"]] |
| names.update({v["use_case_id"]: v["use_case_name"] for v in g["violations"]}) |
| for r in raw: |
| for a in r["first_pass"]: |
| names.update({v["use_case_id"]: v.get("use_case_name", v["use_case_id"]) for v in a["violations"]}) |
| images = [prepare_image(r, gold.get(r["image_id"]), by_id[r["image_id"]].get("category", "unmapped"), domains, policy) |
| for r in sorted(raw, key=lambda r: r["image_id"])] |
| print(f"Prepared {len(images):,} images; computing aggregate bootstrap intervals", flush=True) |
| sources = {"gold": source(gold_path, len(gold)), "iaa": source(iaa_path, len(raw)), |
| "manifest": source(manifest_path, len(manifest)), "domains": source(domain_path, len(domains)), |
| "policy": source(policy_path, len(ids))} |
| selections = {} |
| categories = sorted({im["category"] for im in images}) |
| for pop in ("all", "gold_linked"): |
| for category in ["all", *categories]: |
| selections[f"{pop}:{category}"] = np.array([i for i, im in enumerate(images) |
| if (pop == "all" or im["gold"] is not None) and (category == "all" or im["category"] == category)], dtype=int) |
| targets = [("overall", "All violations", "overall", set(ids))] |
| targets += [(d, d, "domain", set(cs)) for d, cs in domains.items()] |
| targets += [(c, names.get(c, c), "class", {c}) for c in ids] |
| groups = {key: {"population": key.split(":", 1)[0], "source": key.split(":", 1)[1], |
| "images": len(indices), "rows": []} for key, indices in selections.items()} |
| quality = {k: np.array([im["quality"][k] for im in images]).reshape(-1, RATING_WIDTH) for k in ("plausibility", "naturalness")} |
| |
| absent_cache = {} |
| all_present = [set().union(*im["sets"].values()) if im["sets"] else set() for im in images] |
| for target_index, (key, name, kind, classes) in enumerate(targets): |
| per_class = kind == "class" |
| stats = np.zeros((len(images), len(FIELDS))) |
| for i, im in enumerate(images): |
| if all_present[i] & classes: |
| stats[i] = image_statistics(im, classes, per_class=per_class) |
| else: |
| cache_key = (len(im["sets"]), sum(a["box_eligible"] for a in im["labels"]), len(classes), per_class) |
| if cache_key not in absent_cache: |
| absent_cache[cache_key] = image_statistics(im, classes, per_class=per_class) |
| stats[i] = absent_cache[cache_key] |
| for group_key, indices in selections.items(): |
| q_indices = indices if kind == "overall" else np.array([i for i in indices if images[i]["gold_ids"] & classes], dtype=int) |
| rating = {k: rating_summary(v[q_indices], seed=stable_seed(f"{group_key}:{key}:{k}"), replicates=replicates) for k, v in quality.items()} |
| for k in rating: |
| rating[k]["excluded_images"] = len(q_indices)-rating[k]["eligible"] |
| groups[group_key]["rows"].append({"id": key, "name": name, "kind": kind, |
| "quality_images": len(q_indices), "quality": rating, |
| "agreement": agreement_summary(stats[indices], per_class=per_class, |
| seed=stable_seed(f"{group_key}:{key}:agreement"), replicates=replicates)}) |
| if target_index % 10 == 0: |
| print(f"Completed {target_index+1}/{len(targets)} slices: {key}", flush=True) |
| audits = Counter() |
| for im in images: audits.update(im["audit"]) |
| metadata = {"schema_version": 2, "method_version": METHOD_VERSION, |
| "release": release, |
| "generated_at": datetime.now(timezone.utc).isoformat(), "sources": sources, |
| "bootstrap": {"replicates": replicates, "seed": SEED, "unit": "image", "interval": "95% percentile", "minimum_estimable_fraction": .95}, |
| "quality_alpha": {"primary": "ordinal", "sensitivity": "interval", "ordinal_distances": "sample cumulative category midranks", "bootstrap_distances": "recomputed per resample"}, |
| "semantic": {"cosine_strictly_greater_than": .8, "accepted_off_diagonal_pairs": int((accepted.sum()-len(ids))/2), "expert_validated": False}, |
| "coverage": {"gold": len(gold), "iaa": len(images), "overlap": sum(im["gold"] is not None for im in images), |
| "first_pass_submissions": sum(len(im["labels"]) for im in images), |
| "raters_per_image": dict(sorted(Counter(len(im["labels"]) for im in images).items())), |
| "report_disagreement_images": sum(len({a["reported"] for a in im["labels"]}) > 1 for im in images), |
| "annotation_exclusions": dict(audits)}, |
| "categories": categories, "domains": domains, |
| "limitations": ["First-pass reliability does not prove gold correctness.", |
| "The export does not establish independence from annotation prefill.", |
| "Gold-defined quality slices are overlapping selected populations.", |
| "Semantic relaxation is exploratory and not expert validated.", |
| "Intervals resample images; unrecorded batch dependence is not modelled."]} |
| artifact = {**metadata, "groups": groups} |
| output.parent.mkdir(parents=True, exist_ok=True) |
| output.write_text(json.dumps(artifact, separators=(",", ":"), allow_nan=False) + "\n") |
| evidence_output.parent.mkdir(parents=True, exist_ok=True) |
| evidence_output.write_text(json.dumps({"method_version": METHOD_VERSION, "sources": sources, |
| "images": [public_evidence(im) for im in images]}, separators=(",", ":"), allow_nan=False) + "\n") |
| if report_dir: |
| write_report(artifact, report_dir) |
| return artifact |
|
|
|
|
| def write_report(artifact, directory): |
| directory.mkdir(parents=True, exist_ok=True) |
| (directory / "agreement.json").write_text(json.dumps(artifact, separators=(",", ":"), allow_nan=False)+"\n") |
| with (directory / "agreement.csv").open("w", newline="") as stream: |
| writer = csv.writer(stream) |
| writer.writerow(["population", "source", "slice_kind", "slice_id", "dimension", "metric", "value", "ci_low", "ci_high", "eligible_images", "positive_images", "bootstrap_valid"]) |
| for group in artifact["groups"].values(): |
| for row in group["rows"]: |
| for dim, metrics in [*row["quality"].items(), ("labels_instances", row["agreement"])]: |
| for name, m in metrics.items(): |
| if not isinstance(m, dict) or "value" not in m: continue |
| support = row["agreement"]["support"] |
| eligible = metrics.get("eligible", support["box_n"] if name in ("instance_f1", "semantic_instance_f1", "matched_iou") or name.startswith("iou_") else support["label_n"]) |
| writer.writerow([group["population"], group["source"], row["kind"], row["id"], dim, name, |
| m["value"], *(m["ci"] or [None,None]), eligible, support["positive_images"], m["bootstrap_valid"]]) |
| def val(m): |
| if m["value"] is None: return "Not estimable" |
| ci = "" if m["ci"] is None else f" [{m['ci'][0]:.4f}, {m['ci'][1]:.4f}]" |
| return f"{m['value']:.4f}{ci}" |
| lines = ["# Annotation reliability results", "", f"Method `{METHOD_VERSION}`; generated {artifact['generated_at']}. Values in brackets are 95% image-bootstrap intervals.", "", |
| "## Provenance", "", "| Input | File | SHA-256 |", "|---|---|---|"] |
| lines += [f"| {k} | `{v['filename']}` | `{v['sha256']}` |" for k,v in artifact["sources"].items()] |
| lines += ["", f"Bootstrap: {artifact['bootstrap']['replicates']} image resamples; seed {SEED}. All first-pass annotations remain together. Ordinal distances are recalculated from each selected sample’s category frequencies, including every bootstrap resample. Interval alpha is secondary. Standard alpha uses coincidence weights; descriptive pair counts are normalised within images.", "", |
| "## Overall reliability", "", "| Population | Variable | Images | Exact | Within one | Ordinal alpha (primary) | Interval alpha (sensitivity) |", "|---|---|---:|---|---|---|---|"] |
| for pop in ("all", "gold_linked"): |
| row = artifact["groups"][f"{pop}:all"]["rows"][0] |
| for k,q in row["quality"].items(): |
| lines.append(f"| {pop} | {k} | {q['eligible']} | {val(q['exact'])} | {val(q['within_one'])} | {val(q['alpha'])} | {val(q['interval_alpha'])} |") |
| lines += ["", "| Population | Label images | Unanimous exact sets | Positive-label agreement | Instance F1 | Matched IoU |", "|---|---:|---|---|---|---|"] |
| for pop in ("all", "gold_linked"): |
| a=artifact["groups"][f"{pop}:all"]["rows"][0]["agreement"] |
| lines.append(f"| {pop} | {int(a['support']['label_n'])} | {val(a['exact'])} | {val(a['positive_agreement'])} | {val(a['instance_f1'])} | {val(a['matched_iou'])} |") |
| lines += ["", "## Semantic diagnostic", "", "Exact class agreement is primary. The frozen strict cosine >0.80 policy matches exact labels first; boxes also require IoU >=0.50. This policy has not been expert validated.", "", |
| "| Population | Relaxed positive-label agreement | Relaxed instance F1 |", "|---|---|---|"] |
| for pop in ("all", "gold_linked"): |
| a=artifact["groups"][f"{pop}:all"]["rows"][0]["agreement"] |
| lines.append(f"| {pop} | {val(a['semantic_positive_agreement'])} | {val(a['semantic_instance_f1'])} |") |
| lines += ["", "## Reading the tables", "", "Quality domain/class slices use gold image membership. Class label/box rows consider that class across the full selected eligible population, including omissions. Domain label rows preserve constituent classes. Exact-set agreement includes shared clean labels; positive agreement excludes shared absence from its denominator and is undefined without any positive endpoint. Instance F1 includes one-sided boxes; both-empty comparisons have no spatial score. Matched IoU is conditional on exact-class one-to-one matches.", "", |
| "`agreement.csv` and `agreement.json` contain all source/population/domain/class estimates, support and IoU sensitivity. No individual annotator rankings or source identities are exported. Per-image evidence is written to the configured evidence output.", "", "## Limitations", ""] |
| lines += [f"- {s}" for s in artifact["limitations"]] |
| lines += ["- Fewer than ten eligible or positive-support images is flagged; a narrow interval does not remove sparse-class or prevalence limitations.", "- Constant ratings/presence produce undefined alpha; negative alpha values are retained. These estimates measure agreement and do not independently verify gold correctness.", "", "## Calculation definitions", "", "The [metric-to-value table](../../../docs/reference/metrics.md#which-metric-calculates-each-displayed-value) identifies each displayed value's formula, denominator, weighting and artifact field. Quality percentages use image unanimity/range; quality alpha uses ordinal cumulative-frequency distances and all within-image coincidences; interval alpha is retained as sensitivity; label positive agreement uses pooled binary positive decisions; per-class alpha uses nominal coincidences; instance F1 uses weighted one-to-one match counts; mean IoU is conditional on matches. Annotation instance F1 is distinct from the model benchmark's F2.", ""] |
| (directory / "REPORT.md").write_text("\n".join(lines)) |
|
|
|
|
| def main(): |
| parser=argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--gold", type=Path) |
| parser.add_argument("--iaa", type=Path) |
| parser.add_argument("--manifest", type=Path) |
| parser.add_argument("--domains", type=Path, default=DOMAIN_PATH) |
| parser.add_argument("--policy", type=Path, default=DEFAULT_POLICY) |
| parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) |
| parser.add_argument("--evidence-output", type=Path, default=DEFAULT_EVIDENCE) |
| parser.add_argument("--bootstrap", type=int, default=2000) |
| parser.add_argument("--report-dir", type=Path) |
| args=parser.parse_args() |
| pinned = args.gold is None and args.iaa is None and args.manifest is None |
| paths = release_paths(verify=pinned) |
| gold_path, iaa_path = args.gold or paths["gold"], args.iaa or paths["iaa"] |
| report_dir = args.report_dir or ROOT / "results/dataset_evaluation" / "synthetic11534" / "agreement" |
| build_agreement(gold_path=gold_path, iaa_path=iaa_path, |
| manifest_path=args.manifest or paths["manifest"], domain_path=args.domains, policy_path=args.policy, |
| output=args.output, evidence_output=args.evidence_output, replicates=args.bootstrap, report_dir=report_dir, |
| release=release_identity() if pinned else None) |
| print(f"Wrote {args.output} and {report_dir}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
