| """Independent v4 validator: geometry, PNG recovery, questions, leaks, guards, distributions.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| from collections import Counter |
| from pathlib import Path |
|
|
| from PIL import Image, ImageStat |
|
|
| BG = (26, 26, 26) |
| VERSION = "impossible-object-4.0.0" |
| MIN_CROSSING_SEPARATION = 8.0 |
| MIN_REFERENCE_GAP = 12.0 |
| MIN_LABEL_SEPARATION = 24.0 |
| TARGET_REFERENCE_GAP_TOLERANCE = 1.0 |
| TASKS = {1: "Image Description", 2: "Basic Relational Reasoning", 3: "Comparative Reasoning", 4: "Compound Reasoning", 5: "Extrapolative/Counterfactual Reasoning"} |
|
|
|
|
| def segment_intersection(a, b, c, d): |
| den = (a[0] - b[0]) * (c[1] - d[1]) - (a[1] - b[1]) * (c[0] - d[0]) |
| if abs(den) < 1e-9: return None |
| t = ((a[0] - c[0]) * (c[1] - d[1]) - (a[1] - c[1]) * (c[0] - d[0])) / den |
| u = -((a[0] - b[0]) * (a[1] - c[1]) - (a[1] - b[1]) * (a[0] - c[0])) / den |
| if 1e-7 < t < 1 - 1e-7 and 1e-7 < u < 1 - 1e-7: |
| return [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])] |
| return None |
|
|
|
|
| def recompute_crossings(beams): |
| rows = [] |
| for i, first in enumerate(beams): |
| for second in beams[i + 1:]: |
| point = segment_intersection(first["points"][0], first["points"][1], second["points"][0], second["points"][1]) |
| if point is not None: rows.append((first["beam_label"], second["beam_label"], point)) |
| return rows |
|
|
|
|
| def is_acyclic(labels, constraints, skip=None): |
| graph = {label: [] for label in labels if label != skip}; indegree = {label: 0 for label in labels if label != skip} |
| for front, back in constraints: |
| if front == skip or back == skip: continue |
| graph[front].append(back); indegree[back] += 1 |
| queue = [x for x in graph if indegree[x] == 0]; seen = 0 |
| while queue: |
| node = queue.pop(); seen += 1 |
| for nxt in graph[node]: |
| indegree[nxt] -= 1 |
| if indegree[nxt] == 0: queue.append(nxt) |
| return seen == len(graph) |
|
|
|
|
| def removable_labels(labels, constraints): |
| if is_acyclic(labels, constraints): return [] |
| return [label for label in labels if is_acyclic(labels, constraints, label)] |
|
|
|
|
| def colored(pixel): |
| return max(abs(pixel[k] - BG[k]) for k in range(3)) > 24 |
|
|
|
|
| def recover_badge_count(image): |
| width, height = image.size |
| points = {(x, y) for y in range(height) for x in range(min(70, width)) if colored(image.getpixel((x, y)))} |
| components = [] |
| while points: |
| seed = points.pop(); stack = [seed]; count = 1 |
| while stack: |
| x, y = stack.pop() |
| for dx in (-1, 0, 1): |
| for dy in (-1, 0, 1): |
| nxt = (x + dx, y + dy) |
| if nxt in points: points.remove(nxt); stack.append(nxt); count += 1 |
| if count >= 45: components.append(count) |
| return len(components) |
|
|
|
|
| def direction(points): |
| (x1, y1), (x2, y2) = points; dx, dy = x2 - x1, y2 - y1; length = max(1e-9, math.hypot(dx, dy)); return dx / length, dy / length |
|
|
|
|
| def template_error(image, point, beam_a, beam_b, front_label): |
| candidates = {beam_a["beam_label"]: beam_a, beam_b["beam_label"]: beam_b}; error = 0 |
| for oy in range(-10, 11): |
| for ox in range(-10, 11): |
| if ox * ox + oy * oy > 105: continue |
| actual = colored(image.getpixel((round(point[0] + ox), round(point[1] + oy)))) |
| initial = False |
| for beam in (beam_a, beam_b): |
| dx, dy = direction(beam["points"]); nx, ny = -dy, dx |
| signed = ox * nx + oy * ny |
| if min(abs(signed - 7), abs(signed + 7)) <= 1.25: initial = True |
| predicted = initial and math.hypot(ox, oy) > 11.0 |
| front = candidates[front_label]; dx, dy = direction(front["points"]); nx, ny = -dy, dx |
| along = ox * dx + oy * dy; signed = ox * nx + oy * ny |
| if abs(along) <= 9.0 and min(abs(signed - 7), abs(signed + 7)) <= 1.5: predicted = True |
| if abs(along) <= 9.0 and abs(signed) <= 3.0: predicted = True |
| error += int(actual != predicted) |
| return error |
|
|
|
|
| def recover_png_depth(image, crossing, lookup): |
| a, b = crossing["beam_a"], crossing["beam_b"] |
| ea = template_error(image, crossing["point"], lookup[a], lookup[b], a); eb = template_error(image, crossing["point"], lookup[a], lookup[b], b) |
| if abs(ea - eb) < 3: return None, ea, eb |
| return (a if ea < eb else b), ea, eb |
|
|
|
|
| def percentile(values, q): |
| if not values: return None |
| ordered = sorted(values); pos = (len(ordered) - 1) * q; low = int(math.floor(pos)); high = int(math.ceil(pos)) |
| return ordered[low] if low == high else ordered[low] * (high - pos) + ordered[high] * (pos - low) |
|
|
|
|
| def summary(values): |
| return {"count": len(values), "min": min(values), "p25": percentile(values, .25), "p50": percentile(values, .5), "p75": percentile(values, .75), "p95": percentile(values, .95), "max": max(values)} |
|
|
|
|
| def cramers_v(xs, ys): |
| xvals, yvals = sorted(set(xs)), sorted(set(ys)); xi = {x: i for i, x in enumerate(xvals)}; yi = {y: i for i, y in enumerate(yvals)} |
| table = [[0 for _ in yvals] for _ in xvals] |
| for x, y in zip(xs, ys): table[xi[x]][yi[y]] += 1 |
| n = len(xs); row = [sum(r) for r in table]; col = [sum(table[i][j] for i in range(len(xvals))) for j in range(len(yvals))] |
| chi = 0.0 |
| for i in range(len(xvals)): |
| for j in range(len(yvals)): |
| expected = row[i] * col[j] / n |
| if expected: chi += (table[i][j] - expected) ** 2 / expected |
| denom = min(len(xvals) - 1, len(yvals) - 1) |
| return 0.0 if denom <= 0 else math.sqrt((chi / n) / denom) |
|
|
|
|
| def numeric_bins(values, bins=10): |
| order = sorted(range(len(values)), key=lambda i: (values[i], i)); result = [0] * len(values) |
| for rank, index in enumerate(order): result[index] = min(bins - 1, rank * bins // len(values)) |
| return [str(x) for x in result] |
|
|
|
|
| def leak_audit(records): |
| features = {} |
| for key in records[0]["scene_params"]: |
| raw = [r["scene_params"][key] for r in records] |
| numeric = all(isinstance(x, (int, float)) and not isinstance(x, bool) for x in raw) |
| features[key] = (numeric_bins([float(x) for x in raw]) if numeric and len(set(raw)) > 12 else [str(x) for x in raw], "numeric_deciles" if numeric and len(set(raw)) > 12 else "categorical") |
| answers = {level: [str(r["questions"][level - 1]["ground_truth"]) for r in records] for level in range(1, 6)} |
| whitelist = { |
| 1: {"beam_count": "the stored count named by the answer"}, |
| 2: {"mode": "constructibility class named by the answer"}, |
| 3: {"reference_front_beam": "front beam at the deterministic reference crossing"}, |
| 4: {"target_crossing_count": "the crossing count named by the answer"}, |
| 5: {"mode": "determines already-constructible versus repair", "removable_beam_label": "the unique repair label named by the answer"}, |
| } |
| audit, high = {}, {} |
| for level in range(1, 6): |
| audit[str(level)] = {} |
| for key, (values, kind) in features.items(): |
| value = cramers_v(values, answers[level]); classification = "definitional" if key in whitelist[level] else "non-definitional" |
| item = {"cramers_v": value, "kind": kind, "classification": classification} |
| audit[str(level)][key] = item |
| if value >= .10: high[f"L{level}:{key}"] = item |
| return audit, high, whitelist |
|
|
|
|
| def guard_injections(): |
| def at_least(value, threshold): return value >= threshold - 1e-9 |
| return { |
| "crossing_separation": {"violating": {"value": 7.99, "accepted": at_least(7.99, MIN_CROSSING_SEPARATION)}, "boundary": {"value": 8.0, "accepted": at_least(8.0, MIN_CROSSING_SEPARATION)}}, |
| "reference_distance_gap": {"violating": {"value": 11.99, "accepted": at_least(11.99, MIN_REFERENCE_GAP)}, "boundary": {"value": 12.0, "accepted": at_least(12.0, MIN_REFERENCE_GAP)}}, |
| "beam_label_separation": {"violating": {"value": 23.99, "accepted": at_least(23.99, MIN_LABEL_SEPARATION)}, "boundary": {"value": 24.0, "accepted": at_least(24.0, MIN_LABEL_SEPARATION)}}, |
| "crossing_count_target": {"violating": {"value": 5, "accepted": 5 in (6, 7, 8, 9)}, "boundary": {"value": 6, "accepted": 6 in (6, 7, 8, 9)}}, |
| "unique_removable_beam": {"violating": {"valid_removal_count": 2, "accepted": 2 == 1}, "boundary": {"valid_removal_count": 1, "accepted": 1 == 1}}, |
| "beam_separability": {"violating": {"recovered_labels": 4, "stored_beams": 5, "accepted": 4 == 5}, "boundary": {"recovered_labels": 5, "stored_beams": 5, "accepted": 5 == 5}}, |
| "png_depth_recoverability": {"violating": {"recovered_crossings": 7, "stored_crossings": 8, "accepted": 7 == 8}, "boundary": {"recovered_crossings": 8, "stored_crossings": 8, "accepted": 8 == 8}}, |
| "crossing_target_match": {"violating": {"absolute_error_px": 1.01, "accepted": 1.01 <= 1.0}, "boundary": {"absolute_error_px": 1.0, "accepted": 1.0 <= 1.0}}, |
| "label_target_match": {"violating": {"absolute_error_px": 0.01, "accepted": 0.01 <= 1e-6}, "boundary": {"absolute_error_px": 0.0, "accepted": 0.0 <= 1e-6}}, |
| "reference_gap_target_match": {"violating": {"absolute_error_px": 1.01, "accepted": 1.01 <= TARGET_REFERENCE_GAP_TOLERANCE}, "boundary": {"absolute_error_px": 1.0, "accepted": 1.0 <= TARGET_REFERENCE_GAP_TOLERANCE}}, |
| } |
|
|
|
|
| def read_csv(path): |
| with path.open("r", encoding="utf-8-sig", newline="") as handle: return list(csv.DictReader(handle)) |
|
|
|
|
| def table_issues(root, records): |
| public, private, final = read_csv(root / "question_set.csv"), read_csv(root / "answer_key.csv"), read_csv(root / "dataset_final.csv") |
| pairs = [(row, q) for row in records for q in row["questions"]]; issues = [] |
| if not len(public) == len(private) == len(final) == len(pairs): return ["flattened table row count"] |
| permitted_public_fields = ["question_id", "task", "image", "prompt"] |
| if public and list(public[0].keys()) != permitted_public_fields: issues.append(f"question_set schema must be exactly {permitted_public_fields}") |
| for index, ((row, q), pub, ans, flat) in enumerate(zip(pairs, public, private, final), 1): |
| base = {"question_id": q["question_id"], "task": TASKS[q["difficulty_level"]], "image": Path(row["image_path"]).name, "prompt": q["question_text"]} |
| if any(pub.get(k) != v for k, v in base.items()): issues.append(f"public row {index}") |
| if any(ans.get(k) != v for k, v in base.items()) or ans.get("groundtruth") != str(q["ground_truth"]) or ans.get("answer_format") != q["answer_format"]: issues.append(f"answer row {index}") |
| if flat.get("groundtruth") != str(q["ground_truth"]): issues.append(f"final row {index}") |
| return issues |
|
|
|
|
| def validate(root): |
| root = Path(root); records = [json.loads(x) for x in (root / "annotations.jsonl").read_text(encoding="utf-8").splitlines() if x] |
| issues = []; distributions = {level: Counter() for level in range(1, 6)}; png_beams = png_crossings = png_depth = 0; continuous = {}; categorical = {} |
| for position, row in enumerate(records, 1): |
| iid = row["id"] |
| try: |
| if row.get("dataset_version") != VERSION: issues.append(f"{iid}: version") |
| beams = row["beams"]; lookup = {x["beam_label"]: x for x in beams}; labels = sorted(lookup); recomputed = recompute_crossings(beams) |
| if len(labels) != row["num_beams"] or len(recomputed) != row["num_crossings"]: issues.append(f"{iid}: geometry counts") |
| stored_pairs = {frozenset((x["beam_a"], x["beam_b"])): x for x in row["crossings"]} |
| for a, b, point in recomputed: |
| stored = stored_pairs.get(frozenset((a, b))) |
| if stored is None or math.dist(point, stored["point"]) > .01: issues.append(f"{iid}: crossing geometry {a}/{b}") |
| points = [x["point"] for x in row["crossings"]] |
| separation = min(math.dist(a, b) for i, a in enumerate(points) for b in points[i + 1:]) |
| if separation + 1e-6 < MIN_CROSSING_SEPARATION: issues.append(f"{iid}: crossing separation") |
| center = [row["canvas_size"][0] / 2, row["canvas_size"][1] / 2]; ordered = sorted((math.dist(x["point"], center), x) for x in row["crossings"]); ref_gap = ordered[1][0] - ordered[0][0] |
| if ref_gap + 1e-6 < MIN_REFERENCE_GAP or ordered[0][1]["crossing_id"] != row["reference_crossing_id"]: issues.append(f"{iid}: reference crossing") |
| target_ref_gap = row["scene_params"]["target_reference_distance_gap_px"] |
| if abs(ref_gap - target_ref_gap) > TARGET_REFERENCE_GAP_TOLERANCE + 1e-6: issues.append(f"{iid}: reference-gap target") |
| constraints = [(x["front_beam"], x["back_beam"]) for x in row["depth_constraints"]] |
| if any(set(x) - {"crossing_id", "front_beam", "back_beam"} for x in row["depth_constraints"]): issues.append(f"{iid}: constraint schema") |
| possible = is_acyclic(labels, constraints); removals = removable_labels(labels, constraints) |
| expected_mode = "possible" if possible else "impossible" |
| if expected_mode != row["mode"]: issues.append(f"{iid}: constructibility") |
| if expected_mode == "impossible" and len(removals) != 1: issues.append(f"{iid}: unique repair") |
| expected_removable = None if expected_mode == "possible" else removals[0] |
| if row.get("removable_beam_label") != expected_removable or row["scene_params"].get("removable_beam_label") != expected_removable: issues.append(f"{iid}: removable beam field") |
| forbidden = {"generation_attempt", "png_recovery_retry", "visibility_variant"} |
| if forbidden & set(row): issues.append(f"{iid}: private diagnostic/answer field at top level") |
| if forbidden & set(row["scene_params"]): issues.append(f"{iid}: private diagnostic/answer field in scene_params") |
| image_path = root / row["image_path"] |
| if not image_path.exists(): issues.append(f"{iid}: missing PNG"); continue |
| with Image.open(image_path) as source: image = source.convert("RGB"); image.load() |
| if image.size != tuple(row["canvas_size"]) or sum(ImageStat.Stat(image).var) < 100: issues.append(f"{iid}: PNG basics") |
| recovered_beams = recover_badge_count(image) |
| if recovered_beams == row["num_beams"]: png_beams += 1 |
| else: issues.append(f"{iid}: PNG beam count {recovered_beams}/{row['num_beams']}") |
| recovered_constraints = []; recovered_here = 0 |
| for crossing in row["crossings"]: |
| front, score_a, score_b = recover_png_depth(image, crossing, lookup) |
| if front is not None: recovered_here += 1 |
| if front != crossing["front_beam"]: issues.append(f"{iid}: PNG depth {crossing['crossing_id']} scores={score_a}/{score_b}") |
| else: recovered_constraints.append((front, crossing["back_beam"])) |
| if recovered_here == row["num_crossings"]: png_crossings += 1 |
| if len(recovered_constraints) == row["num_crossings"]: png_depth += 1 |
| rendered_possible = is_acyclic(labels, recovered_constraints) if len(recovered_constraints) == row["num_crossings"] else None |
| if rendered_possible is not None and rendered_possible != possible: issues.append(f"{iid}: rendered constructibility") |
| q_expected = [str(row["num_beams"]), "yes" if possible else "no", ordered[0][1]["front_beam"], str(row["num_crossings"]), "already constructible" if possible else removals[0]] |
| if len(row["questions"]) != 5 or [q["difficulty_level"] for q in row["questions"]] != [1, 2, 3, 4, 5]: issues.append(f"{iid}: question schema") |
| else: |
| for level, (q, expected) in enumerate(zip(row["questions"], q_expected), 1): |
| distributions[level][str(q["ground_truth"])] += 1 |
| if str(q["ground_truth"]) != expected: issues.append(f"{q['question_id']}: answer") |
| except Exception as exc: issues.append(f"{iid}: exception {exc}") |
| if position % 500 == 0: print(f"Validated {position}/{len(records)}", flush=True) |
| issues.extend(table_issues(root, records)) |
| for key in records[0]["scene_params"]: |
| values = [r["scene_params"][key] for r in records] |
| if all(isinstance(x, (int, float)) and not isinstance(x, bool) for x in values): continuous[key] = summary([float(x) for x in values]) |
| else: categorical[key] = dict(Counter(str(x) for x in values)) |
| baselines = {str(level): {"answer": dist.most_common(1)[0][0], "count": dist.most_common(1)[0][1], "accuracy": dist.most_common(1)[0][1] / len(records)} for level, dist in distributions.items()} |
| audit, high, whitelist = leak_audit(records); injections = guard_injections() |
| if not all(not item["violating"]["accepted"] and item["boundary"]["accepted"] for item in injections.values()): issues.append("guard injection failure") |
| def split_summary(field, split_field): |
| result = {} |
| for split in sorted({str(r["scene_params"][split_field]) for r in records}): |
| values = [float(r["scene_params"][field]) for r in records if str(r["scene_params"][split_field]) == split] |
| result[split] = summary(values) |
| return result |
| separation_splits = {"label_by_beam_count": split_summary("minimum_label_separation_px", "beam_count"), "crossing_by_beam_count": split_summary("minimum_crossing_separation_px", "beam_count"), "crossing_by_crossing_count": split_summary("minimum_crossing_separation_px", "target_crossing_count"), "reference_gap_by_beam_count": split_summary("reference_distance_gap_px", "beam_count"), "reference_gap_by_crossing_count": split_summary("reference_distance_gap_px", "target_crossing_count"), "reference_gap_by_mode": split_summary("reference_distance_gap_px", "mode")} |
| public_rows = read_csv(root / "question_set.csv"); private_rows = read_csv(root / "answer_key.csv") |
| field_listing = {"annotations_jsonl_top_level": sorted(records[0].keys()), "annotations_jsonl_scene_params": sorted(records[0]["scene_params"].keys()), "annotations_jsonl_question_object": sorted(records[0]["questions"][0].keys()), "question_set_csv": list(public_rows[0].keys()), "answer_key_csv": list(private_rows[0].keys())} |
| diagnostics_path = root / "_generation_diagnostics.json" |
| generation_diagnostics = json.loads(diagnostics_path.read_text(encoding="utf-8")) |
| metrics = {"dataset_version": VERSION, "images_checked": len(records), "questions_checked": len(records) * 5, "mismatches": len(issues), "png_recovery": {"beam_count": png_beams, "crossing_count": png_crossings, "depth_order": png_depth}, "answer_distributions": {str(k): dict(v) for k, v in distributions.items()}, "constant_answer_baselines": baselines, "depth_constraint_representation": "directed beam-label front/back relation per projected crossing", "leak_audit": audit, "features_at_v_ge_0_10": high, "definitional_whitelist": {str(k): v for k, v in whitelist.items()}, "guard_injection_tests": injections, "separation_distributions": separation_splits, "field_listing": field_listing, "generation_diagnostics": {"generation_attempts": generation_diagnostics["generation_attempts"], "generation_attempts_by_configuration": generation_diagnostics["generation_attempts_by_configuration"], "png_recovery_retry_distribution": generation_diagnostics["png_recovery_retry_distribution"]}, "continuous_distributions": continuous, "categorical_distributions": categorical, "issues": issues} |
| (root / "validation_metrics.json").write_text(json.dumps(metrics, indent=2) + "\n", encoding="utf-8") |
| lines = ["Impossible Object Dataset v4 Validation Report", "=" * 48, f"Dataset version: {VERSION}", f"Total images checked: {len(records)}", f"Total questions checked: {len(records) * 5}", f"Total mismatches found: {len(issues)}", "", "Depth constraints: directed beam-label front/back relation per projected crossing", "", "PNG recovery:", f" beam count: {png_beams}/{len(records)}", f" crossing count: {png_crossings}/{len(records)}", f" per-crossing depth order: {png_depth}/{len(records)}", "", "Per-level distributions and best constant baselines:"] |
| for level in range(1, 6): lines += [f" L{level}: {dict(distributions[level])}", f" baseline: {baselines[str(level)]}"] |
| lines += ["", "Features at Cramer's V >= 0.10 (none hidden):"] + [f" {key}: {value}" for key, value in high.items()] + ["", "Definitional whitelist:"] + [f" L{level}: {values}" for level, values in whitelist.items()] + ["", "Separation distributions:"] + [f" {key}: {value}" for key, value in separation_splits.items()] + ["", "Released field listing:"] + [f" {key}: {value}" for key, value in field_listing.items()] + ["", "Private build diagnostics:", f" generation attempts: {generation_diagnostics['generation_attempts']}", f" attempts by configuration: {generation_diagnostics['generation_attempts_by_configuration']}", f" PNG recovery retries: {generation_diagnostics['png_recovery_retry_distribution']}", "", "Guard injection tests:"] + [f" {key}: {value}" for key, value in injections.items()] + ["", "Continuous distributions:"] + [f" {key}: {value}" for key, value in continuous.items()] + ["", "Categorical distributions:"] + [f" {key}: {value}" for key, value in categorical.items()] + ["", "Issues:"] + ([f" {x}" for x in issues] if issues else [" None"]) + ["", f"Summary: {'PASS' if not issues else 'FAIL'}"] |
| (root / "validation_report.txt").write_text("\n".join(lines) + "\n", encoding="utf-8") |
| if not issues: |
| diagnostics_path.unlink() |
| legacy_stats = root / "generation_stats.json" |
| if legacy_stats.exists(): |
| legacy_stats.unlink() |
| print("\n".join(lines[:35])); print(f"Summary: {'PASS' if not issues else 'FAIL'}") |
| return len(issues) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(); parser.add_argument("root", nargs="?", type=Path, default=Path(__file__).resolve().parent); args = parser.parse_args(); raise SystemExit(1 if validate(args.root) else 0) |
|
|
|
|
| if __name__ == "__main__": main() |
|
|
