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) @torch.no_grad() 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()