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()