| """Check official split counts, every referenced image, and sampled JPEG decoding.""" |
| from pathlib import Path |
| import collections |
| import csv |
| import hashlib |
| import json |
| import os |
| import sys |
| import time |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT / "code/vendor")) |
| import ijson |
| from PIL import Image |
|
|
| EXPECTED = {"train": 1361062, "val": 380125, "test": 849160} |
|
|
|
|
| def main(): |
| parts = json.loads((ROOT / "audit/image_parts_verified.json").read_text()) |
| annotations = json.loads((ROOT / "audit/annotations_verification.json").read_text()) |
| extraction = json.loads((ROOT / "audit/images_extraction.json").read_text()) |
| assert parts["complete"] and len(parts["verified"]) == 44 |
| assert annotations["complete"] and len(annotations["verified"]) == 14 |
| assert extraction["status"] == "complete" |
| rows, errors = [], [] |
| for split, expected in EXPECTED.items(): |
| count = missing = zero = decoded = mismatched = 0 |
| annotated_captures, subjects, cameras, sequences = set(), set(), set(), set() |
| source = ROOT / "annotations" / split / f"InterHand2.6M_{split}_data.json" |
| sample_every = max(1, expected // 128) |
| with source.open("rb") as f: |
| for item in ijson.items(f, "images.item"): |
| path = ROOT / "images" / split / item["file_name"] |
| count += 1 |
| annotated_captures.add(item["capture"]) |
| subjects.add(item["subject"]) |
| cameras.add(item["camera"]) |
| sequences.add((item["capture"], item["seq_name"])) |
| try: |
| size = path.stat().st_size |
| except FileNotFoundError: |
| missing += 1 |
| if len(errors) < 100: |
| errors.append({"type": "missing_image", "path": str(path)}) |
| continue |
| if size == 0: |
| zero += 1 |
| if (count - 1) % sample_every == 0: |
| try: |
| with Image.open(path) as image: |
| image.load() |
| if image.size != (item["width"], item["height"]): |
| mismatched += 1 |
| errors.append({"type": "image_dimension_mismatch", "path": str(path)}) |
| decoded += 1 |
| except Exception as exc: |
| errors.append({"type": "image_decode_failure", "path": str(path), "error": str(exc)}) |
| row = {"split": split, "official_expected_images": expected, "annotation_images": count, |
| "missing_referenced_images": missing, "empty_referenced_images": zero, |
| "jpeg_samples_decoded": decoded, "sample_dimension_mismatches": mismatched, |
| "annotated_captures": len(annotated_captures), "subjects": len(subjects), |
| "camera_ids": len(cameras), "capture_sequence_pairs": len(sequences)} |
| rows.append(row) |
| print("CHECKED", json.dumps(row), flush=True) |
| if count != expected: |
| errors.append({"type": "unexpected_split_count", "split": split, "count": count}) |
| |
| raw_counts = collections.Counter() |
| raw_bytes = 0 |
| for split in EXPECTED: |
| for base, dirs, files in os.walk(ROOT / "images" / split): |
| for name in files: |
| if name.lower().endswith((".jpg", ".jpeg", ".png")): |
| raw_counts[split] += 1 |
| raw_bytes += (Path(base) / name).stat().st_size |
| for row in rows: |
| row["extracted_image_files"] = raw_counts[row["split"]] |
| with (ROOT / "audit/split_inventory.csv").open("w") as f: |
| writer = csv.DictWriter(f, fieldnames=list(rows[0])) |
| writer.writeheader() |
| writer.writerows(rows) |
| |
| lines = [] |
| for entry in parts["verified"]: |
| lines.append(entry["sha256"] + " archives/5fps/" + entry["name"]) |
| for entry in annotations["verified"]: |
| lines.append(entry["sha256"] + " " + entry["local_path"]) |
| supplementary_path = ROOT / "audit/human_annotation_ids.json" |
| if supplementary_path.exists(): |
| for entry in json.loads(supplementary_path.read_text()): |
| lines.append(entry["sha256"] + " " + entry["local_path"]) |
| for folder in ["sources", "code"]: |
| for path in sorted((ROOT / folder).iterdir()): |
| if path.is_file(): |
| lines.append(hashlib.sha256(path.read_bytes()).hexdigest() + " " + str(path.relative_to(ROOT))) |
| (ROOT / "audit/SHA256SUMS").write_text("\n".join(lines) + "\n") |
| missing_total = sum(row["missing_referenced_images"] for row in rows) |
| empty_total = sum(row["empty_referenced_images"] for row in rows) |
| report = {"status": "PASS" if not errors and not missing_total and not empty_total else "FAIL", |
| "dataset": "InterHand2.6M", "version": "v1.0", "fps": 5, |
| "host": os.uname().nodename, "root": str(ROOT), "checked_unix": time.time(), |
| "official_md5_parts_verified": len(parts["verified"]), |
| "annotation_files_validated": len(annotations["verified"]), |
| "referenced_images_checked": sum(row["annotation_images"] for row in rows), |
| "extracted_image_files": sum(raw_counts.values()), "extracted_image_bytes": raw_bytes, |
| "image_archive_bytes": sum(x["bytes"] for x in parts["verified"]), |
| "splits": rows, "errors": errors, |
| "scope": "Full official v1.0 5 fps train/val/test with current official annotations; excludes 30 fps expansion.", |
| "note": "File integrity and annotation/image correspondence checks are not a GT-accuracy certification."} |
| (ROOT / "audit/final_validation.json").write_text(json.dumps(report, indent=2) + "\n") |
| print("FINAL", report["status"], flush=True) |
| if report["status"] != "PASS": |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
