File size: 4,827 Bytes
4d99a96 88362ad 4d99a96 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | 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()
|