Release KITTI-C2L v1.0.0: documented self-contained benchmark, loader and baselines
db613b6 verified | """Read-only audit of existing Hub asset shards using ranged metadata reads.""" | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from collections import Counter | |
| from pathlib import Path | |
| import pyarrow.parquet as pq | |
| from huggingface_hub import HfApi, HfFileSystem | |
| from kitti_c2l.release import require | |
| from kitti_c2l.schema import ASSETS_SCHEMA | |
| from kitti_c2l.sequence_mapping import load_sequence_mapping | |
| def audit(repo_id: str, revision: str | None, root: Path) -> dict: | |
| api = HfApi() | |
| info = api.dataset_info(repo_id, revision=revision, files_metadata=True) | |
| inventory = [] | |
| for item in info.siblings or []: | |
| lfs = item.lfs | |
| inventory.append( | |
| { | |
| "path": item.rfilename, | |
| "bytes": item.size, | |
| "sha256": (getattr(lfs, "sha256", None) or lfs.get("sha256")) if lfs else None, | |
| } | |
| ) | |
| fs = HfFileSystem() | |
| mapping = load_sequence_mapping() | |
| expected = { | |
| (seq, frame) | |
| for seq, source in mapping.items() | |
| if source.available | |
| for frame in range(source.frame_count) | |
| } | |
| seen = set() | |
| counts = Counter() | |
| shards = [] | |
| columns = [ | |
| "frame_id", | |
| "sequence", | |
| "frame_index", | |
| "split", | |
| "camera_id", | |
| "image_width", | |
| "image_height", | |
| "raw_date", | |
| "raw_drive", | |
| "raw_frame_index", | |
| ] | |
| for item in inventory: | |
| if not Path(item["path"]).name.startswith("frames_"): | |
| continue | |
| path = f"datasets/{repo_id}@{info.sha}/{item['path']}" | |
| with fs.open(path, "rb", block_size=256 * 1024, cache_type="readahead") as stream: | |
| parquet = pq.ParquetFile(stream) | |
| require( | |
| parquet.schema_arrow.equals(ASSETS_SCHEMA, check_metadata=False), | |
| f"schema mismatch: {item['path']}", | |
| ) | |
| rows = parquet.read(columns=columns, use_threads=False).to_pylist() | |
| row_groups = parquet.metadata.num_row_groups | |
| for row in rows: | |
| key = (row["sequence"], row["frame_index"]) | |
| require( | |
| key in expected and key not in seen, f"missing/unexpected/duplicate frame: {key}" | |
| ) | |
| seen.add(key) | |
| source = mapping[row["sequence"]] | |
| require( | |
| row["frame_id"] == f"{row['sequence']}_{row['frame_index']:06d}", | |
| "frame ID mismatch", | |
| ) | |
| require( | |
| (row["raw_date"], row["raw_drive"], row["raw_frame_index"]) | |
| == (source.date, source.drive, source.start + row["frame_index"]), | |
| "Raw mapping mismatch", | |
| ) | |
| require(row["split"] == source.split and row["camera_id"] == 2, "split/camera mismatch") | |
| counts[source.split] += 1 | |
| shards.append(dict(item, rows=len(rows), row_groups=row_groups)) | |
| print(f"{item['path']}: {len(rows)} frame identities verified", flush=True) | |
| require(seen == expected, "incomplete source-frame coverage") | |
| local = json.loads((root / "release/v1/manifest.json").read_text()) | |
| remote = {item["path"]: item for item in inventory} | |
| for item in local["files"]: | |
| require( | |
| remote[item["path"]]["sha256"] == item["sha256"] | |
| and remote[item["path"]]["bytes"] == item["bytes"], | |
| "metadata snapshot differs from local audit", | |
| ) | |
| return { | |
| "repo_id": repo_id, | |
| "revision": info.sha, | |
| "private_at_audit": info.private, | |
| "shards": shards, | |
| "frames_by_split": dict(counts), | |
| "total_frames": len(seen), | |
| "asset_bytes": sum(item["bytes"] for item in shards), | |
| "audit_scope": "All shard schemas, row counts and frame identity/source mapping columns via authenticated ranged reads. Payload checksums are Hub LFS declarations; not a download of every sensor payload.", | |
| "schema_coverage_and_raw_mappings": "pass", | |
| "metadata_files": [remote[item["path"]] for item in local["files"]], | |
| "metadata_sha256_matches_audited_snapshot": True, | |
| } | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--repo-id", default="mcocheteux/KITTI-C2L-Dataset") | |
| parser.add_argument("--revision", help="Pinned Hub revision; defaults to current main") | |
| parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) | |
| parser.add_argument("--output", required=True, type=Path) | |
| args = parser.parse_args() | |
| if args.output.exists(): | |
| raise FileExistsError(f"Refusing to overwrite audit: {args.output}") | |
| report = audit(args.repo_id, args.revision, args.root) | |
| args.output.parent.mkdir(parents=True, exist_ok=True) | |
| args.output.write_text(json.dumps(report, indent=2) + "\n") | |
| print( | |
| f"Verified {report['total_frames']} frames in {len(report['shards'])} shards; report: {args.output}" | |
| ) | |
| if __name__ == "__main__": | |
| main() | |