Download scripts/inference.py from OneScience-Group/FlowBench-FNO-LDC2D-Harmonics: direct link, hf CLI and curl.
- Browser
- Download file 4.83 kB
-
https://huggingface.co/OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/resolve/main/scripts/inference.py
- Command line
-
hf download hf://OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/scripts/inference.py
-
curl -L -o inference.py https://huggingface.co/OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/resolve/main/scripts/inference.py
4.83 kB
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import sys | |
| from pathlib import Path | |
| from typing import Any | |
| import numpy as np | |
| import yaml | |
| try: | |
| import torch | |
| from torch.utils.data import DataLoader | |
| except ImportError as exc: # pragma: no cover | |
| raise SystemExit(f"PyTorch is required to run inference: {exc}") from exc | |
| PROJECT_ROOT = Path(__file__).resolve().parents[1] | |
| if str(PROJECT_ROOT) not in sys.path: | |
| sys.path.insert(0, str(PROJECT_ROOT)) | |
| from model.FlowBenchFNO import build_model_from_config | |
| from scripts.train import FlowBenchTensorDataset, compute_metrics, load_npz_array, resolve_path, select_device | |
| def load_config(path: str | Path) -> dict[str, Any]: | |
| with open(path, "r", encoding="utf-8") as handle: | |
| return yaml.safe_load(handle) | |
| def tensor_to_numpy(value: Any) -> np.ndarray: | |
| if isinstance(value, torch.Tensor): | |
| return value.cpu().numpy() | |
| return np.asarray(value) | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description="Run FlowBench FNO inference.") | |
| parser.add_argument("--config", default=str(PROJECT_ROOT / "config/config.yaml")) | |
| parser.add_argument("--checkpoint", default=None) | |
| parser.add_argument("--split", choices=["train", "val"], default=None) | |
| parser.add_argument("--output", default=None) | |
| parser.add_argument("--metrics-output", default=None) | |
| parser.add_argument("--max-batches", type=int, default=None) | |
| parser.add_argument("--device", default=None) | |
| args = parser.parse_args() | |
| config = load_config(args.config) | |
| infer_cfg = config["inference"] | |
| checkpoint_path = resolve_path(args.checkpoint or infer_cfg["checkpoint_path"]) | |
| output_path = resolve_path(args.output or infer_cfg["output_path"]) | |
| metrics_path = resolve_path(args.metrics_output or infer_cfg["metrics_path"]) | |
| split = args.split or infer_cfg.get("split", "val") | |
| device = select_device(args.device or config["experiment"].get("device", "auto")) | |
| checkpoint = torch.load(checkpoint_path, map_location=device) | |
| ckpt_config = checkpoint.get("config", config) | |
| norm = checkpoint["normalization"] | |
| x_mean = tensor_to_numpy(norm["x_mean"]) | |
| x_std = tensor_to_numpy(norm["x_std"]) | |
| y_mean = tensor_to_numpy(norm["y_mean"]) | |
| y_std = tensor_to_numpy(norm["y_std"]) | |
| data_cfg = dict(ckpt_config["data"]) | |
| data_cfg["root_dir"] = config["data"]["root_dir"] | |
| data_root = resolve_path(data_cfg["root_dir"]) | |
| x = load_npz_array(data_root / data_cfg["x_file"], data_cfg.get("x_key", "data")) | |
| y = load_npz_array(data_root / data_cfg["y_file"], data_cfg.get("y_key", "data")) | |
| indices = checkpoint["splits"][f"{split}_idx"] | |
| if isinstance(indices, torch.Tensor): | |
| indices = indices.cpu().numpy() | |
| dataset = FlowBenchTensorDataset(x, y, indices, x_mean, x_std, y_mean, y_std, normalize=True) | |
| loader = DataLoader(dataset, batch_size=int(ckpt_config["training"]["batch_size"]), shuffle=False) | |
| model = build_model_from_config(ckpt_config).to(device) | |
| model.load_state_dict(checkpoint["model_state_dict"]) | |
| model.eval() | |
| y_mean_t = torch.from_numpy(y_mean).to(device) | |
| y_std_t = torch.from_numpy(y_std).to(device) | |
| preds: list[np.ndarray] = [] | |
| targets: list[np.ndarray] = [] | |
| totals = {"mse": 0.0, "relative_l2": 0.0, "mae": 0.0} | |
| count = 0 | |
| max_batches = args.max_batches if args.max_batches is not None else infer_cfg.get("max_batches") | |
| for batch_idx, (x_batch, y_batch) in enumerate(loader): | |
| if max_batches is not None and batch_idx >= int(max_batches): | |
| break | |
| x_batch = x_batch.to(device) | |
| y_batch = y_batch.to(device) | |
| pred = model(x_batch) | |
| pred_phys = pred * y_std_t + y_mean_t | |
| target_phys = y_batch * y_std_t + y_mean_t | |
| metrics = compute_metrics(pred_phys, target_phys) | |
| batch_size = x_batch.shape[0] | |
| for key, value in metrics.items(): | |
| totals[key] += value * batch_size | |
| count += batch_size | |
| preds.append(pred_phys.cpu().numpy().astype(np.float32)) | |
| targets.append(target_phys.cpu().numpy().astype(np.float32)) | |
| if count == 0: | |
| raise RuntimeError("No batches were processed during inference.") | |
| metrics = {key: value / count for key, value in totals.items()} | |
| metrics.update({"samples": count, "checkpoint": str(checkpoint_path), "split": split}) | |
| output_path.parent.mkdir(parents=True, exist_ok=True) | |
| np.savez_compressed(output_path, predictions=np.concatenate(preds), targets=np.concatenate(targets)) | |
| metrics_path.parent.mkdir(parents=True, exist_ok=True) | |
| with open(metrics_path, "w", encoding="utf-8") as handle: | |
| json.dump(metrics, handle, indent=2) | |
| print(json.dumps(metrics, indent=2), flush=True) | |
| if __name__ == "__main__": | |
| main() | |