""" check_dataset.py Validate that ACWMPhysicalDataset (physical_dataset_acwm.py) loads correctly from a cases_200_full.json produced by subset_200.py. Checks, per sample: - all referenced files exist (images + physical npy), reporting the FIRST missing path per sample - the sample actually loads through __getitem__ without throwing - video is 17 PIL frames at the right size - actions is (16, 7), finite - phys_gt is (C, 17, H, W) with C matching modality, finite - reports value ranges (min/max/mean) so you can eyeball normalization It does a fast existence pre-scan over ALL samples first (cheap, no decode), then fully loads a few samples (decode images + npy) to catch loader bugs. Usage: python check_dataset.py \ --metadata cases_200_full.json \ --source_root /net/.../sycen/ \ --stats /path/to/physical_stats.json \ --modality contact \ --n_full 5 """ import argparse import json import os import sys import numpy as np def pre_scan_existence(meta_path, source_root, modality): """Cheap pass: just check every referenced file exists. No decoding.""" obj = json.load(open(meta_path)) samples = obj["samples"] if isinstance(obj, dict) and "samples" in obj else obj print(f"[scan] {len(samples)} samples in {meta_path}") def absp(p): return p if os.path.isabs(p) else os.path.join(source_root, p) img_keys_obs = ["observation_frame", "observation"] phys_obs_key = ("observation_contact_path" if modality == "contact" else "observation_force_path") phys_fut_key = "contact_path" if modality == "contact" else "force_path" n_ok = 0 bad = [] # (sample_idx, missing_path) n_missing_files = 0 for i, s in enumerate(samples): paths = [] # obs image obs_img = next((s[k] for k in img_keys_obs if k in s), None) if obs_img is None: bad.append((i, "")); continue paths.append(obs_img) # future images paths += list(s.get("frames", [])) # physical if phys_obs_key in s: paths.append(s[phys_obs_key]) else: bad.append((i, f"")); continue paths += list(s.get(phys_fut_key, [])) # frame-count sanity n_img = 1 + len(s.get("frames", [])) n_phys = 1 + len(s.get(phys_fut_key, [])) if n_img != 17 or n_phys != 17: bad.append((i, f"")) continue first_missing = None for p in paths: if not os.path.exists(absp(p)): first_missing = p n_missing_files += 1 break if first_missing is None: n_ok += 1 else: bad.append((i, first_missing)) print(f"[scan] samples fully present: {n_ok}/{len(samples)}") if bad: print(f"[scan] {len(bad)} samples with a problem (showing first 20):") for idx, why in bad[:20]: print(f" sample {idx}: {why}") if len(bad) > 20: print(f" ... +{len(bad)-20} more") return samples, bad def full_load(meta_path, source_root, stats_path, modality, height, width, n_full): """Actually construct the dataset and pull n_full items end-to-end.""" # import the user's dataset try: from physical_dataset_acwm import ACWMPhysicalDataset except Exception as e: print(f"[load] could not import ACWMPhysicalDataset: {e}") print(" run this from the dir containing physical_dataset_acwm.py " "or add it to PYTHONPATH.") return ds = ACWMPhysicalDataset( metadata_path=meta_path, source_root=source_root, stats_path=stats_path, modality=modality, height=height, width=width, ) print(f"\n[load] dataset len = {len(ds)}") expect_ch = 2 if modality == "contact" else 6 k = min(n_full, len(ds)) for i in range(k): try: d = ds[i] except Exception as e: print(f"[load] sample {i} FAILED in __getitem__: {type(e).__name__}: {e}") continue vid = d["video"] act = d["actions"] phys = d["phys_gt"] problems = [] if not (isinstance(vid, list) and len(vid) == 17): problems.append(f"video len {len(vid) if hasattr(vid,'__len__') else '?'} != 17") else: if vid[0].size != (width, height): problems.append(f"frame size {vid[0].size} != {(width, height)}") if tuple(act.shape) != (16, 7): problems.append(f"actions {tuple(act.shape)} != (16,7)") if not np.isfinite(act.numpy()).all(): problems.append("actions has NaN/Inf") if tuple(phys.shape) != (expect_ch, 17, height, width): problems.append(f"phys_gt {tuple(phys.shape)} != {(expect_ch,17,height,width)}") if not np.isfinite(phys.numpy()).all(): problems.append("phys_gt has NaN/Inf") tag = "OK" if not problems else "PROBLEM" print(f"\n[load] sample {i}: {tag}") print(f" video: {len(vid)} frames @ {vid[0].size}") print(f" actions {tuple(act.shape)} range [{act.min():.4f}, {act.max():.4f}]") print(f" phys_gt {tuple(phys.shape)} " f"range [{phys.min():.4f}, {phys.max():.4f}] mean {phys.float().mean():.4f} " f"nonzero {100*(phys!=0).float().mean():.2f}%") for pb in problems: print(f" !! {pb}") def main(): ap = argparse.ArgumentParser() ap.add_argument("--metadata", required=True, help="cases_200_full.json") ap.add_argument("--source_root", required=True) ap.add_argument("--stats", default=None, help="physical stats json (optional). Not needed for " "--scan_only. If omitted during full load, identity " "scale (1.0) is used so shapes still validate, but the " "printed phys_gt ranges are un-normalized.") ap.add_argument("--modality", choices=["contact", "force"], default="contact") ap.add_argument("--height", type=int, default=480) ap.add_argument("--width", type=int, default=640) ap.add_argument("--n_full", type=int, default=5, help="how many samples to fully decode/load end-to-end") ap.add_argument("--scan_only", action="store_true", help="only check file existence, skip full load") args = ap.parse_args() samples, bad = pre_scan_existence(args.metadata, args.source_root, args.modality) if args.scan_only: return if len(samples) == len(bad): print("\n[stop] every sample has a missing file/key; not attempting full load.") print(" check --source_root: paths in the json are relative to it.") return stats_path = args.stats tmp_stats = None if stats_path is None: # identity stats so the dataset still constructs & shapes validate import tempfile ch = 2 if args.modality == "contact" else 6 ident = {"contact_ch_max": [1.0] * 2, "force_ch_active_std": [1.0] * 6} tmp_stats = tempfile.NamedTemporaryFile( mode="w", suffix=".json", delete=False) json.dump(ident, tmp_stats) tmp_stats.close() stats_path = tmp_stats.name print("\n[load] no --stats given -> identity scale (1.0); " "phys_gt ranges below are UN-normalized.") full_load(args.metadata, args.source_root, stats_path, args.modality, args.height, args.width, args.n_full) if tmp_stats is not None: os.unlink(tmp_stats.name) if __name__ == "__main__": main()