"""Build dataset evaluation from explicitly pinned release inputs.""" from __future__ import annotations from utils.paths import PROJECT_ROOT from utils.io import sha256_file as _sha256 import json from collections import Counter from datetime import datetime, timezone from pathlib import Path from utils.dataset import resolve_local_images from statistics import mean, median from scripts.datasets.dataset_quality import build_quality_slices from utils.release import release_config, release_identity, release_paths, validate_population ROOT = PROJECT_ROOT FULL_DATASET = ROOT / "data" / "full_dataset" MANIFEST_PATH = FULL_DATASET / "dataset_manifest.jsonl" GOLD_DIR = FULL_DATASET / "ground_truth" / "gold" IAA_DIR = FULL_DATASET / "ground_truth" / "iaa" IMAGE_DIR = FULL_DATASET / "images" DOMAIN_PATH = ROOT / "data" / "violation_domains.json" DEFAULT_OUTPUT = ROOT / "frontend" / ".generated" / "dataset_eda.json" def _latest(directory: Path, pattern: str) -> Path: candidates = sorted(directory.glob(pattern)) if not candidates: raise FileNotFoundError(f"No {pattern} exports found in {directory}") return candidates[-1] def _source(path: Path, records: int) -> dict: return {"filename": path.name, "records": records, "sha256": _sha256(path)} def _valid_bbox(bbox: object) -> bool: if not isinstance(bbox, list) or len(bbox) != 4 or not all(isinstance(value, (int, float)) for value in bbox): return False x, y, width, height = bbox return width > 0 and height > 0 and x >= 0 and y >= 0 and x + width <= 1 and y + height <= 1 def _rating(values: list[int | None]) -> dict: clean = [value for value in values if value is not None] counts = Counter(clean) return { "eligible": len(clean), "missing": len(values) - len(clean), "counts": {str(score): counts[score] for score in range(1, 6)}, "mean": round(mean(clean), 3) if clean else None, "median": median(clean) if clean else None, "low": sum(value <= 2 for value in clean), "high": sum(value >= 4 for value in clean), } def _distribution(values: list[str], order: list[str] | None = None) -> list[dict]: counts = Counter(values) keys = order or sorted(counts) return [{"name": key, "count": counts[key]} for key in keys] def summarize_gold(records: list[dict], domains: list[dict]) -> dict: domain_ids = {item["name"]: set(item["ids"]) for item in domains} image_classes = [set(item["use_case_id"] for item in row["violations"]) for row in records] instance_counts = Counter( item["use_case_id"] for row in records for item in row["violations"] ) image_counts = Counter(use_case_id for values in image_classes for use_case_id in values) class_names = {} for row in records: for item in row["violations"]: class_names.setdefault(item["use_case_id"], item["name"]) violations = [] for domain in domains: for use_case_id in domain["ids"]: violations.append({ "id": use_case_id, "name": class_names.get(use_case_id, f"Violation {use_case_id}"), "domain": domain["name"], "images": image_counts[use_case_id], "instances": instance_counts[use_case_id], "represented": image_counts[use_case_id] > 0, }) domain_rows = [] for name, ids in domain_ids.items(): domain_rows.append({ "name": name, "class_count": len(ids), "represented_classes": sum(image_counts[use_case_id] > 0 for use_case_id in ids), "images": sum(bool(values & ids) for values in image_classes), "instances": sum(instance_counts[use_case_id] for use_case_id in ids), }) return { "records": len(records), "categories": _distribution([row["category"] for row in records]), "gold_kinds": _distribution([row["kind"] for row in records]), "gold_methods": _distribution([row.get("method", row["kind"]) for row in records]), "label_states": [ {"name": "Violation present", "count": sum(bool(row["violations"]) for row in records)}, {"name": "No violation", "count": sum(row["no_violation_detected"] for row in records)}, {"name": "Reported / unusable", "count": sum(row["reported"] for row in records)}, ], "plausibility": _rating([row["plausibility"] for row in records]), "naturalness": _rating([row["naturalness"] for row in records]), "domains": domain_rows, "violations": violations, "violation_instances": sum(instance_counts.values()), "represented_classes": sum(item["represented"] for item in violations), } def _agreement_summary(records: list[dict]) -> dict: def values(key: str) -> list[float]: return [row["agreement"][key] for row in records if row["agreement"].get(key) is not None] plausibility = values("plausibility_delta") naturalness = values("naturalness_delta") jaccard = values("violation_jaccard") bbox = values("mean_bbox_iou") scores = values("disagreement_score") return { "records": len(records), "first_pass_submissions": sum(row["n_first_pass"] for row in records), "plausibility": { "eligible": len(plausibility), "exact": sum(value == 0 for value in plausibility), "within_one": sum(value <= 1 for value in plausibility), "counts": {str(delta): sum(value == delta for value in plausibility) for delta in range(5)}, }, "naturalness": { "eligible": len(naturalness), "exact": sum(value == 0 for value in naturalness), "within_one": sum(value <= 1 for value in naturalness), "counts": {str(delta): sum(value == delta for value in naturalness) for delta in range(5)}, }, "violation_jaccard": { "eligible": len(jaccard), "exact": sum(value == 1 for value in jaccard), "none": sum(value == 0 for value in jaccard), "partial": sum(0 < value < 1 for value in jaccard), "mean": round(mean(jaccard), 3) if jaccard else None, }, "bbox_iou": { "eligible": len(bbox), "mean": round(mean(bbox), 3) if bbox else None, "median": round(median(bbox), 3) if bbox else None, "at_least_50": sum(value >= 0.50 for value in bbox), "at_least_75": sum(value >= 0.75 for value in bbox), }, "reported_mismatches": sum(bool(row["agreement"].get("reported_mismatch")) for row in records), "disagreement_score": { "eligible": len(scores), "mean": round(mean(scores), 3) if scores else None, "median": round(median(scores), 3) if scores else None, "maximum": max(scores) if scores else None, }, } def _timeline(iaa_records: list[dict], gold_records: list[dict]) -> list[dict]: iaa_dates = Counter(row["completed_at"] for row in iaa_records if row["completed_at"]) gold_dates = Counter(row["adjudicated_at"] for row in gold_records if row["adjudicated_at"]) dates = sorted(set(iaa_dates) | set(gold_dates)) rows, iaa_total, gold_total = [], 0, 0 for date in dates: iaa_total += iaa_dates[date] gold_total += gold_dates[date] rows.append({"date": date, "iaa": iaa_total, "gold": gold_total}) return rows def build_dataset_eda(output: Path = DEFAULT_OUTPUT, *, gold_path: Path | None = None, iaa_path: Path | None = None, manifest_path: Path | None = None) -> dict: pinned = gold_path is None and iaa_path is None and manifest_path is None paths = release_paths(verify=pinned) gold_path = gold_path or paths["gold"] iaa_path = iaa_path or paths["iaa"] manifest_path = manifest_path or paths["manifest"] manifest = [json.loads(line) for line in manifest_path.open(encoding="utf-8")] if len({row["image_id"] for row in manifest}) != len(manifest): raise ValueError("Full-dataset manifest contains duplicate image IDs") manifest_by_id = {row["image_id"]: row for row in manifest} domains_payload = json.loads(DOMAIN_PATH.read_text(encoding="utf-8")) domains = [{"name": name, "ids": ids} for name, ids in domains_payload.items()] domain_by_id = {use_case_id: name for name, ids in domains_payload.items() for use_case_id in ids} local_images = resolve_local_images(manifest, IMAGE_DIR) gold_source = json.loads(gold_path.read_text(encoding="utf-8")) if not isinstance(gold_source, list) or len({row["image_id"] for row in gold_source}) != len(gold_source): raise ValueError("Gold export must be an array with unique image IDs") invalid_gold_boxes = 0 gold_records = [] for record in gold_source: gold = record["gold"] for item in gold.get("violations", []): invalid_gold_boxes += int(not _valid_bbox(item.get("bbox"))) gold_records.append({ "image_id": record["image_id"], "category": manifest_by_id.get(record["image_id"], {}).get("category", "unmapped"), "kind": record["kind"], "method": record.get("edit_summary", {}).get("resolution", {}).get("method_id", record["kind"]), "adjudicated_at": (record.get("adjudicated_at") or "")[:10] or None, "plausibility": gold.get("plausibility"), "naturalness": gold.get("naturalness"), "no_violation_detected": bool(gold.get("no_violation_detected")), "reported": bool(gold.get("reported", False)), "violations": [{ "use_case_id": item["use_case_id"], "name": item.get("use_case_name", f"Violation {item['use_case_id']}"), "domain": domain_by_id.get(item["use_case_id"], "Unmapped"), "bbox": item.get("bbox") if _valid_bbox(item.get("bbox")) else None, } for item in gold.get("violations", [])], }) raw_iaa = json.loads(iaa_path.read_text(encoding="utf-8")) if pinned: validate_population(gold_source, raw_iaa, manifest, release_config()["expected"]) if not isinstance(raw_iaa, list) or len({row["image_id"] for row in raw_iaa}) != len(raw_iaa): raise ValueError("IAA export must be an array with unique image IDs") iaa_records = [] invalid_iaa_boxes = 0 for row in raw_iaa: labels = [] completed = [] for index, label in enumerate(row.get("first_pass", [])): submitted_at = label.get("submitted_at") if submitted_at: completed.append(submitted_at[:10]) violations = [] for item in label.get("violations", []): if not _valid_bbox(item.get("bbox")): invalid_iaa_boxes += 1 continue violations.append({ "use_case_id": item["use_case_id"], "name": item.get("use_case_name", f"Violation {item['use_case_id']}"), "bbox": item["bbox"], }) labels.append({ "label": f"Label {chr(65 + index)}", "plausibility": label.get("plausibility"), "naturalness": label.get("naturalness"), "no_violation_detected": bool(label.get("no_violation_detected")), "reported": bool(label.get("reported", False)), "violations": violations, }) agreement = { key: row.get("agreement", {}).get(key) for key in ("plausibility_delta", "naturalness_delta", "violation_jaccard", "mean_bbox_iou", "reported_mismatch", "disagreement_score") } iaa_records.append({ "image_id": row["image_id"], "category": manifest_by_id.get(row["image_id"], {}).get("category", "unmapped"), "l2_code": row.get("l2_code"), "n_first_pass": len(labels), "completed_at": max(completed) if completed else None, "agreement": agreement, "labels": labels, "image_available": row["image_id"] in local_images, }) manifest_categories = _distribution([row.get("category", "unmapped") for row in manifest]) artifact = { "schema_version": 1, "generated_at": datetime.now(timezone.utc).isoformat(), "release": release_identity() if pinned else None, "sources": { "manifest": _source(manifest_path, len(manifest)), "gold": _source(gold_path, len(gold_records)), "iaa": _source(iaa_path, len(iaa_records)), }, "progress": { "target_images": len(manifest), "iaa_ready_images": len(iaa_records), "gold_ready_images": len(gold_records), "local_images": len(local_images), "gold_in_iaa": len({row["image_id"] for row in gold_records} & {row["image_id"] for row in iaa_records}), "timeline": _timeline(iaa_records, gold_records), }, "manifest_categories": manifest_categories, "domains": domains, "gold_summary": summarize_gold(gold_records, domains), "iaa_summary": _agreement_summary(iaa_records), "quality_audit": { "invalid_gold_boxes": invalid_gold_boxes, "invalid_iaa_boxes": invalid_iaa_boxes, "gold_missing_manifest": sum(row["category"] == "unmapped" for row in gold_records), "iaa_missing_manifest": sum(row["category"] == "unmapped" for row in iaa_records), }, "filter_options": { "categories": [row["name"] for row in manifest_categories if row["count"]], "gold_kinds": sorted({row["kind"] for row in gold_records}), }, "gold_records": gold_records, "iaa_records": iaa_records, } output.parent.mkdir(parents=True, exist_ok=True) artifact["quality_slices"] = build_quality_slices(gold_records, domains, artifact["gold_summary"]["violations"]) output.write_text(json.dumps(artifact, indent=2), encoding="utf-8") return artifact def main() -> None: import argparse parser = argparse.ArgumentParser() parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) parser.add_argument("--gold", type=Path) parser.add_argument("--iaa", type=Path) parser.add_argument("--manifest", type=Path) args = parser.parse_args() artifact = build_dataset_eda(args.output, gold_path=args.gold, iaa_path=args.iaa, manifest_path=args.manifest) print( f"Wrote {args.output} from {artifact['sources']['gold']['filename']} and " f"{artifact['sources']['iaa']['filename']}" ) if __name__ == "__main__": main()