Download model/FlowBenchFNO.py from OneScience-Group/FlowBench-FNO-LDC2D-Harmonics: direct link, hf CLI and curl.
- Browser
- Download file 4.82 kB
-
https://huggingface.co/OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/resolve/main/model/FlowBenchFNO.py
- Command line
-
hf download hf://OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/model/FlowBenchFNO.py
-
curl -L -o FlowBenchFNO.py https://huggingface.co/OneScience-Group/FlowBench-FNO-LDC2D-Harmonics/resolve/main/model/FlowBenchFNO.py
4.82 kB
| """Fourier Neural Operator baseline for FlowBench LDC_NS_2D data.""" | |
| from __future__ import annotations | |
| from typing import Iterable, Sequence | |
| import torch | |
| from torch import nn | |
| import torch.nn.functional as F | |
| class SpectralConv2d(nn.Module): | |
| """2D Fourier convolution using a truncated set of low-frequency modes.""" | |
| def __init__(self, in_channels: int, out_channels: int, n_modes: Sequence[int]) -> None: | |
| super().__init__() | |
| if len(n_modes) != 2: | |
| raise ValueError("n_modes must contain [modes_height, modes_width].") | |
| self.in_channels = in_channels | |
| self.out_channels = out_channels | |
| self.modes_height = int(n_modes[0]) | |
| self.modes_width = int(n_modes[1]) | |
| scale = 1.0 / max(1, in_channels * out_channels) | |
| shape = (in_channels, out_channels, self.modes_height, self.modes_width) | |
| self.weights_pos = nn.Parameter(scale * torch.randn(*shape, dtype=torch.cfloat)) | |
| self.weights_neg = nn.Parameter(scale * torch.randn(*shape, dtype=torch.cfloat)) | |
| def compl_mul2d(inputs: torch.Tensor, weights: torch.Tensor) -> torch.Tensor: | |
| return torch.einsum("bixy,ioxy->boxy", inputs, weights) | |
| def forward(self, x: torch.Tensor) -> torch.Tensor: | |
| batch_size, _, height, width = x.shape | |
| x_ft = torch.fft.rfft2(x, norm="ortho") | |
| out_ft = torch.zeros( | |
| batch_size, | |
| self.out_channels, | |
| height, | |
| width // 2 + 1, | |
| dtype=torch.cfloat, | |
| device=x.device, | |
| ) | |
| mh = min(self.modes_height, height) | |
| mw = min(self.modes_width, width // 2 + 1) | |
| out_ft[:, :, :mh, :mw] = self.compl_mul2d( | |
| x_ft[:, :, :mh, :mw], self.weights_pos[:, :, :mh, :mw] | |
| ) | |
| out_ft[:, :, -mh:, :mw] = self.compl_mul2d( | |
| x_ft[:, :, -mh:, :mw], self.weights_neg[:, :, :mh, :mw] | |
| ) | |
| return torch.fft.irfft2(out_ft, s=(height, width), norm="ortho") | |
| class FNOBlock2d(nn.Module): | |
| def __init__(self, channels: int, n_modes: Sequence[int]) -> None: | |
| super().__init__() | |
| self.spectral = SpectralConv2d(channels, channels, n_modes) | |
| self.pointwise = nn.Conv2d(channels, channels, kernel_size=1) | |
| def forward(self, x: torch.Tensor) -> torch.Tensor: | |
| return self.spectral(x) + self.pointwise(x) | |
| class FlowBenchFNO(nn.Module): | |
| """FNO baseline for mapping FlowBench LDC inputs to dense output fields. | |
| Expected input shape is ``[batch, in_channels, height, width]``. | |
| The default constructor arguments match the requested FlowBench baseline: | |
| ``n_modes=[32, 32]``, ``n_layers=5``, ``in_channels=3``, | |
| ``out_channels=4``, ``hidden_channels=32``, and | |
| ``projection_channels=128``. | |
| """ | |
| def __init__( | |
| self, | |
| n_modes: Sequence[int] | Iterable[int] = (32, 32), | |
| n_layers: int = 5, | |
| in_channels: int = 3, | |
| out_channels: int = 4, | |
| hidden_channels: int = 32, | |
| projection_channels: int = 128, | |
| ) -> None: | |
| super().__init__() | |
| self.n_modes = list(n_modes) | |
| self.n_layers = int(n_layers) | |
| self.in_channels = int(in_channels) | |
| self.out_channels = int(out_channels) | |
| self.hidden_channels = int(hidden_channels) | |
| self.projection_channels = int(projection_channels) | |
| self.lifting = nn.Conv2d(self.in_channels, self.hidden_channels, kernel_size=1) | |
| self.fno_blocks = nn.ModuleList( | |
| [FNOBlock2d(self.hidden_channels, self.n_modes) for _ in range(self.n_layers)] | |
| ) | |
| self.projection = nn.Sequential( | |
| nn.Conv2d(self.hidden_channels, self.projection_channels, kernel_size=1), | |
| nn.GELU(), | |
| nn.Conv2d(self.projection_channels, self.out_channels, kernel_size=1), | |
| ) | |
| def forward(self, x: torch.Tensor) -> torch.Tensor: | |
| if x.ndim != 4: | |
| raise ValueError(f"Expected [B,C,H,W] input, got shape {tuple(x.shape)}.") | |
| if x.shape[1] != self.in_channels: | |
| raise ValueError(f"Expected {self.in_channels} channels, got {x.shape[1]}.") | |
| x = self.lifting(x) | |
| for idx, block in enumerate(self.fno_blocks): | |
| x = block(x) | |
| if idx != len(self.fno_blocks) - 1: | |
| x = F.gelu(x) | |
| return self.projection(x) | |
| def build_model_from_config(config: dict) -> FlowBenchFNO: | |
| model_cfg = config.get("model", {}) | |
| return FlowBenchFNO( | |
| n_modes=model_cfg.get("n_modes", [32, 32]), | |
| n_layers=model_cfg.get("n_layers", 5), | |
| in_channels=model_cfg.get("in_channels", 3), | |
| out_channels=model_cfg.get("out_channels", 4), | |
| hidden_channels=model_cfg.get("hidden_channels", 32), | |
| projection_channels=model_cfg.get("projection_channels", 128), | |
| ) | |