Datasets:
ArXiv:
License:
| #!/usr/bin/env python3 | |
| """Validate the standardized DeepMind CylinderFlow dataset package.""" | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| EXPECTED_SPLITS = ["train", "valid", "test"] | |
| EXPECTED_REQUIRED = { | |
| "data/cylinder_flow/meta.json", | |
| "data/cylinder_flow/train.tfrecord", | |
| "data/cylinder_flow/valid.tfrecord", | |
| "data/cylinder_flow/test.tfrecord", | |
| "data/cylinder_flow/stats/edge_stats.json", | |
| "data/cylinder_flow/stats/node_stats.json", | |
| } | |
| def fail(message: str) -> None: | |
| raise SystemExit(f"[FAIL] {message}") | |
| def sha256_file(path: Path) -> str: | |
| digest = hashlib.sha256() | |
| with path.open("rb") as f: | |
| for chunk in iter(lambda: f.read(1024 * 1024), b""): | |
| digest.update(chunk) | |
| return digest.hexdigest() | |
| def parse_args() -> argparse.Namespace: | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--dataset-root", default=".", help="dataset package root") | |
| parser.add_argument( | |
| "--verify-sha256", | |
| action="store_true", | |
| help="recompute and verify SHA256 values from files_sha256.jsonl", | |
| ) | |
| parser.add_argument( | |
| "--skip-tfrecord-read", | |
| action="store_true", | |
| help="skip optional TensorFlow first-record readability check", | |
| ) | |
| return parser.parse_args() | |
| def check_files(dataset_root: Path) -> dict: | |
| sizes = {} | |
| for rel_path in sorted(EXPECTED_REQUIRED): | |
| path = dataset_root / rel_path | |
| if not path.is_file(): | |
| fail(f"missing required file: {rel_path}") | |
| if path.stat().st_size <= 0: | |
| fail(f"empty required file: {rel_path}") | |
| sizes[rel_path] = path.stat().st_size | |
| return sizes | |
| def check_metadata(data_dir: Path) -> dict: | |
| meta = json.loads((data_dir / "meta.json").read_text(encoding="utf-8")) | |
| if meta.get("simulator") != "comsol": | |
| fail("meta.json simulator must be comsol") | |
| if meta.get("trajectory_length") != 600: | |
| fail("meta.json trajectory_length must be 600") | |
| expected_fields = ["cells", "mesh_pos", "node_type", "velocity", "pressure"] | |
| if meta.get("field_names") != expected_fields: | |
| fail("meta.json field_names mismatch") | |
| expected_shapes = { | |
| "cells": [1, -1, 3], | |
| "mesh_pos": [1, -1, 2], | |
| "node_type": [1, -1, 1], | |
| "velocity": [600, -1, 2], | |
| "pressure": [600, -1, 1], | |
| } | |
| expected_dtypes = { | |
| "cells": "int32", | |
| "mesh_pos": "float32", | |
| "node_type": "int32", | |
| "velocity": "float32", | |
| "pressure": "float32", | |
| } | |
| for key in expected_fields: | |
| feature = meta.get("features", {}).get(key) | |
| if not feature: | |
| fail(f"meta.json missing feature {key}") | |
| if feature.get("shape") != expected_shapes[key]: | |
| fail(f"meta.json feature {key} shape mismatch") | |
| if feature.get("dtype") != expected_dtypes[key]: | |
| fail(f"meta.json feature {key} dtype mismatch") | |
| return meta | |
| def check_stats(stats_dir: Path) -> None: | |
| edge = json.loads((stats_dir / "edge_stats.json").read_text(encoding="utf-8")) | |
| node = json.loads((stats_dir / "node_stats.json").read_text(encoding="utf-8")) | |
| for key in ["edge_mean", "edge_std"]: | |
| if not isinstance(edge.get(key), list) or len(edge[key]) != 3: | |
| fail(f"edge_stats.json {key} must be length 3") | |
| for key in ["velocity_mean", "velocity_std", "velocity_diff_mean", "velocity_diff_std"]: | |
| if not isinstance(node.get(key), list) or len(node[key]) != 2: | |
| fail(f"node_stats.json {key} must be length 2") | |
| for key in ["pressure_mean", "pressure_std"]: | |
| if not isinstance(node.get(key), list) or len(node[key]) != 1: | |
| fail(f"node_stats.json {key} must be length 1") | |
| def verify_inventory(dataset_root: Path, sizes: dict, verify_sha256: bool) -> None: | |
| inventory_path = dataset_root / "files_sha256.jsonl" | |
| if not inventory_path.is_file(): | |
| fail("missing files_sha256.jsonl") | |
| seen = {} | |
| for line in inventory_path.read_text(encoding="utf-8").splitlines(): | |
| if not line.strip(): | |
| continue | |
| item = json.loads(line) | |
| rel_path = item["path"] | |
| path = dataset_root / rel_path | |
| if not path.is_file(): | |
| fail(f"inventory path missing on disk: {rel_path}") | |
| if path.stat().st_size != item["size"]: | |
| fail(f"size mismatch for {rel_path}") | |
| if rel_path in sizes and sizes[rel_path] != item["size"]: | |
| fail(f"required file size mismatch for {rel_path}") | |
| if verify_sha256 and sha256_file(path) != item["sha256"]: | |
| fail(f"sha256 mismatch for {rel_path}") | |
| seen[rel_path] = item | |
| missing = sorted(EXPECTED_REQUIRED - set(seen)) | |
| if missing: | |
| fail(f"inventory missing required files: {missing}") | |
| def check_tfrecord_first_record(data_dir: Path, meta: dict) -> None: | |
| try: | |
| import numpy as np | |
| import tensorflow.compat.v1 as tf | |
| except Exception as exc: # pragma: no cover - optional runtime dependency | |
| print(f"[WARN] TensorFlow first-record check skipped: {exc}") | |
| return | |
| feature_dict = {k: tf.io.VarLenFeature(tf.string) for k in meta["field_names"]} | |
| for split in EXPECTED_SPLITS: | |
| record_iter = iter(tf.data.TFRecordDataset(str(data_dir / f"{split}.tfrecord")).take(1)) | |
| try: | |
| raw = next(record_iter) | |
| except StopIteration: | |
| fail(f"{split}.tfrecord contains no records") | |
| features = tf.io.parse_single_example(raw, feature_dict) | |
| velocity = np.frombuffer(features["velocity"].values[0].numpy(), dtype=np.float32) | |
| pressure = np.frombuffer(features["pressure"].values[0].numpy(), dtype=np.float32) | |
| mesh_pos = np.frombuffer(features["mesh_pos"].values[0].numpy(), dtype=np.float32) | |
| cells = np.frombuffer(features["cells"].values[0].numpy(), dtype=np.int32) | |
| if velocity.size % (meta["trajectory_length"] * 2) != 0: | |
| fail(f"{split}.tfrecord velocity shape incompatible with metadata") | |
| nodes = velocity.size // (meta["trajectory_length"] * 2) | |
| if pressure.size != meta["trajectory_length"] * nodes: | |
| fail(f"{split}.tfrecord pressure node count mismatch") | |
| if mesh_pos.size != nodes * 2: | |
| fail(f"{split}.tfrecord mesh_pos node count mismatch") | |
| if cells.size % 3 != 0: | |
| fail(f"{split}.tfrecord cells are not triangular") | |
| print(f"[OK] {split}.tfrecord first record: nodes={nodes}, cells={cells.size // 3}") | |
| def main() -> None: | |
| args = parse_args() | |
| dataset_root = Path(args.dataset_root).resolve() | |
| data_dir = dataset_root / "data" / "cylinder_flow" | |
| sizes = check_files(dataset_root) | |
| meta = check_metadata(data_dir) | |
| check_stats(data_dir / "stats") | |
| verify_inventory(dataset_root, sizes, args.verify_sha256) | |
| if not args.skip_tfrecord_read: | |
| check_tfrecord_first_record(data_dir, meta) | |
| print("[OK] CylinderFlow dataset validation passed") | |
| if __name__ == "__main__": | |
| main() | |