| |
| """Validate the standardized OneScience oxide ASE databases.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
|
|
| import numpy as np |
| from ase.db import connect |
|
|
|
|
| EXPECTED_COUNTS = {"train": 238, "val": 28, "test": 29} |
| REQUIRED_METADATA = {"oxide", "polymorph", "xc"} |
|
|
|
|
| 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 require_file(path: Path) -> None: |
| if not path.is_file(): |
| raise FileNotFoundError(f"missing file: {path}") |
|
|
|
|
| def validate_split(path: Path, expected_count: int) -> dict[str, int]: |
| require_file(path) |
| database = connect(path) |
| if database.count() != expected_count: |
| raise ValueError(f"unexpected row count in {path}: {database.count()} != {expected_count}") |
|
|
| oxides: set[str] = set() |
| groups: set[tuple[str, str]] = set() |
| for row in database.select(): |
| missing = REQUIRED_METADATA - set(row.key_value_pairs) |
| if missing: |
| raise ValueError(f"missing metadata in {path} row {row.id}: {sorted(missing)}") |
| if row.xc != "PBE": |
| raise ValueError(f"unexpected xc in {path} row {row.id}: {row.xc!r}") |
| atoms = row.toatoms() |
| if len(atoms) == 0 or not atoms.pbc.all() or abs(atoms.get_volume()) <= 0: |
| raise ValueError(f"invalid periodic structure in {path} row {row.id}") |
| forces = np.asarray(row.forces, dtype=float) |
| stress = np.asarray(row.stress, dtype=float) |
| if forces.shape != (len(atoms), 3): |
| raise ValueError(f"invalid forces shape in {path} row {row.id}: {forces.shape}") |
| if stress.shape != (6,): |
| raise ValueError(f"invalid stress shape in {path} row {row.id}: {stress.shape}") |
| values = np.concatenate(([float(row.energy)], forces.reshape(-1), stress)) |
| if not np.isfinite(values).all(): |
| raise ValueError(f"non-finite target in {path} row {row.id}") |
| oxides.add(str(row.oxide)) |
| groups.add((str(row.oxide), str(row.polymorph))) |
| return {"structures": database.count(), "oxide_count": len(oxides), "group_count": len(groups)} |
|
|
|
|
| def validate_checksums(package_root: Path, manifest: Path) -> int: |
| require_file(manifest) |
| count = 0 |
| for line_number, raw in enumerate(manifest.read_text(encoding="utf-8").splitlines(), 1): |
| if not raw.strip(): |
| continue |
| digest, relative = raw.split(None, 1) |
| target = package_root / relative |
| require_file(target) |
| if sha256_file(target) != digest: |
| raise ValueError(f"checksum mismatch on line {line_number}: {relative}") |
| count += 1 |
| return count |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", default="data/OXIDES") |
| parser.add_argument("--checksum-manifest", default="metadata/sha256_manifest.txt") |
| parser.add_argument("--skip-checksum", action="store_true") |
| args = parser.parse_args() |
|
|
| root = Path(args.dataset_root) |
| summary = { |
| split: validate_split(root / "prepared" / f"{split}.db", count) |
| for split, count in EXPECTED_COUNTS.items() |
| } |
| manifest = root / "manifest.json" |
| require_file(manifest) |
| metadata = json.loads(manifest.read_text(encoding="utf-8")) |
| if metadata.get("counts") != EXPECTED_COUNTS: |
| raise ValueError(f"manifest counts do not match expected counts: {metadata.get('counts')}") |
| checksums = 0 if args.skip_checksum else validate_checksums(Path.cwd(), Path(args.checksum_manifest)) |
| print("Oxides dataset validation passed") |
| print(json.dumps(summary, sort_keys=True)) |
| print(f"checksum entries verified: {checksums}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
