| |
| """Validate the standardized OneScience MP-20 dataset package.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
|
|
| EXPECTED_SPLITS = {"train": 27136, "val": 9047, "test": 9046} |
| REQUIRED_COLUMNS = { |
| "material_id", |
| "formation_energy_per_atom", |
| "dft_band_gap", |
| "pretty_formula", |
| "elements", |
| "cif", |
| "spacegroup_number", |
| "dft_bulk_modulus", |
| "dft_mag_density", |
| } |
| REQUIRED_ARRAYS = { |
| "atomic_numbers.npy", |
| "cell.npy", |
| "num_atoms.npy", |
| "pos.npy", |
| "structure_id.npy", |
| } |
| PROPERTY_FILES = { |
| "formation_energy_per_atom.json", |
| "dft_band_gap.json", |
| "dft_bulk_modulus.json", |
| "dft_mag_density.json", |
| } |
|
|
|
|
| def require_file(path: Path) -> None: |
| if not path.is_file(): |
| raise FileNotFoundError(f"missing file: {path}") |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def validate_csv(path: Path, expected_rows: int) -> None: |
| require_file(path) |
| with path.open(encoding="utf-8", newline="") as handle: |
| reader = csv.DictReader(handle) |
| columns = set(reader.fieldnames or []) |
| missing = REQUIRED_COLUMNS - columns |
| if missing: |
| raise ValueError(f"missing CSV columns in {path}: {sorted(missing)}") |
| rows = sum(1 for _ in reader) |
| if rows != expected_rows: |
| raise ValueError(f"unexpected CSV rows in {path}: {rows} != {expected_rows}") |
|
|
|
|
| def validate_cache(path: Path, expected_structures: int) -> None: |
| for name in REQUIRED_ARRAYS | PROPERTY_FILES: |
| require_file(path / name) |
|
|
| atomic_numbers = np.load(path / "atomic_numbers.npy", mmap_mode="r", allow_pickle=False) |
| cells = np.load(path / "cell.npy", mmap_mode="r", allow_pickle=False) |
| num_atoms = np.load(path / "num_atoms.npy", mmap_mode="r", allow_pickle=False) |
| positions = np.load(path / "pos.npy", mmap_mode="r", allow_pickle=False) |
| structure_ids = np.load(path / "structure_id.npy", mmap_mode="r", allow_pickle=False) |
|
|
| if cells.shape != (expected_structures, 3, 3): |
| raise ValueError(f"unexpected cell shape in {path}: {cells.shape}") |
| if num_atoms.shape != (expected_structures,): |
| raise ValueError(f"unexpected num_atoms shape in {path}: {num_atoms.shape}") |
| if structure_ids.shape != (expected_structures,): |
| raise ValueError(f"unexpected structure_id shape in {path}: {structure_ids.shape}") |
| total_atoms = int(num_atoms.sum()) |
| if atomic_numbers.shape != (total_atoms,): |
| raise ValueError(f"atomic_numbers and num_atoms disagree in {path}") |
| if positions.shape != (total_atoms, 3): |
| raise ValueError(f"positions and num_atoms disagree in {path}") |
|
|
| for name in PROPERTY_FILES: |
| payload = json.loads((path / name).read_text(encoding="utf-8")) |
| if len(payload.get("values", [])) != expected_structures: |
| raise ValueError(f"unexpected property length in {path / name}") |
|
|
|
|
| def read_checksum_manifest(path: Path) -> list[tuple[str, str]]: |
| require_file(path) |
| entries: list[tuple[str, str]] = [] |
| with path.open(encoding="utf-8") as handle: |
| for line_no, raw in enumerate(handle, start=1): |
| line = raw.strip() |
| if not line: |
| continue |
| parts = line.split(None, 1) |
| if len(parts) != 2: |
| raise ValueError(f"invalid checksum line {line_no}: {raw!r}") |
| entries.append((parts[0], parts[1])) |
| return entries |
|
|
|
|
| def validate_checksums(package_root: Path, manifest_path: Path) -> int: |
| entries = read_checksum_manifest(manifest_path) |
| for expected_hash, relative_path in entries: |
| target = package_root / relative_path |
| require_file(target) |
| if sha256_file(target) != expected_hash: |
| raise ValueError(f"checksum mismatch: {relative_path}") |
| return len(entries) |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", default="data/MP20") |
| parser.add_argument("--checksum-manifest", default="metadata/sha256_manifest.txt") |
| parser.add_argument("--skip-checksum", action="store_true") |
| args = parser.parse_args() |
|
|
| package_root = Path.cwd() |
| dataset_root = Path(args.dataset_root) |
| raw_root = dataset_root / "raw/mp_20" |
| cache_root = dataset_root / "cache/mp_20" |
|
|
| for split, expected_count in EXPECTED_SPLITS.items(): |
| validate_csv(raw_root / f"{split}.csv", expected_count) |
| validate_cache(cache_root / split, expected_count) |
|
|
| checksum_count = 0 |
| if not args.skip_checksum: |
| checksum_count = validate_checksums(package_root, Path(args.checksum_manifest)) |
|
|
| print("MP-20 dataset validation passed") |
| print(f"structures: {sum(EXPECTED_SPLITS.values())}") |
| print(f"splits: {EXPECTED_SPLITS}") |
| print(f"checksum entries verified: {checksum_count}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| raise SystemExit(main()) |
| except Exception as exc: |
| print(f"MP-20 dataset validation failed: {exc}", file=sys.stderr) |
| raise SystemExit(1) |
|
|
