Upload CIDM Foundation A1-R1-R2 FIX1 experimental results and data (part 2)

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d2_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33a0ee1bb8a6a6b2229cca47d78d6dcafb189fec2c56fce1f9f5d768c52229b8
+size 1302

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d3_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acb6b88051508ff82584b4d33726084120b44f0f705be6ef883120a3795e5ecb
+size 1702

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d4_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04da0d0714d27808b9cdefcada5290238b72a8e98c9f69442f7004ebe26a4c1f
+size 2102

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d5_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a60ec4ef444634164b236f68c0ddf57c566a362c774d4989a9f137241cb44786
+size 2502

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d6_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a98f20321763ffd92d5d1a6e28b9db12bf6a804848448727763f93c3cf39b306
+size 2902

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d7_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c73487f13a2935f8d2749a9edaf9bc99a081510fc1b5aa93c3bb5b92234a694e
+size 3302

sources/neuraloperator/neuralop/layers/fcgram_matrices/FCGram_data_d8_c25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7911eae1f4def9aea17937a0925749ef2743c75b9eff81e7f01fc0fac6586db3
+size 3702

sources/neuraloperator/neuralop/layers/fno_block.py

@@ -0,0 +1,498 @@
+from typing import List, Union
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from .channel_mlp import ChannelMLP
+from .complex import CGELU, ctanh, ComplexValued
+from .normalization_layers import AdaIN, InstanceNorm, BatchNorm
+from .skip_connections import skip_connection
+from .spectral_convolution import SpectralConv
+from ..utils import validate_scaling_factor
+
+
+Number = Union[int, float]
+
+
+def _make_conv_bias(in_channels, out_channels, n_dim, kernel_size):
+    """Create the local convolutional bias term used alongside SpectralConv."""
+    if kernel_size < 1:
+        raise ValueError(f"conv_bias_kernel must be >= 1, got {kernel_size}")
+
+    if kernel_size == 1:
+        return skip_connection(
+            in_channels,
+            out_channels,
+            skip_type="linear",
+            n_dim=n_dim,
+        )
+
+    if n_dim > 3:
+        raise NotImplementedError(
+            "conv_bias_kernel > 1 is only implemented for 1D, 2D, and 3D FNO blocks."
+        )
+
+    conv_module = getattr(nn, f"Conv{n_dim}d")
+    return conv_module(
+        in_channels,
+        out_channels,
+        kernel_size=kernel_size,
+        padding="same",
+        bias=False,
+    )
+
+
+class FNOBlocks(nn.Module):
+    """FNOBlocks implements a sequence of Fourier layers.
+    
+    The Fourier layers are first described in [1]_, and the exact implementation details 
+    of the Fourier layer architecture are discussed in [2]_.
+
+    Parameters
+    ----------
+    in_channels : int
+        Number of input channels to Fourier layers
+    out_channels : int
+        Number of output channels after Fourier layers
+    n_modes : int or List[int]
+        Number of modes to keep along each dimension in frequency space.
+        Can either be specified as an int (for all dimensions) or an iterable
+        with one number per dimension
+    resolution_scaling_factor : Optional[Union[Number, List[Number]]], optional
+        Factor by which to scale outputs for super-resolution, by default None
+    n_layers : int, optional
+        Number of Fourier layers to apply in sequence, by default 1
+    max_n_modes : int or List[int], optional
+        Maximum number of modes to keep along each dimension, by default None
+    fno_block_precision : str, optional
+        Floating point precision to use for computations. Options: "full", "half", "mixed", by default "full"
+    use_channel_mlp : bool, optional
+        Whether to use an MLP layer after each FNO block, by default True
+    channel_mlp_dropout : float, optional
+        Dropout parameter for self.channel_mlp, by default 0
+    channel_mlp_expansion : float, optional
+        Expansion parameter for self.channel_mlp, by default 0.5
+    non_linearity : torch.nn.F module, optional
+        Nonlinear activation function to use between layers, by default F.gelu
+    stabilizer : Literal["tanh"], optional
+        Stabilizing module to use between certain layers. Options: "tanh", None, by default None
+    norm : Literal["ada_in", "group_norm", "instance_norm", "batch_norm"], optional
+        Normalization layer to use. Options: "ada_in", "group_norm", "instance_norm", "batch_norm", None, by default None
+    norm_groups : int, optional
+        Number of groups for GroupNorm, by default 1
+    ada_in_features : int, optional
+        Number of features for adaptive instance norm above, by default None
+    preactivation : bool, optional
+        Whether to call forward pass with pre-activation, by default False
+        If True, call nonlinear activation and norm before Fourier convolution
+        If False, call activation and norms after Fourier convolutions
+    fno_skip : str, optional
+        Module to use for FNO skip connections. Options: "linear", "soft-gating", "identity", None, by default "linear"
+        If None, no skip connection is added. See layers.skip_connections for more details
+    conv_bias_kernel : int, optional
+        Kernel size for the local convolutional bias term used when ``fno_skip="linear"``.
+        ``1`` preserves the default pointwise bias term, while larger kernels add a
+        local convolution alongside the global spectral convolution. Default: 1
+    channel_mlp_skip : str, optional
+        Module to use for ChannelMLP skip connections. Options: "linear", "soft-gating", "identity", None, by default "soft-gating"
+        If None, no skip connection is added. See layers.skip_connections for more details
+
+    Other Parameters
+    ----------------
+    complex_data : bool, optional
+        Whether the FNO's data takes on complex values in space, by default False
+    separable : bool, optional
+        Separable parameter for SpectralConv, by default False
+    factorization : str, optional
+        Factorization parameter for SpectralConv. Options: "tucker", "cp", "tt", None, by default None
+    rank : float, optional
+        Rank parameter for SpectralConv, by default 1.0
+    conv_module : BaseConv, optional
+        Module to use for convolutions in FNO block, by default SpectralConv
+    joint_factorization : bool, optional
+        Whether to factorize all spectralConv weights as one tensor, by default False
+    fixed_rank_modes : bool, optional
+        Fixed_rank_modes parameter for SpectralConv, by default False
+    implementation : str, optional
+        Implementation parameter for SpectralConv. Options: "factorized", "reconstructed", by default "factorized"
+    decomposition_kwargs : dict, optional
+        Kwargs for tensor decomposition in SpectralConv, by default dict()
+    enforce_hermitian_symmetry : bool, optional
+        Whether to enforce Hermitian symmetry conditions when performing inverse FFT
+        for real-valued data. Only used when ``conv_module`` is :class:`SpectralConv`
+        or a subclass; ignored otherwise. When True, explicitly enforces that the 0th
+        frequency and Nyquist frequency are real-valued before calling irfft. When False,
+        relies on cuFFT's irfftn to handle symmetry automatically, which may fail on
+        certain GPUs or input sizes, causing line artifacts. By default True.
+
+    References
+    ----------
+    .. [1] Li, Z. et al. "Fourier Neural Operator for Parametric Partial Differential
+           Equations" (2021). ICLR 2021, https://arxiv.org/pdf/2010.08895.
+    .. [2] Kossaifi, J., Kovachki, N., Azizzadenesheli, K., Anandkumar, A. "Multi-Grid
+           Tensorized Fourier Neural Operator for High-Resolution PDEs" (2024).
+           TMLR 2024, https://openreview.net/pdf?id=AWiDlO63bH.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        n_modes,
+        resolution_scaling_factor=None,
+        n_layers=1,
+        max_n_modes=None,
+        fno_block_precision="full",
+        use_channel_mlp=True,
+        channel_mlp_dropout=0,
+        channel_mlp_expansion=0.5,
+        non_linearity=F.gelu,
+        stabilizer=None,
+        norm=None,
+        norm_groups=1,
+        ada_in_features=None,
+        preactivation=False,
+        fno_skip="linear",
+        conv_bias_kernel=1,
+        channel_mlp_skip="soft-gating",
+        complex_data=False,
+        separable=False,
+        factorization=None,
+        rank=1.0,
+        conv_module=SpectralConv,
+        fixed_rank_modes=False,
+        implementation="factorized",
+        decomposition_kwargs=dict(),
+        enforce_hermitian_symmetry=True,
+    ):
+        super().__init__()
+        if isinstance(n_modes, int):
+            n_modes = [n_modes]
+        self._n_modes = n_modes
+        self.n_dim = len(n_modes)
+
+        self.resolution_scaling_factor: Union[
+            None, List[List[float]]
+        ] = validate_scaling_factor(resolution_scaling_factor, self.n_dim, n_layers)
+
+        self.max_n_modes = max_n_modes
+        self.fno_block_precision = fno_block_precision
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.n_layers = n_layers
+        self.stabilizer = stabilizer
+        self.rank = rank
+        self.factorization = factorization
+        self.fixed_rank_modes = fixed_rank_modes
+        self.decomposition_kwargs = decomposition_kwargs
+        self.fno_skip = fno_skip
+        self.conv_bias_kernel = conv_bias_kernel
+        self.channel_mlp_skip = channel_mlp_skip
+        self.complex_data = complex_data
+
+        self.use_channel_mlp = use_channel_mlp
+        self.channel_mlp_expansion = channel_mlp_expansion
+        self.channel_mlp_dropout = channel_mlp_dropout
+        self.implementation = implementation
+        self.separable = separable
+        self.preactivation = preactivation
+        self.ada_in_features = ada_in_features
+        self.enforce_hermitian_symmetry = enforce_hermitian_symmetry
+
+        # apply real nonlin if data is real, otherwise CGELU
+        if self.complex_data:
+            self.non_linearity = CGELU
+        else:
+            self.non_linearity = non_linearity
+
+        # One conv per layer. Only resolution_scaling_factor varies by layer index
+        self.convs = nn.ModuleList(
+            [
+                conv_module(
+                    self.in_channels,
+                    self.out_channels,
+                    self.n_modes,
+                    # Per-layer scaling for super-resolution, or None if disabled
+                    resolution_scaling_factor=(
+                        self.resolution_scaling_factor[i]
+                        if resolution_scaling_factor is not None
+                        else None
+                    ),
+                    max_n_modes=max_n_modes,
+                    rank=rank,
+                    fixed_rank_modes=fixed_rank_modes,
+                    implementation=implementation,
+                    separable=separable,
+                    factorization=factorization,
+                    fno_block_precision=fno_block_precision,
+                    decomposition_kwargs=decomposition_kwargs,
+                    complex_data=complex_data,
+                    # Only SpectralConv (and subclasses) accept enforce_hermitian_symmetry. Others ignore it
+                    **(
+                        {"enforce_hermitian_symmetry": enforce_hermitian_symmetry}
+                        if issubclass(conv_module, SpectralConv)
+                        else {}
+                    ),
+                )
+                for i in range(n_layers)
+            ]
+        )
+
+        if fno_skip is not None:
+            if fno_skip.lower() == "linear":
+                # FourCastNet v3-like local + global convolutions: the spectral
+                # path is global, while larger kernels give this bias term locality.
+                fno_skip_modules = [
+                    _make_conv_bias(
+                        self.in_channels,
+                        self.out_channels,
+                        self.n_dim,
+                        conv_bias_kernel,
+                    )
+                    for _ in range(n_layers)
+                ]
+            else:
+                if conv_bias_kernel != 1:
+                    raise ValueError(
+                        "conv_bias_kernel can only differ from 1 when fno_skip='linear'."
+                    )
+                fno_skip_modules = [
+                    skip_connection(
+                        self.in_channels,
+                        self.out_channels,
+                        skip_type=fno_skip,
+                        n_dim=self.n_dim,
+                    )
+                    for _ in range(n_layers)
+                ]
+            self.fno_skips = nn.ModuleList(fno_skip_modules)
+        else:
+            if conv_bias_kernel != 1:
+                raise ValueError(
+                    "conv_bias_kernel can only differ from 1 when fno_skip='linear'."
+                )
+            self.fno_skips = None
+        if self.complex_data and self.fno_skips is not None:
+            self.fno_skips = nn.ModuleList([ComplexValued(x) for x in self.fno_skips])
+
+        if self.use_channel_mlp:
+            self.channel_mlp = nn.ModuleList(
+                [
+                    ChannelMLP(
+                        in_channels=self.out_channels,
+                        hidden_channels=round(self.out_channels * channel_mlp_expansion),
+                        dropout=channel_mlp_dropout,
+                        n_dim=self.n_dim,
+                    )
+                    for _ in range(n_layers)
+                ]
+            )
+            if self.complex_data:
+                self.channel_mlp = nn.ModuleList(
+                    [ComplexValued(x) for x in self.channel_mlp]
+                )
+            if channel_mlp_skip is not None:
+                self.channel_mlp_skips = nn.ModuleList(
+                    [
+                        skip_connection(
+                            self.in_channels,
+                            self.out_channels,
+                            skip_type=channel_mlp_skip,
+                            n_dim=self.n_dim,
+                        )
+                        for _ in range(n_layers)
+                    ]
+                )
+            else:
+                self.channel_mlp_skips = None
+            if self.complex_data and self.channel_mlp_skips is not None:
+                self.channel_mlp_skips = nn.ModuleList(
+                    [ComplexValued(x) for x in self.channel_mlp_skips]
+                )
+
+        # Each block will have 2 norms if we also use a ChannelMLP
+        self.n_norms = 2
+        if norm is None:
+            self.norm = None
+        elif norm == "instance_norm":
+            self.norm = nn.ModuleList(
+                [InstanceNorm() for _ in range(n_layers * self.n_norms)]
+            )
+        elif norm == "group_norm":
+            self.norm = nn.ModuleList(
+                [
+                    nn.GroupNorm(num_groups=norm_groups, num_channels=self.out_channels)
+                    for _ in range(n_layers * self.n_norms)
+                ]
+            )
+
+        elif norm == "batch_norm":
+            self.norm = nn.ModuleList(
+                [
+                    BatchNorm(n_dim=self.n_dim, num_features=self.out_channels)
+                    for _ in range(n_layers * self.n_norms)
+                ]
+            )
+
+        elif norm == "ada_in":
+            self.norm = nn.ModuleList(
+                [
+                    AdaIN(ada_in_features, out_channels)
+                    for _ in range(n_layers * self.n_norms)
+                ]
+            )
+        else:
+            raise ValueError(
+                f"Got norm={norm} but expected None or one of "
+                "[instance_norm, group_norm, batch_norm, ada_in]"
+            )
+
+        if self.complex_data and self.norm is not None:
+            self.norm = nn.ModuleList([ComplexValued(x) for x in self.norm])
+
+    def set_ada_in_embeddings(self, *embeddings):
+        """Sets the embeddings of each Ada-IN norm layers
+
+        Parameters
+        ----------
+        embeddings : tensor or list of tensor
+            if a single embedding is given, it will be used for each norm layer
+            otherwise, each embedding will be used for the corresponding norm layer
+        """
+        if self.norm is not None:
+            if len(embeddings) == 1:
+                for norm in self.norm:
+                    norm.set_embedding(embeddings[0])
+            else:
+                for norm, embedding in zip(self.norm, embeddings):
+                    norm.set_embedding(embedding)
+
+    def forward(self, x, index=0, output_shape=None):
+        if self.preactivation:
+            return self.forward_with_preactivation(x, index, output_shape)
+        else:
+            return self.forward_with_postactivation(x, index, output_shape)
+
+    def forward_with_postactivation(self, x, index=0, output_shape=None):
+        if self.fno_skips is not None:
+            x_skip_fno = self.fno_skips[index](x)
+            x_skip_fno = self.convs[index].transform(x_skip_fno, output_shape=output_shape)
+
+        if self.use_channel_mlp and self.channel_mlp_skips is not None:
+            x_skip_channel_mlp = self.channel_mlp_skips[index](x)
+            x_skip_channel_mlp = self.convs[index].transform(x_skip_channel_mlp, output_shape=output_shape)
+
+        if self.stabilizer == "tanh":
+            if self.complex_data:
+                x = ctanh(x)
+            else:
+                x = torch.tanh(x)
+
+        x_fno = self.convs[index](x, output_shape=output_shape)
+
+        if self.norm is not None:
+            x_fno = self.norm[self.n_norms * index](x_fno)
+
+        x = x_fno + x_skip_fno if self.fno_skips is not None else x_fno
+
+        if index < (self.n_layers - 1):
+            x = self.non_linearity(x)
+
+        if self.use_channel_mlp:
+            if self.channel_mlp_skips is not None:
+                x = self.channel_mlp[index](x) + x_skip_channel_mlp
+            else:
+                x = self.channel_mlp[index](x)
+
+        if self.norm is not None:
+            x = self.norm[self.n_norms * index + 1](x)
+
+        if index < (self.n_layers - 1):
+            x = self.non_linearity(x)
+
+        return x
+
+    def forward_with_preactivation(self, x, index=0, output_shape=None):
+        # Apply non-linear activation (and norm)
+        # before this block's convolution/forward pass:
+        x = self.non_linearity(x)
+
+        if self.norm is not None:
+            x = self.norm[self.n_norms * index](x)
+
+        if self.fno_skips is not None:
+            x_skip_fno = self.fno_skips[index](x)
+            x_skip_fno = self.convs[index].transform(x_skip_fno, output_shape=output_shape)
+
+        if self.use_channel_mlp and self.channel_mlp_skips is not None:
+            x_skip_channel_mlp = self.channel_mlp_skips[index](x)
+            x_skip_channel_mlp = self.convs[index].transform(x_skip_channel_mlp, output_shape=output_shape)
+
+        if self.stabilizer == "tanh":
+            if self.complex_data:
+                x = ctanh(x)
+            else:
+                x = torch.tanh(x)
+
+        x_fno = self.convs[index](x, output_shape=output_shape)
+
+        x = x_fno + x_skip_fno if self.fno_skips is not None else x_fno
+
+        if index < (self.n_layers - 1):
+            x = self.non_linearity(x)
+
+        if self.norm is not None:
+            x = self.norm[self.n_norms * index + 1](x)
+
+        if self.use_channel_mlp:
+            if self.channel_mlp_skips is not None:
+                x = self.channel_mlp[index](x) + x_skip_channel_mlp
+            else:
+                x = self.channel_mlp[index](x)
+
+        return x
+
+    @property
+    def n_modes(self):
+        return self._n_modes
+
+    @n_modes.setter
+    def n_modes(self, n_modes):
+        for i in range(self.n_layers):
+            self.convs[i].n_modes = n_modes
+        self._n_modes = n_modes
+
+    def get_block(self, indices):
+        """Returns a sub-FNO Block layer from the jointly parametrized main block
+
+        The parametrization of an FNOBlock layer is shared with the main one.
+        """
+        if self.n_layers == 1:
+            raise ValueError(
+                "A single layer is parametrized, directly use the main class."
+            )
+
+        return SubModule(self, indices)
+
+    def __getitem__(self, indices):
+        return self.get_block(indices)
+
+
+class SubModule(nn.Module):
+    """Class representing one of the sub_module from the mother joint module
+
+    Notes
+    -----
+    This relies on the fact that nn.Parameters are not duplicated:
+    if the same nn.Parameter is assigned to multiple modules,
+    they all point to the same data, which is shared.
+    """
+
+    def __init__(self, main_module, indices):
+        super().__init__()
+        self.main_module = main_module
+        self.indices = indices
+
+    def forward(self, x):
+        return self.main_module.forward(x, self.indices)

sources/neuraloperator/neuralop/layers/fourier_continuation.py

@@ -0,0 +1,453 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from numpy.polynomial.legendre import Legendre
+import warnings
+from pathlib import Path
+import tensorly as tl
+
+
+class FourierContinuation(nn.Module):
+    """Base class for Fourier Continuation implementations.
+
+    Fourier Continuation is a technique for extending non-periodic functions to periodic
+    ones on larger domains, enabling the use of spectral methods for differentiation
+    and solving PDEs. This base class provides the common interface and methods for
+    different Fourier Continuation approaches (Legendre polynomials, Gram matrices, etc.).
+
+    This allows spectral methods such as spectral differentiation to be applied to
+    non-periodic functions by working on the extended periodic domain.
+    """
+
+    def __init__(self, d=5, n_additional_pts=50):
+        """
+        Initialize FourierContinuation with specified parameters.
+
+        Parameters
+        ----------
+        d : int, optional
+            Number of matching points on the left and right boundaries, by default 5
+        n_additional_pts : int, optional
+            Number of additional points to add for continuation, by default 50
+        """
+        super().__init__()
+
+        self.d = d
+        self.n_additional_pts = n_additional_pts
+
+    def extend(self, x, dim):
+        """
+        Extend tensor along specified dimensions using Fourier Continuation.
+
+        This method extends non-periodic functions to periodic ones by adding
+        continuation points on both sides of the specified dimensions using
+        TensorLy's multi_mode_dot for efficient multi-dimensional extension.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor to extend. Must have at least 2*d points along each
+            dimension to be extended (for boundary value extraction).
+        dim : int or tuple of ints,
+            Dimensions along which to extend:
+            - If int: extend along the last dim axes (e.g. dim=2 extends along the last 2 axes)
+            - If tuple: extend along the specified axes (supports negative indexing)
+
+        Returns
+        -------
+        torch.Tensor
+            Extended tensor with additional points added along specified dimensions.
+            Each extended dimension will have n_additional_pts more points than the input.
+        """
+
+        # Convert input dimension(s) to list of axes to extend along:
+        if isinstance(dim, int):
+            # If dim is an integer n, extend along the last n dimensions
+            axes = list(range(-dim, 0))
+        else:
+            # If dim is a tuple, extend along those specific dimensions
+            axes = list(dim)
+
+        # Convert negative axes to positive indices
+        axes = [a if a >= 0 else x.ndim + a for a in axes]
+
+        # Create extension matrices for each axis
+        # Each matrix maps input tensor along one axis to extended tensor
+        extension_matrices = []  # List of torch tensors, each shape: (extended_size, original_size)
+        modes = []  # List of axis indices to extend along
+
+        for axis in axes:
+            # Get the extension matrix for this axis
+            ext_mat = self._get_extension_matrix_for_axis(x, axis)
+            extension_matrices.append(ext_mat)
+            modes.append(axis)
+
+        # Use TensorLy's multi_mode_dot to apply all extensions simultaneously
+        # Input: x (original shape), matrices (list of extension matrices), modes (axis indices)
+        # Output: extended tensor with shape modified along specified axes
+        return tl.tenalg.multi_mode_dot(x, extension_matrices, modes=modes)
+
+    def _get_extension_matrix_for_axis(self, x, axis):
+        """
+        Get the extension matrix for a specific axis using Fourier continuation.
+
+        This method creates a matrix that maps the input tensor along one axis
+        to the extended tensor using the Fourier continuation approach.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+        axis : int
+            Axis for which to get the extension matrix
+
+        Returns
+        -------
+        torch.Tensor
+            Extension matrix for the specified axis
+        """
+
+        axis_size = x.shape[axis]  # Original size along the axis to extend
+        extended_size = axis_size + self.n_additional_pts  # Final size after extension
+        c = self.n_additional_pts // 2  # Number of continuation points on each side
+
+        # Create the extension matrix, which maps the input to the extended output
+        # Shape: (extended_size, axis_size) where extended_size = axis_size + n_additional_pts
+        ext_mat = torch.zeros((extended_size, axis_size), dtype=x.dtype, device=x.device)
+        
+        # Place identity matrix in the middle (original values)
+        ext_mat[c:c+axis_size, :] = torch.eye(axis_size, dtype=x.dtype, device=x.device)
+        
+        # Get the extension matrix for boundary points
+        ext_mat_boundary = self.ext_mat.to(dtype=x.dtype, device=x.device)
+
+        # Fill in the continuation regions
+        if c > 0:
+            # The extension matrix maps [right_bnd, left_bnd] to continuation values
+            # where ext_mat_boundary has shape (n_additional_pts, 2*d)
+            # and maps [right_bnd, left_bnd] to [left_cont, right_cont]
+
+            # Left continuation: use the last c rows of the extension matrix
+            # These map [right_bnd, left_bnd] to left continuation values
+            ext_mat[:c, :self.d] = ext_mat_boundary[-c:, self.d:]  # right_bnd -> left_cont
+            ext_mat[:c, axis_size-self.d:] = ext_mat_boundary[-c:, :self.d]  # left_bnd -> left_cont
+            
+            # Right continuation: use the first c rows of the extension matrix  
+            # These map [right_bnd, left_bnd] to right continuation values
+            ext_mat[-c:, :self.d] = ext_mat_boundary[:c, self.d:]  # right_bnd -> right_cont
+            ext_mat[-c:, axis_size-self.d:] = ext_mat_boundary[:c, :self.d]  # left_bnd -> right_cont
+        
+        return ext_mat
+
+    def forward(self, x, dim):
+        """
+        Forward pass that calls the extend method.
+
+        This method extends non-periodic functions to periodic ones by adding
+        continuation points on both sides of the specified dimensions.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor to extend. Must have at least 2*d points along each
+            dimension to be extended (for boundary value extraction).
+        dim : int or tuple of ints,
+            Dimensions along which to extend:
+            - If int: extend along the last dim axes (e.g. dim=2 extends along the last 2 axes)
+            - If tuple: extend along the specified axes (supports negative indexing)
+
+        Returns
+        -------
+        torch.Tensor
+            Extended tensor with additional points added along specified dimensions.
+            Each extended dimension will have n_additional_pts more points than the input.
+        """
+        return self.extend(x, dim)
+
+    def restrict(self, x, dim):
+        """
+        Remove Fourier continuation extension points to restore original domain size.
+
+        This method reverses the extension process by removing the continuation points
+        that were added during Fourier continuation.
+
+        It removes n_additional_pts//2 points from each side of the specified dimensions.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Extended tensor from Fourier continuation. Must have been extended using
+            the same n_additional_pts parameter as this instance.
+        dim : int or tuple of ints
+            Dimensions along which to restrict:
+            - If int: restrict along the last dim axes (e.g. dim=2 restricts along the last 2 axes)
+            - If tuple: restrict along the specified axes (supports negative indexing)
+
+        Returns
+        -------
+        torch.Tensor
+            Tensor with original domain size. Each restricted dimension will have
+            n_additional_pts fewer points than the input (n_additional_pts//2 removed
+            from each side).
+        """
+
+        # Convert input dimension(s) to list of axes to restrict along:
+        if isinstance(dim, int):
+            # If dim is an integer n, restrict along the last n dimensions
+            axes = list(range(-dim, 0))
+        else:
+            # If dim is a tuple, restrict along those specific dimensions
+            axes = list(dim)
+
+        # Convert negative axes to positive for easier handling
+        axes = [a if a >= 0 else x.ndim + a for a in axes]
+
+        # Create slices to restrict along each axis
+        c = self.n_additional_pts // 2  # Number of points to remove from each side
+        slices = [slice(None)] * x.ndim
+
+        for axis in axes:
+            # For each axis to restrict, remove c points from each side
+            slices[axis] = slice(c, -c)
+
+        # Return restricted tensor with reduced size along specified axes
+        return x[tuple(slices)]
+
+
+class FCLegendre(FourierContinuation):
+    """Fourier Continuation using Legendre polynomials.
+
+    This class implements Fourier Continuation using Legendre polynomial basis functions
+    to extend non-periodic functions to periodic ones on larger domains. The method works
+    by fitting Legendre polynomials to boundary values and using them to compute
+    continuation values that make the extended function periodic.
+
+    Legendre polynomials P_n(x) are orthogonal polynomials with weight w=1 on [-1, 1]:
+        ∫_{-1}^{1} P_j(x) P_k(x) dx = 2/(2j+1) δ_{jk}
+
+    The extension process:
+    1. Extract d boundary points from each end of the input signal
+    2. Fit a linear combination of Legendre polynomials to these boundary values
+    3. Use the fitted polynomials to compute continuation values
+    4. Concatenate the continuation with the original signal
+
+    """
+
+    def __init__(self, d=5, n_additional_pts=50, rcond=1e-15):
+        """
+        Initialize FCLegendre with specified parameters.
+
+        Parameters
+        ----------
+        d : int
+            Number of matching points on the left and right boundaries
+            Related to the degree of the Legendre polynomial basis used for extension (degree 2d-1).
+            By default 6
+        n_additional_pts : int
+            Number of additional points to add for continuation, by default 50
+            Lower values of d typically require more n_additional_pts points
+        rcond : float, optional
+            Cutoff for small singular values for the pseudoinverse of the extension matrix
+            Singular values less than or equal to rcond * largest_singular_value are set to zero
+            This can be adjusted for numerical stability, especially for larger values of d.
+            A smaller value can lead to more stable results, but may also introduce numerical errors.
+            By default 1e-15 (same as numpy default for np.linalg.pinv)
+        """
+        super().__init__(d, n_additional_pts)
+
+        self.rcond = rcond
+        self.compute_extension_matrix()
+
+    def compute_extension_matrix(self):
+        """
+        Compute the extension matrix using Legendre polynomials.
+
+        This method constructs the matrix that maps boundary values to continuation
+        values using Legendre polynomial basis functions.
+        """
+
+        total_points = 2 * self.d + self.n_additional_pts
+
+        # Use [-1,1] interval where Legendre polynomials are orthogonal
+        a, b = -1.0, 1.0
+
+        # Generate uniform grid on [-1,1] with total_points points
+        h = (b - a) / (total_points - 1)
+        full_grid = a + h * np.arange(total_points, dtype=np.float64)
+
+        # Extract points for fitting (d points from each end)
+        fit_grid = np.concatenate((full_grid[0 : self.d], full_grid[-self.d :]), 0)
+
+        # Extract points for extension (middle points)
+        extension_grid = full_grid[self.d : -self.d]
+
+        # Construct normalized Legendre polynomials
+        # numpy.polynomial.legendre.Legendre are orthogonal but not normalized on [-1,1]:
+        #    ∫_{-1}^{1} P_j(x) P_k(x) dx = 2/(2j+1) δ_{jk}
+        # Normalization can improve numerical stability for larger values of d
+        I = np.eye(2 * self.d, dtype=np.float64)
+        polynomials = [
+            np.sqrt((2 * j + 1) / 2) * Legendre(I[j, :]) for j in range(2 * self.d)
+        ]
+
+        # Evaluate normalized polynomials on the fit and extension grids
+        X = np.stack([P(fit_grid) for P in polynomials], axis=1)  # Fit grid evaluations
+        Q = np.stack([P(extension_grid) for P in polynomials], axis=1)  # Extension grid evaluations
+
+        # Compute extension matrix using pseudoinverse
+        ext_mat = Q @ np.linalg.pinv(X, rcond=self.rcond)
+
+        # Register matrices as persistent buffers for the module
+        self.register_buffer("ext_mat", torch.from_numpy(ext_mat))
+        self.register_buffer("ext_mat_T", self.ext_mat.T.clone())
+
+        return self.ext_mat
+
+
+class FCGram(FourierContinuation):
+    """Fourier Continuation using Gram matrices.
+
+    This class implements the FC-Gram algorithm described in Section 3.1 of:
+    Amlani, F., & Bruno, O. P. (2016). An FC-based spectral solver for
+    elastodynamic problems in general three-dimensional domains.
+    Journal of Computational Physics, 307, 333-354.
+
+    The algorithm uses pre-computed Gram matrices (ArQr, AlQl) to perform
+    Fourier Continuation of discretized functions.
+
+    If the required pre-computed FCGram matrices are not available, they
+    can be computed using the MATLAB code from the FCGram repository
+    https://github.com/neuraloperator/FCGram/
+    and then saved to the appropriate matrices_path directory in .npz format.
+
+    The matrices are:
+    - ArQr: Right boundary continuation matrix
+    - AlQl: Left boundary continuation matrix
+
+    The matrices are saved in the .npz format.
+
+    """
+
+    def __init__(self, d=5, n_additional_pts=50, matrices_path=None):
+        """
+        Initialize FCGram with specified parameters.
+
+        Parameters
+        ----------
+        d : int
+            Number of matching points on the left and right boundaries
+            Degree of the Gram polynomial d
+            Typically between 3 and 8 (precomputed matrices available for d in {2,3,4,5,6,7,8}).
+            d=3,4,5,6 are typically good choices, by default 6.
+        n_additional_pts : int
+            Number of continuation points. By default 50.
+            Adds n_additional_pts//2 points on each side of the input signal.
+            Precomputed matrices available only for n_additional_pts = 50.
+            Unlike for FCLegendre, it is usually not necessary to change this parameter.
+        matrices_path : str or Path, optional
+            Path to directory containing FCGram matrices.
+            If None, uses the directory containing this file, by default None
+        """
+        super().__init__(d, n_additional_pts)
+
+        if self.n_additional_pts % 2 == 1:
+            warnings.warn("n_additional_pts must be even, rounding down.", UserWarning)
+            self.n_additional_pts -= 1
+
+        self.c = int(self.n_additional_pts // 2)
+
+        if matrices_path is None:
+            self.matrices_path = Path(__file__).parent / "fcgram_matrices"
+        else:
+            self.matrices_path = Path(matrices_path)
+
+        # Load pre-computed FCGram matrices
+        self.load_matrices()
+
+    def _get_extension_matrix_for_axis(self, x, axis):
+        """
+        Get the extension matrix for a specific axis using FC-Gram algorithm.
+
+        This method creates a matrix that maps the input tensor along one axis
+        to the extended tensor using pre-computed Gram matrices.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor
+        axis : int
+            Axis for which to get the extension matrix
+
+        Returns
+        -------
+        torch.Tensor
+            Extension matrix for the specified axis
+        """
+        axis_size = x.shape[axis]
+        extended_size = axis_size + self.n_additional_pts
+        c = self.n_additional_pts // 2
+
+        # Create the extension matrix
+        ext_mat = torch.zeros((extended_size, axis_size), dtype=x.dtype, device=x.device)
+        
+        # Place identity matrix in the middle (original values)
+        ext_mat[c:c+axis_size, :] = torch.eye(axis_size, dtype=x.dtype, device=x.device)
+        
+        # Get pre-computed Gram matrices
+        AlQl = self.AlQl.to(dtype=x.dtype, device=x.device)
+        ArQr = self.ArQr.to(dtype=x.dtype, device=x.device)
+
+        # Fill in the continuation regions
+        if c > 0:
+            # Left continuation: map left boundary to left continuation
+            ext_mat[:c, : self.d] = AlQl[:c, :]
+
+            # Right continuation: map right boundary to right continuation
+            ext_mat[-c:, axis_size - self.d :] = ArQr[:c, :]
+
+        return ext_mat
+
+    def load_matrices(self):
+        """
+        Load the pre-computed FCGram matrices from .npz files.
+
+        This method loads the pre-computed Gram matrices required for the FC-Gram
+        algorithm. The matrices are stored in .npz format and contain the optimized
+        continuation matrices for the specified (d, c) parameter combination.
+
+        The loaded matrices are:
+        - ArQr: Right boundary continuation matrix
+        - AlQl: Left boundary continuation matrix
+
+        These matrices are registered as PyTorch buffers so they are automatically
+        moved to the correct device (CPU/GPU) when the module is moved.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the required .npz file is not found in the matrices_path directory.
+            The file should be named 'FCGram_data_d{d}_c{c}.npz' where c = n_additional_pts // 2.
+
+        Note
+        ----
+        If the required matrices are not available, they can be computed using the
+        MATLAB code from the FCGram repository:
+        https://github.com/neuraloperator/FCGram/
+
+        The computed matrices should be saved in .npz format in the matrices_path
+        directory with the correct naming convention.
+        """
+        filepath = self.matrices_path / f"FCGram_data_d{self.d}_c{self.c}.npz"
+
+        if not filepath.exists():
+            raise FileNotFoundError(
+                f"FCGram matrices not found at {filepath}. \n"
+                f"Please ensure the .npz file exists with d={self.d}, c={self.c}."
+            )
+
+        # Load matrices from .npz file
+        npz_data = np.load(str(filepath))
+
+        # Extract matrices, convert to torch tensors, and register as buffers so they are moved to GPU
+        self.register_buffer("ArQr", torch.from_numpy(npz_data["ArQr"]))
+        self.register_buffer("AlQl", torch.from_numpy(npz_data["AlQl"]))

sources/neuraloperator/neuralop/layers/gno_block.py

@@ -0,0 +1,250 @@
+from typing import List, Literal, Optional, Callable
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from .channel_mlp import LinearChannelMLP
+from .integral_transform import IntegralTransform
+from .neighbor_search import NeighborSearch
+from .embeddings import SinusoidalEmbedding
+
+
+class GNOBlock(nn.Module):
+    """Graph Neural Operator layer 
+    
+    It is a resolution-invariant operator that maps a function defined
+    over one coordinate mesh to another defined over another coordinate mesh using
+    a pointwise kernel integral that takes contributions from neighbors of distance 1
+    within a graph constructed via neighbor search with a specified radius.
+    The exact implementation details of the GNO layer architecture are discussed in [1]_.
+
+    Optionally, if provided, the input and output queries can have a positional embedding
+    applied using the argument pos_embedding.
+
+    The kernel integral computed in IntegralTransform computes one of:
+    (a) \\int_{A(x)} k(x, y) dy
+    (b) \\int_{A(x)} k(x, y) * f(y) dy
+    (c) \\int_{A(x)} k(x, y, f(y)) dy
+    (d) \\int_{A(x)} k(x, y, f(y)) * f(y) dy
+
+    Parameters
+    ----------
+    in_channels : int
+        Number of channels in input function. Only used if transform_type
+        is (c) "nonlinear" or (d) "nonlinear_kernelonly"
+    out_channels : int
+        Number of channels in output function
+    coord_dim : int
+        Dimension of domain on which x and y are defined
+    radius : float
+        Radius in which to search for neighbors
+    weighting_fn : Callable, optional
+        Optional squared-norm weighting function to use for Mollified GNO layer
+        by default None. See neuralop.layers.gno_weighting_functions for more details.
+    reduction : Literal['sum', 'mean']
+        Whether to aggregate information from each neighborhood in the
+        integral transform by summing ('sum') or averaging ('mean'), by default 'sum'
+
+    Other Parameters
+    ----------------
+    transform_type : str, optional
+        Which integral transform to compute. Options: 'linear_kernelonly', 'linear', 'nonlinear_kernelonly', 'nonlinear'.
+        The mapping is:
+        'linear_kernelonly' -> (a)
+        'linear' -> (b) [DEFAULT]
+        'nonlinear_kernelonly' -> (c)
+        'nonlinear' -> (d)
+        If the input f is not given then (a) is computed
+        by default independently of this parameter, by default 'linear'
+    pos_embedding_type: literal {'transformer', 'nerf'} | None, optional
+        Type of positional embedding to use during the kernel integral transform.
+        Options: 'transformer', 'nerf', None. See `neuralop.layers.embeddings.SinusoidalEmbedding` for more details, by default 'transformer'
+    pos_embedding_channels : int, optional
+        Per-channel dimension of optional positional embedding to use, by default 32
+    pos_embedding_max_positions: int, optional
+        `max_positions` parameter for SinusoidalEmbedding of type `'transformer'`. If
+        `pos_embedding_type != 'transformer'`, this value is not used, by default 10000
+    channel_mlp_layers : List[int], optional
+        List of layer widths to dynamically construct
+        LinearChannelMLP network to parameterize kernel k, by default None
+    channel_mlp_non_linearity : torch.nn function, optional
+        Activation function for ChannelMLPLinear above, by default F.gelu
+    channel_mlp : nn.Module, optional
+        ChannelMLP parametrizing the kernel k. Input dimension
+        should be dim x + dim y or dim x + dim y + dim f.
+        ChannelMLP should not be pointwise and should only operate across
+        channels to preserve the discretization-invariance of the
+        kernel integral. If you have more specific needs than the LinearChannelMLP,
+        this argument allows you to pass your own Module to parameterize the kernel k.
+        Default None, by default None
+    use_torch_scatter_reduce : bool, optional
+        Whether to use torch-scatter to perform grouped reductions in the IntegralTransform.
+        If False, uses native Python reduction in neuralop.layers.segment_csr, by default True
+
+        .. warning::
+
+            torch-scatter is an optional dependency that conflicts with the newest versions of PyTorch,
+            so you must handle the conflict explicitly in your environment. See :ref:`torch_scatter_dependency`
+            for more information.
+    use_open3d_neighbor_search : bool, optional
+        Whether to use open3d for fast 3d neighbor search, by default True.
+
+        .. note ::
+            If the coordinates provided are not 3D, the GNOBlock automatically
+            uses PyTorch native fallback neighbor search.
+
+    Examples
+    --------
+    ```
+    >>> gno = GNOBlock(in_channels=2, out_channels=12, coord_dim=3, radius=0.035)
+
+    >>> gno
+    GNOBlock(
+        (pos_embedding): SinusoidalEmbedding()
+        (neighbor_search): NeighborSearch()
+        (integral_transform): IntegralTransform(
+            (channel_mlp): LinearChannelMLP(
+            (fcs): ModuleList(
+                (0): Linear(in_features=384, out_features=128, bias=True)
+                (1): Linear(in_features=128, out_features=256, bias=True)
+                (2): Linear(in_features=256, out_features=128, bias=True)
+                (3): Linear(in_features=128, out_features=12, bias=True)
+            )
+            )
+        )
+    )
+    ```
+
+    References
+    ----------
+    .. [1] Zongyi Li, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya,
+        Anima Anandkumar (2020). "Neural Operator: Graph Kernel Network for
+        Partial Differential Equations." ArXiV, https://arxiv.org/pdf/2003.03485.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        coord_dim: int,
+        radius: float,
+        transform_type="linear",
+        weighting_fn: Optional[Callable] = None,
+        reduction: Literal["sum", "mean"] = "sum",
+        pos_embedding_type: str = "transformer",
+        pos_embedding_channels: int = 32,
+        pos_embedding_max_positions: int = 10000,
+        channel_mlp_layers: List[int] = [128, 256, 128],
+        channel_mlp_non_linearity=F.gelu,
+        channel_mlp: nn.Module = None,
+        use_torch_scatter_reduce: bool = True,
+        use_open3d_neighbor_search: bool = True,
+    ):
+        super().__init__()
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.coord_dim = coord_dim
+
+        self.radius = radius
+
+        # Apply sinusoidal positional embedding
+        self.pos_embedding_type = pos_embedding_type
+        if self.pos_embedding_type in ["nerf", "transformer"]:
+            self.pos_embedding = SinusoidalEmbedding(
+                in_channels=coord_dim,
+                num_frequencies=pos_embedding_channels,
+                embedding_type=pos_embedding_type,
+                max_positions=pos_embedding_max_positions,
+            )
+        else:
+            self.pos_embedding = None
+
+        # Create in-to-out nb search module
+        if use_open3d_neighbor_search:
+            assert self.coord_dim == 3, f"Error: open3d is only designed for 3d data, \
+                GNO instantiated for dim={coord_dim}"
+        self.neighbor_search = NeighborSearch(
+            use_open3d=use_open3d_neighbor_search, return_norm=weighting_fn is not None
+        )
+
+        # create proper kernel input channel dim
+        if self.pos_embedding is None:
+            # x and y dim will be coordinate dim if no pos embedding is applied
+            kernel_in_dim = self.coord_dim * 2
+            kernel_in_dim_str = "dim(y) + dim(x)"
+        else:
+            # x and y dim will be embedding dim if pos embedding is applied
+            kernel_in_dim = self.pos_embedding.out_channels * 2
+            kernel_in_dim_str = "dim(y_embed) + dim(x_embed)"
+
+        if transform_type == "nonlinear" or transform_type == "nonlinear_kernelonly":
+            kernel_in_dim += self.in_channels
+            kernel_in_dim_str += " + dim(f_y)"
+
+        if channel_mlp is not None:
+            assert channel_mlp.in_channels == kernel_in_dim, f"Error: expected ChannelMLP to take\
+                  input with {kernel_in_dim} channels (feature channels={kernel_in_dim_str}),\
+                      got {channel_mlp.in_channels}."
+            assert channel_mlp.out_channels == out_channels, f"Error: expected ChannelMLP to have\
+                 {out_channels=} but got {channel_mlp.in_channels=}."
+            channel_mlp = channel_mlp
+
+        elif channel_mlp_layers is not None:
+            if channel_mlp_layers[0] != kernel_in_dim:
+                channel_mlp_layers = [kernel_in_dim] + channel_mlp_layers
+            if channel_mlp_layers[-1] != self.out_channels:
+                channel_mlp_layers.append(self.out_channels)
+            channel_mlp = LinearChannelMLP(layers=channel_mlp_layers, non_linearity=channel_mlp_non_linearity)
+
+        # Create integral transform module
+        self.integral_transform = IntegralTransform(
+            channel_mlp=channel_mlp,
+            transform_type=transform_type,
+            use_torch_scatter=use_torch_scatter_reduce,
+            weighting_fn=weighting_fn,
+            reduction=reduction,
+        )
+
+    def forward(self, y, x, f_y=None):
+        """Compute a GNO neighbor search and kernel integral transform.
+
+        Parameters
+        ----------
+        y : torch.Tensor of shape [n, d1]
+            n points of dimension d1 specifying
+            the space to integrate over.
+            If batched, these must remain constant
+            over the whole batch so no batch dim is needed.
+        x : torch.Tensor of shape [m, d1], default None
+            m points of dimension d1 over which the
+            output function is defined. Must share domain
+            with y
+        f_y : torch.Tensor of shape [batch, n, d2] or [n, d2], default None
+            Function to integrate the kernel against defined
+            on the points y. The kernel is assumed diagonal
+            hence its output shape must be d3 for the transforms
+            (b) or (d). If None, (a) is computed.
+
+        Returns
+        -------
+        out_features : torch.Tensor of shape [batch, m, d3] or [m, d3]
+            Output function given on the points x.
+            d4 is the output size of the kernel k.
+        """
+
+        neighbors_dict = self.neighbor_search(data=y, queries=x, radius=self.radius)
+
+        if self.pos_embedding is not None:
+            y_embed = self.pos_embedding(y)
+            x_embed = self.pos_embedding(x)
+        else:
+            y_embed = y
+            x_embed = x
+
+        out_features = self.integral_transform(
+            y=y_embed, x=x_embed, neighbors=neighbors_dict, f_y=f_y
+        )
+
+        return out_features

sources/neuraloperator/neuralop/layers/gno_weighting_functions.py

@@ -0,0 +1,93 @@
+from functools import partial
+import torch
+
+
+def bump_cutoff(x, radius=1.0, scale=1.0, eps=1e-7):
+    """
+    Bump cutoff function with exponential decay.
+
+    Formula: w(x) = scale * e * exp(-1/(1-d² + ε))
+    where d = x/radius, x ∈ [0, radius], and ε is a small constant for numerical stability.
+    """
+    out = x.clip(0.0, radius) / radius
+    out = -1 / ((1 - out**2) + eps)
+    return out.exp() * torch.e * scale
+
+
+def half_cos_cutoff(x, radius=1.0, scale=1.0):
+    """
+    Half-cosine cutoff function with smooth decay.
+
+    Formula: w(x) = scale * (0.5 * cos(π * d) + 0.5)
+    where d = x/radius, x ∈ [0, radius].
+    """
+    x = x / radius
+    return scale * (0.5 * torch.cos(torch.pi * x) + 0.5)
+
+
+def quadr_cutoff(x, radius=1.0, scale=1.0):
+    """
+    Quadratic cutoff function with piecewise definition.
+
+    Formula: w(x) = scale * {1 - 2d², if d < 0.5
+                           {2(1 - d)², if d ≥ 0.5
+    where d = x/radius, x ∈ [0, radius].
+    """
+    x = x / radius
+    left = 1 - 2 * x**2
+    right = 2 * (1 - x) ** 2
+    return scale * torch.where(x < 0.5, left, right)
+
+
+def quartic_cutoff(x, radius=1.0, scale=1.0):
+    """
+    Quartic cutoff function with fourth-order polynomial.
+
+    Formula: w(x) = (scale/radius⁴) * x⁴ - (2*scale/radius²) * x² + scale
+    where d = x/radius, x ∈ [0, radius].
+    """
+    a = scale / radius**4
+    c = -2 * scale / radius**2
+    return a * x**4 + c * x**2 + scale
+
+
+def octic_cutoff(x, radius=1.0, scale=1.0):
+    """
+    Octic cutoff function with eighth-order polynomial.
+
+    Formula: w(x) = scale * (-3d⁸ + 8d⁶ - 6d⁴ + 1)
+    where d = x/radius, x ∈ [0, radius].
+    """
+    x = x / radius
+    return scale * (-3 * x**8 + 8 * x**6 - 6 * x**4 + 1)
+
+
+WEIGHTING_FN_REGISTRY = {
+    "bump": bump_cutoff,
+    "half_cos": half_cos_cutoff,
+    "quadr": quadr_cutoff,
+    "quartic": quartic_cutoff,
+    "octic": octic_cutoff,
+}
+
+
+def dispatch_weighting_fn(weight_function_name: str, sq_radius: float, scale: float):
+    """
+    Select a GNO weighting function for use in output GNO
+    of a Mollified Graph Neural Operator-based model. See [1]_ (add later)
+
+    Parameters
+    ----------
+    weight_function_name : str Literal
+        name of weighting function to use, keyed to ``WEIGHTING_FN_REGISTRY`` above
+    sq_radius : float
+        squared radius of GNO neighborhoods for Nyström approximation
+    scale : float
+        factor by which to scale all weights
+    """
+    base_func = WEIGHTING_FN_REGISTRY.get(weight_function_name)
+    if base_func is None:
+        raise NotImplementedError(
+            f"weighting function should be one of {list(WEIGHTING_FN_REGISTRY.keys())}, got {weight_function_name}"
+        )
+    return partial(base_func, radius=sq_radius, scale=scale)

sources/neuraloperator/neuralop/layers/integral_transform.py

@@ -0,0 +1,227 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from .channel_mlp import LinearChannelMLP
+from .segment_csr import segment_csr
+
+
+class IntegralTransform(nn.Module):
+    """Integral Kernel Transform (GNO).
+    
+    It computes one of the following:
+        (a) \\int_{A(x)} k(x, y) dy
+        (b) \\int_{A(x)} k(x, y) * f(y) dy
+        (c) \\int_{A(x)} k(x, y, f(y)) dy
+        (d) \\int_{A(x)} k(x, y, f(y)) * f(y) dy
+
+    x : Points for which the output is defined
+
+    y : Points for which the input is defined
+    A(x) : A subset of all points y (depending on\
+        each x) over which to integrate
+
+    k : A kernel parametrized as a MLP (LinearChannelMLP)
+    
+    f : Input function to integrate against given\
+        on the points y
+
+    If f is not given, a transform of type (a)
+    is computed. Otherwise transforms (b), (c),
+    or (d) are computed. The sets A(x) are specified
+    as a graph in CRS format.
+
+    Parameters
+    ----------
+    channel_mlp : torch.nn.Module, optional
+        MLP parametrizing the kernel k. Input dimension
+        should be dim x + dim y or dim x + dim y + dim f.
+        MLP should not be pointwise and should only operate across
+        channels to preserve the discretization-invariance of the 
+        kernel integral, by default None
+    channel_mlp_layers : list, optional
+        List of layers sizes speficing a MLP which
+        parametrizes the kernel k. The MLP will be
+        instansiated by the LinearChannelMLP class, by default None
+    channel_mlp_non_linearity : callable, optional
+        Non-linear function used to be used by the
+        LinearChannelMLP class, by default F.gelu. Only used if channel_mlp_layers is
+        given and channel_mlp is None, by default torch.nn.functional.gelu
+    transform_type : str, optional
+        Which integral transform to compute. Options: 'linear_kernelonly', 'linear', 'nonlinear_kernelonly', 'nonlinear'.
+        The mapping is:
+        'linear_kernelonly' -> (a)
+        'linear' -> (b)
+        'nonlinear_kernelonly' -> (c)
+        'nonlinear' -> (d)
+        If the input f is not given then (a) is computed
+        by default independently of this parameter, by default 'linear'
+    use_torch_scatter : bool, optional
+        Whether to use torch-scatter to perform grouped reductions in the IntegralTransform. 
+        If False, uses native Python reduction in neuralop.layers.segment_csr, by default True
+
+        .. warning:: 
+
+            torch-scatter is an optional dependency that conflicts with the newest versions of PyTorch,
+            so you must handle the conflict explicitly in your environment. See :ref:`torch_scatter_dependency` 
+            for more information. 
+    """
+
+    def __init__(
+        self,
+        channel_mlp=None,
+        channel_mlp_layers=None,
+        channel_mlp_non_linearity=F.gelu,
+        transform_type="linear",
+        weighting_fn=None,
+        reduction="sum",
+        use_torch_scatter=True,
+    ):
+        super().__init__()
+
+        assert channel_mlp is not None or channel_mlp_layers is not None
+
+        self.reduction = reduction
+        self.transform_type = transform_type
+        self.use_torch_scatter = use_torch_scatter
+        if (
+            self.transform_type != "linear_kernelonly"
+            and self.transform_type != "linear"
+            and self.transform_type != "nonlinear_kernelonly"
+            and self.transform_type != "nonlinear"
+        ):
+            raise ValueError(
+                f"Got transform_type={transform_type} but expected one of "
+                "[linear_kernelonly, linear, nonlinear_kernelonly, nonlinear]"
+            )
+
+        if channel_mlp is None:
+            self.channel_mlp = LinearChannelMLP(
+                layers=channel_mlp_layers, non_linearity=channel_mlp_non_linearity
+            )
+        else:
+            self.channel_mlp = channel_mlp
+
+        self.weighting_fn = weighting_fn
+
+    def forward(self, y, neighbors, x=None, f_y=None, weights=None):
+        """Compute a kernel integral transform. Assumes x=y if not specified.
+
+        Integral is taken w.r.t. the neighbors.
+
+        If no weights are given, a Monte-Carlo approximation is made.
+
+        .. note :: For transforms of type 0 or 2, out channels must be
+            the same as the channels of f
+
+        Parameters
+        ----------
+        y : torch.Tensor of shape [n, d1]
+            n points of dimension d1 specifying
+            the space to integrate over.
+            If batched, these must remain constant
+            over the whole batch so no batch dim is needed.
+        neighbors : dict
+            The sets :math:`A(x)` given in CRS format. The
+            dict must contain the keys "neighbors_index"
+            and "neighbors_row_splits." For descriptions
+            of the two, see NeighborSearch.
+            If batch > 1, the neighbors must be constant
+            across the entire batch.
+        x : torch.Tensor of shape [m, d2], default None
+            m points of dimension d2 over which the
+            output function is defined. If None,
+            x = y.
+        f_y : torch.Tensor of shape [batch, n, d3] or [n, d3], default None
+            Function to integrate the kernel against defined
+            on the points y. The kernel is assumed diagonal
+            hence its output shape must be d3 for the transforms
+            (b) or (d). If None, (a) is computed.
+        weights : torch.Tensor of shape [n,], default None
+            Weights for each point y proprtional to the
+            volume around f(y) being integrated. For example,
+            suppose d1=1 and let y_1 < y_2 < ... < y_{n+1}
+            be some points. Then, for a Riemann sum,
+            the weights are y_{j+1} - y_j. If None,
+            :math:`1/|A(x)|` is used.
+
+        Returns
+        -------
+        out_features : torch.Tensor of shape [batch, m, d4] or [m, d4]
+            Output function given on the points x.
+            d4 is the output size of the kernel k.
+        """
+
+        if x is None:
+            x = y
+
+        rep_features = y[neighbors["neighbors_index"]]
+
+        # batching only matters if f_y (latent embedding) values are provided
+        batched = False
+        # f_y has a batch dim IFF batched=True
+        if f_y is not None:
+            if f_y.ndim == 3:
+                batched = True
+                batch_size = f_y.shape[0]
+                in_features = f_y[:, neighbors["neighbors_index"], :]
+            elif f_y.ndim == 2:
+                batched = False
+                in_features = f_y[neighbors["neighbors_index"]]
+
+        num_reps = (
+            neighbors["neighbors_row_splits"][1:]
+            - neighbors["neighbors_row_splits"][:-1]
+        )
+
+        self_features = torch.repeat_interleave(x, num_reps, dim=0)
+
+        agg_features = torch.cat([rep_features, self_features], dim=-1)
+        if f_y is not None and (
+            self.transform_type == "nonlinear_kernelonly"
+            or self.transform_type == "nonlinear"
+        ):
+            if batched:
+                # repeat agg features for every example in the batch
+                agg_features = agg_features.repeat(
+                    [batch_size] + [1] * agg_features.ndim
+                )
+            agg_features = torch.cat([agg_features, in_features], dim=-1)
+
+        rep_features = self.channel_mlp(agg_features)
+
+        if f_y is not None and self.transform_type != "nonlinear_kernelonly":
+            # if we have a batch of outputs (3d incl. batch dim) and unbatched inputs,
+            # create an identical batch dim in rep_features
+            if rep_features.ndim == 2 and batched:
+                rep_features = rep_features.unsqueeze(0).repeat([batch_size] + [1] * rep_features.ndim)
+            rep_features.mul_(in_features)
+
+        # Weight neighbors in each neighborhood, first according to the neighbor search (mollified GNO)
+        # and second according to individually-provided weights.
+        nbr_weights = neighbors.get("weights")
+        if nbr_weights is None:
+            nbr_weights = weights
+        if nbr_weights is None and self.weighting_fn is not None:
+            raise KeyError("if a weighting function is provided, your neighborhoods must contain weights.")
+        if nbr_weights is not None:
+            nbr_weights = nbr_weights.unsqueeze(-1).unsqueeze(0)
+            if self.weighting_fn is not None:
+                nbr_weights = self.weighting_fn(nbr_weights)
+            rep_features.mul_(nbr_weights)
+            reduction = "sum"  # Force sum reduction for weighted GNO layers
+
+        else:
+            reduction = self.reduction
+
+        splits = neighbors["neighbors_row_splits"]
+        if batched:
+            splits = splits.unsqueeze(0).repeat([batch_size] + [1] * (splits.ndim))
+
+        out_features = segment_csr(
+            rep_features,
+            splits,
+            reduction=reduction,
+            use_scatter=self.use_torch_scatter,
+        )
+        return out_features

sources/neuraloperator/neuralop/layers/legacy_spectral_convolution.py

@@ -0,0 +1,742 @@
+import itertools
+
+from typing import List, Optional, Tuple, Union
+
+from ..utils import validate_scaling_factor
+
+# Set warning filter to show each warning only once
+import warnings
+
+warnings.filterwarnings("once", category=UserWarning)
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import torch
+from torch import nn
+
+import tensorly as tl
+from tensorly.plugins import use_opt_einsum
+from tltorch.factorized_tensors.core import FactorizedTensor
+
+from .einsum_utils import einsum_complexhalf
+from .base_spectral_conv import BaseSpectralConv
+from .resample import resample
+
+tl.set_backend("pytorch")
+use_opt_einsum("optimal")
+einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
+def _contract_dense(x, weight, separable=False):
+    order = tl.ndim(x)
+    # batch-size, in_channels, x, y...
+    x_syms = list(einsum_symbols[:order])
+
+    # in_channels, out_channels, x, y...
+    weight_syms = list(x_syms[1:])  # no batch-size
+
+    # batch-size, out_channels, x, y...
+    if separable:
+        out_syms = [x_syms[0]] + list(weight_syms)
+    else:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+
+    eq = f'{"".join(x_syms)},{"".join(weight_syms)}->{"".join(out_syms)}'
+
+    if not torch.is_tensor(weight):
+        weight = weight.to_tensor()
+
+    if x.dtype == torch.complex32:
+        # if x is half precision, run a specialized einsum
+        return einsum_complexhalf(eq, x, weight)
+    else:
+        return tl.einsum(eq, x, weight)
+
+
+def _contract_dense_separable(x, weight, separable=True):
+    if not separable:
+        raise ValueError("This function is only for separable=True")
+    return x * weight
+
+
+def _contract_cp(x, cp_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    rank_sym = einsum_symbols[order]
+    out_sym = einsum_symbols[order + 1]
+    out_syms = list(x_syms)
+    if separable:
+        factor_syms = [einsum_symbols[1] + rank_sym]  # in only
+    else:
+        out_syms[1] = out_sym
+        factor_syms = [einsum_symbols[1] + rank_sym, out_sym + rank_sym]  # in, out
+    factor_syms += [xs + rank_sym for xs in x_syms[2:]]  # x, y, ...
+    eq = f'{x_syms},{rank_sym},{",".join(factor_syms)}->{"".join(out_syms)}'
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, cp_weight.weights, *cp_weight.factors)
+    else:
+        return tl.einsum(eq, x, cp_weight.weights, *cp_weight.factors)
+
+
+def _contract_tucker(x, tucker_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    out_sym = einsum_symbols[order]
+    out_syms = list(x_syms)
+    if separable:
+        core_syms = einsum_symbols[order + 1 : 2 * order]
+        # factor_syms = [einsum_symbols[1]+core_syms[0]] #in only
+        # x, y, ...
+        factor_syms = [xs + rs for (xs, rs) in zip(x_syms[1:], core_syms)]
+
+    else:
+        core_syms = einsum_symbols[order + 1 : 2 * order + 1]
+        out_syms[1] = out_sym
+        factor_syms = [
+            einsum_symbols[1] + core_syms[0],
+            out_sym + core_syms[1],
+        ]  # out, in
+        # x, y, ...
+        factor_syms += [xs + rs for (xs, rs) in zip(x_syms[2:], core_syms[2:])]
+
+    eq = f'{x_syms},{core_syms},{",".join(factor_syms)}->{"".join(out_syms)}'
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, tucker_weight.core, *tucker_weight.factors)
+    else:
+        return tl.einsum(eq, x, tucker_weight.core, *tucker_weight.factors)
+
+
+def _contract_tt(x, tt_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = list(einsum_symbols[:order])
+    weight_syms = list(x_syms[1:])  # no batch-size
+    if not separable:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+    else:
+        out_syms = list(x_syms)
+    rank_syms = list(einsum_symbols[order + 1 :])
+    tt_syms = []
+    for i, s in enumerate(weight_syms):
+        tt_syms.append([rank_syms[i], s, rank_syms[i + 1]])
+    eq = (
+        "".join(x_syms)
+        + ","
+        + ",".join("".join(f) for f in tt_syms)
+        + "->"
+        + "".join(out_syms)
+    )
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, *tt_weight.factors)
+    else:
+        return tl.einsum(eq, x, *tt_weight.factors)
+
+
+def get_contract_fun(weight, implementation="reconstructed", separable=False):
+    """Generic ND implementation of Fourier Spectral Conv contraction
+
+    Parameters
+    ----------
+    weight : tensorly-torch's FactorizedTensor
+    implementation : {'reconstructed', 'factorized'}, default is 'reconstructed'
+        whether to reconstruct the weight and do a forward pass (reconstructed)
+        or contract directly the factors of the factorized weight with the input (factorized)
+    separable : bool
+        whether to use the separable implementation of contraction. This arg is
+        only checked when `implementation=reconstructed`.
+
+    Returns
+    -------
+    function : (x, weight) -> x * weight in Fourier space
+    """
+    if implementation == "reconstructed":
+        if separable:
+            return _contract_dense_separable
+        else:
+            return _contract_dense
+    elif implementation == "factorized":
+        if torch.is_tensor(weight):
+            return _contract_dense
+        elif isinstance(weight, FactorizedTensor):
+            if weight.name.lower().endswith("dense"):
+                return _contract_dense
+            elif weight.name.lower().endswith("tucker"):
+                return _contract_tucker
+            elif weight.name.lower().endswith("tt"):
+                return _contract_tt
+            elif weight.name.lower().endswith("cp"):
+                return _contract_cp
+            else:
+                raise ValueError(f"Got unexpected factorized weight type {weight.name}")
+        else:
+            raise ValueError(
+                f"Got unexpected weight type of class {weight.__class__.__name__}"
+            )
+    else:
+        raise ValueError(
+            f'Got implementation={implementation}, expected "reconstructed" or "factorized"'
+        )
+
+
+Number = Union[int, float]
+
+
+class SpectralConv(BaseSpectralConv):
+    """Old implementation of the Spectral Convolution layer.
+    
+    This implementation is deprecated and might be removed in future versions.
+
+    Parameters
+    ----------
+    in_channels : int, optional
+        Number of input channels
+    out_channels : int, optional
+        Number of output channels
+    n_modes : int tuple
+        total number of modes to keep in Fourier Layer, along each dim
+    separable : bool, default is True
+    init_std : float or 'auto', default is 'auto'
+        std to use for the init
+    n_layers : int, optional
+        Number of Fourier Layers, by default 4
+    incremental_n_modes : None or int tuple, default is None
+        * If not None, this allows to incrementally increase the number of modes
+          in Fourier domain during training. Has to verify n <= N for (n, m) in
+          zip(incremental_n_modes, n_modes).
+
+        * If None, all the n_modes are used.
+
+        This can be updated dynamically during training.
+    factorization : str or None, {'tucker', 'cp', 'tt'}, default is None
+        If None, a single dense weight is learned for the FNO.
+        Otherwise, that weight, used for the contraction in the Fourier domain
+        is learned in factorized form. In that case, `factorization` is the
+        tensor factorization of the parameters weight used.
+    joint_factorization : bool, optional
+        Whether all the Fourier Layers should be parametrized by a single tensor
+        (vs one per layer), by default False Ignored if ``factorization is None``
+    rank : float or rank, optional
+        Rank of the tensor factorization of the Fourier weights, by default 1.0
+        Ignored if ``factorization is None``
+    fixed_rank_modes : bool, optional
+        Modes to not factorize, by default False
+        Ignored if ``factorization is None``
+    fft_norm : str, optional
+        by default 'forward'
+    implementation : {'factorized', 'reconstructed'}, optional, default is 'factorized'
+        If factorization is not None, forward mode to use::
+        * `reconstructed` : the full weight tensor is reconstructed from the
+          factorization and used for the forward pass
+        * `factorized` : the input is directly contracted with the factors of
+          the decomposition
+        Ignored if ``factorization is None``
+    decomposition_kwargs : dict, optional, default is {}
+        Optionaly additional parameters to pass to the tensor decomposition
+        Ignored if ``factorization is None``
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        n_modes,
+        incremental_n_modes=None,
+        bias=True,
+        n_layers=1,
+        separable=False,
+        resolution_scaling_factor: Optional[Union[Number, List[Number]]] = None,
+        fno_block_precision="full",
+        rank=0.5,
+        factorization=None,
+        implementation="reconstructed",
+        fixed_rank_modes=False,
+        joint_factorization=False,
+        decomposition_kwargs: Optional[dict] = None,
+        init_std="auto",
+        fft_norm="backward",
+        device=None,
+        dtype=None,
+    ):
+        super().__init__(dtype=dtype, device=device)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.joint_factorization = joint_factorization
+
+        # We index quadrands only
+        # n_modes is the total number of modes kept along each dimension
+        # half_n_modes is half of that except in the last mode, correponding to
+        # the number of modes to keep in *each* quadrant for each dim
+        if isinstance(n_modes, int):
+            n_modes = [n_modes]
+        self.n_modes = n_modes
+        self.order = len(n_modes)
+
+        half_total_n_modes = [m // 2 for m in n_modes]
+        self.half_total_n_modes = half_total_n_modes
+
+        # We use half_total_n_modes to build the full weights
+        # During training we can adjust incremental_n_modes which will also
+        # update half_n_modes
+        # So that we can train on a smaller part of the Fourier modes and total
+        # weights
+        self.incremental_n_modes = incremental_n_modes
+
+        self.fno_block_precision = fno_block_precision
+        self.rank = rank
+        self.factorization = factorization
+        self.n_layers = n_layers
+        self.implementation = implementation
+
+        self.resolution_scaling_factor: Union[
+            None, List[List[float]]
+        ] = validate_scaling_factor(resolution_scaling_factor, self.order, n_layers)
+
+        if init_std == "auto":
+            init_std = (2 / (in_channels + out_channels)) ** 0.5
+
+        if isinstance(fixed_rank_modes, bool):
+            if fixed_rank_modes:
+                # If bool, keep the number of layers fixed
+                fixed_rank_modes = [0]
+            else:
+                fixed_rank_modes = None
+        self.fft_norm = fft_norm
+
+        # Make sure we are using a Complex Factorized Tensor to parametrize the
+        # conv
+        if factorization is None:
+            factorization = "Dense"  # No factorization
+        if not factorization.lower().startswith("complex"):
+            factorization = f"Complex{factorization}"
+
+        if separable:
+            if in_channels != out_channels:
+                raise ValueError(
+                    "To use separable Fourier Conv, in_channels must be equal "
+                    f"to out_channels, but got in_channels={in_channels} and "
+                    f"out_channels={out_channels}",
+                )
+            weight_shape = (in_channels, *half_total_n_modes)
+        else:
+            weight_shape = (in_channels, out_channels, *half_total_n_modes)
+        self.separable = separable
+
+        self.n_weights_per_layer = 2 ** (self.order - 1)
+        tensor_kwargs = decomposition_kwargs if decomposition_kwargs is not None else {}
+        if joint_factorization:
+            self.weight = FactorizedTensor.new(
+                (self.n_weights_per_layer * n_layers, *weight_shape),
+                rank=self.rank,
+                factorization=factorization,
+                fixed_rank_modes=fixed_rank_modes,
+                **tensor_kwargs,
+            )
+            self.weight.normal_(0, init_std)
+        else:
+            self.weight = nn.ModuleList(
+                [
+                    FactorizedTensor.new(
+                        weight_shape,
+                        rank=self.rank,
+                        factorization=factorization,
+                        fixed_rank_modes=fixed_rank_modes,
+                        **tensor_kwargs,
+                    )
+                    for _ in range(self.n_weights_per_layer * n_layers)
+                ]
+            )
+            for w in self.weight:
+                w.normal_(0, init_std)
+        self._contract = get_contract_fun(
+            self.weight[0], implementation=implementation, separable=separable
+        )
+
+        if bias:
+            self.bias = nn.Parameter(
+                init_std
+                * torch.randn(*((n_layers, self.out_channels) + (1,) * self.order))
+            )
+        else:
+            self.bias = None
+
+    def _get_weight(self, index):
+        if self.incremental_n_modes is not None:
+            return self.weight[index][self.weight_slices]
+        else:
+            return self.weight[index]
+
+    @property
+    def incremental_n_modes(self):
+        return self._incremental_n_modes
+
+    @incremental_n_modes.setter
+    def incremental_n_modes(self, incremental_n_modes):
+        if incremental_n_modes is None:
+            self._incremental_n_modes = None
+            self.half_n_modes = [m // 2 for m in self.n_modes]
+
+        else:
+            if isinstance(incremental_n_modes, int):
+                self._incremental_n_modes = [incremental_n_modes] * len(self.n_modes)
+            else:
+                if len(incremental_n_modes) == len(self.n_modes):
+                    self._incremental_n_modes = incremental_n_modes
+                else:
+                    raise ValueError(
+                        f"Provided {incremental_n_modes} for actual "
+                        f"n_modes={self.n_modes}."
+                    )
+            self.weight_slices = [slice(None)] * 2 + [
+                slice(None, n // 2) for n in self._incremental_n_modes
+            ]
+            self.half_n_modes = [m // 2 for m in self._incremental_n_modes]
+
+    def transform(self, x, layer_index=0, output_shape=None):
+        in_shape = list(x.shape[2:])
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            out_shape = tuple(
+                [
+                    round(s * r)
+                    for (s, r) in zip(in_shape, self.resolution_scaling_factor[layer_index])
+                ]
+            )
+        elif output_shape is not None:
+            out_shape = output_shape
+        else:
+            out_shape = in_shape
+
+        if in_shape == out_shape:
+            return x
+        else:
+            return resample(
+                x,
+                1.0,
+                list(range(2, x.ndim)),
+                output_shape=out_shape,
+            )
+
+    def forward(
+        self, x: torch.Tensor, indices=0, output_shape: Optional[Tuple[int]] = None
+    ):
+        """Generic forward pass for the Factorized Spectral Conv
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            input activation of size (batch_size, channels, d1, ..., dN)
+        indices : int, default is 0
+            if joint_factorization, index of the layers for n_layers > 1
+
+        Returns
+        -------
+        tensorized_spectral_conv(x)
+        """
+        batchsize, channels, *mode_sizes = x.shape
+
+        fft_size = list(mode_sizes)
+        fft_size[-1] = fft_size[-1] // 2 + 1  # Redundant last coefficient
+
+        # Compute Fourier coeffcients
+        fft_dims = list(range(-self.order, 0))
+
+        if self.fno_block_precision == "half":
+            x = x.half()
+
+        x = torch.fft.rfftn(x, norm=self.fft_norm, dim=fft_dims)
+
+        if self.fno_block_precision == "mixed":
+            # if 'mixed', the above fft runs in full precision, but the
+            # following operations run at half precision
+            x = x.chalf()
+
+        if self.fno_block_precision in ["half", "mixed"]:
+            out_fft = torch.zeros(
+                [batchsize, self.out_channels, *fft_size],
+                device=x.device,
+                dtype=torch.chalf,
+            )
+        else:
+            out_fft = torch.zeros(
+                [batchsize, self.out_channels, *fft_size],
+                device=x.device,
+                dtype=torch.cfloat,
+            )
+
+        # We contract all corners of the Fourier coefs
+        # Except for the last mode: there, we take all coefs as redundant modes
+        # were already removed
+        mode_indexing = [((None, m), (-m, None)) for m in self.half_n_modes[:-1]] + [
+            ((None, self.half_n_modes[-1]),)
+        ]
+
+        for i, boundaries in enumerate(itertools.product(*mode_indexing)):
+            # Keep all modes for first 2 modes (batch-size and channels)
+            idx_tuple = [slice(None), slice(None)] + [slice(*b) for b in boundaries]
+
+            # For 2D: [:, :, :height, :width] and [:, :, -height:, width]
+            out_fft[idx_tuple] = self._contract(
+                x[idx_tuple],
+                self._get_weight(self.n_weights_per_layer * indices + i),
+                separable=self.separable,
+            )
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            mode_sizes = tuple(
+                [
+                    round(s * r)
+                    for (s, r) in zip(mode_sizes, self.resolution_scaling_factor[indices])
+                ]
+            )
+
+        if output_shape is not None:
+            mode_sizes = output_shape
+
+        x = torch.fft.irfftn(out_fft, s=mode_sizes, norm=self.fft_norm)
+
+        if self.bias is not None:
+            x = x + self.bias[indices, ...]
+
+        return x
+
+    def get_conv(self, indices):
+        """Returns a sub-convolutional layer from the joint parametrize main-convolution
+
+        The parametrization of sub-convolutional layers is shared with the main one.
+        """
+        if self.n_layers == 1:
+            Warning("A single convolution is parametrized, directly use the main class.")
+            # raise ValueError(
+            #     "A single convolution is parametrized, directly use the main class."
+            # )
+
+        return SubConv(self, indices)
+
+    def __getitem__(self, indices):
+        return self.get_conv(indices)
+
+
+class SubConv(nn.Module):
+    """Class representing one of the convolutions from the mother joint
+    factorized convolution.
+
+    Notes
+    -----
+    This relies on the fact that nn.Parameters are not duplicated:
+    if the same nn.Parameter is assigned to multiple modules, they all point to
+    the same data, which is shared.
+    """
+
+    def __init__(self, main_conv, indices):
+        super().__init__()
+        self.main_conv = main_conv
+        self.indices = indices
+
+    def forward(self, x, **kwargs):
+        if kwargs:
+            warnings.warn(
+                f"SpectralConvWrapper.forward() received unexpected keyword arguments: {list(kwargs.keys())}. "
+                "These arguments will be ignored.",
+                UserWarning,
+                stacklevel=2,
+            )
+        return self.main_conv.forward(x, self.indices, **kwargs)
+
+    def transform(self, x, **kwargs):
+        if kwargs:
+            warnings.warn(
+                f"SpectralConvWrapper.transform() received unexpected keyword arguments: {list(kwargs.keys())}. "
+                "These arguments will be ignored.",
+                UserWarning,
+                stacklevel=2,
+            )
+        return self.main_conv.transform(x, self.indices, **kwargs)
+
+    @property
+    def weight(self):
+        return self.main_conv.get_weight(indices=self.indices)
+
+
+class SpectralConv1d(SpectralConv):
+    """1D Spectral Conv
+
+    This is provided for reference only,
+    see :class:`neuralop.layers.SpectraConv` for the preferred, general implementation
+    """
+
+    def forward(self, x, indices=0):
+        batchsize, channels, width = x.shape
+
+        x = torch.fft.rfft(x, norm=self.fft_norm)
+
+        out_fft = torch.zeros(
+            [batchsize, self.out_channels, width // 2 + 1],
+            device=x.device,
+            dtype=torch.cfloat,
+        )
+        slices = (
+            slice(None),  # Equivalent to: [:,
+            slice(None),  # ............... :,
+            slice(self.half_n_modes[0]),  # :half_n_modes[0]]
+        )
+        out_fft[slices] = self._contract(
+            x[slices], self._get_weight(indices), separable=self.separable
+        )
+
+        if self.resolution_scaling_factor is not None:
+            width = round(width * self.resolution_scaling_factor[0])
+
+        x = torch.fft.irfft(out_fft, n=width, norm=self.fft_norm)
+
+        if self.bias is not None:
+            x = x + self.bias[indices, ...]
+
+        return x
+
+
+class SpectralConv2d(SpectralConv):
+    """2D Spectral Conv, see :class:`neuralop.layers.SpectraConv` for the general case
+
+    This is provided for reference only,
+    see :class:`neuralop.layers.SpectraConv` for the preferred, general implementation
+    """
+
+    def forward(self, x, indices=0):
+        batchsize, channels, height, width = x.shape
+
+        x = torch.fft.rfft2(x.float(), norm=self.fft_norm)
+
+        # The output will be of size (batch_size, self.out_channels,
+        # x.size(-2), x.size(-1)//2 + 1)
+        out_fft = torch.zeros(
+            [batchsize, self.out_channels, height, width // 2 + 1],
+            dtype=x.dtype,
+            device=x.device,
+        )
+
+        slices0 = (
+            slice(None),  # Equivalent to: [:,
+            slice(None),  # ............... :,
+            slice(self.half_n_modes[0]),  # :half_n_modes[0],
+            slice(self.half_n_modes[1]),  # :half_n_modes[1]]
+        )
+        """Upper block (truncate high frequencies)."""
+        out_fft[slices0] = self._contract(
+            x[slices0], self._get_weight(2 * indices), separable=self.separable
+        )
+
+        slices1 = (
+            slice(None),  # Equivalent to:        [:,
+            slice(None),  # ...................... :,
+            slice(-self.half_n_modes[0], None),  # -half_n_modes[0]:,
+            slice(self.half_n_modes[1]),  # ...... :half_n_modes[1]]
+        )
+        """Lower block"""
+        out_fft[slices1] = self._contract(
+            x[slices1], self._get_weight(2 * indices + 1), separable=self.separable
+        )
+
+        if self.resolution_scaling_factor is not None:
+            width = round(width * self.resolution_scaling_factor[indices][0])
+            height = round(height * self.resolution_scaling_factor[indices][1])
+
+        x = torch.fft.irfft2(
+            out_fft, s=(height, width), dim=(-2, -1), norm=self.fft_norm
+        )
+
+        if self.bias is not None:
+            x = x + self.bias[indices, ...]
+
+        return x
+
+
+class SpectralConv3d(SpectralConv):
+    """3D Spectral Conv, see :class:`neuralop.layers.SpectraConv` for the general case
+
+    This is provided for reference only,
+    see :class:`neuralop.layers.SpectraConv` for the preferred, general implementation
+    """
+
+    def forward(self, x, indices=0):
+        batchsize, channels, height, width, depth = x.shape
+
+        x = torch.fft.rfftn(x.float(), norm=self.fft_norm, dim=[-3, -2, -1])
+
+        out_fft = torch.zeros(
+            [batchsize, self.out_channels, height, width, depth // 2 + 1],
+            device=x.device,
+            dtype=torch.cfloat,
+        )
+
+        slices0 = (
+            slice(None),  # Equivalent to: [:,
+            slice(None),  # ............... :,
+            slice(self.half_n_modes[0]),  # :half_n_modes[0],
+            slice(self.half_n_modes[1]),  # :half_n_modes[1],
+            slice(self.half_n_modes[2]),  # :half_n_modes[2]]
+        )
+        """Upper block -- truncate high frequencies."""
+        out_fft[slices0] = self._contract(
+            x[slices0], self._get_weight(4 * indices + 0), separable=self.separable
+        )
+
+        slices1 = (
+            slice(None),  # Equivalent to:        [:,
+            slice(None),  # ...................... :,
+            slice(self.half_n_modes[0]),  # ...... :half_n_modes[0],
+            slice(-self.half_n_modes[1], None),  # -half_n_modes[1]:,
+            slice(self.half_n_modes[2]),  # ...... :half_n_modes[0]]
+        )
+        """Low-pass filter for indices 2 & 4, and high-pass filter for index 3."""
+        out_fft[slices1] = self._contract(
+            x[slices1], self._get_weight(4 * indices + 1), separable=self.separable
+        )
+
+        slices2 = (
+            slice(None),  # Equivalent to:        [:,
+            slice(None),  # ...................... :,
+            slice(-self.half_n_modes[0], None),  # -half_n_modes[0]:,
+            slice(self.half_n_modes[1]),  # ...... :half_n_modes[1],
+            slice(self.half_n_modes[2]),  # ...... :half_n_modes[2]]
+        )
+        """Low-pass filter for indices 3 & 4, and high-pass filter for index 2."""
+        out_fft[slices2] = self._contract(
+            x[slices2], self._get_weight(4 * indices + 2), separable=self.separable
+        )
+
+        slices3 = (
+            slice(None),  # Equivalent to:        [:,
+            slice(None),  # ...................... :,
+            slice(-self.half_n_modes[0], None),  # -half_n_modes[0],
+            slice(-self.half_n_modes[1], None),  # -half_n_modes[1],
+            slice(self.half_n_modes[2]),  # ...... :half_n_modes[2]]
+        )
+        """Lower block -- low-cut filter in indices 2 & 3
+        and high-cut filter in index 4."""
+        out_fft[slices3] = self._contract(
+            x[slices3], self._get_weight(4 * indices + 3), separable=self.separable
+        )
+
+        if self.resolution_scaling_factor is not None:
+            width = round(width * self.resolution_scaling_factor[0])
+            height = round(height * self.resolution_scaling_factor[1])
+            depth = round(depth * self.resolution_scaling_factor[2])
+
+        x = torch.fft.irfftn(out_fft, s=(height, width, depth), norm=self.fft_norm)
+
+        if self.bias is not None:
+            x = x + self.bias[indices, ...]
+        return x

sources/neuraloperator/neuralop/layers/local_no_block.py

@@ -0,0 +1,587 @@
+from typing import List, Optional, Union
+import warnings
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from .channel_mlp import ChannelMLP
+from .fno_block import SubModule
+from .differential_conv import FiniteDifferenceConvolution
+from .discrete_continuous_convolution import EquidistantDiscreteContinuousConv2d
+from .normalization_layers import AdaIN, InstanceNorm
+from .skip_connections import skip_connection
+from .spectral_convolution import SpectralConv
+from ..utils import validate_scaling_factor
+
+
+Number = Union[int, float]
+
+
+class LocalNOBlocks(nn.Module):
+    """Local Neural Operator blocks with localized integral and differential kernels.
+    
+    It is implemented as described in [3]_.
+
+    This class implements neural operator blocks that combine Fourier neural operators
+    with localized integral and differential kernels to capture both global and local
+    features in PDE solutions [3]_. The architecture addresses the over-smoothing limitations
+    of purely global FNOs while maintaining resolution-independence through principled
+    local operations.
+
+    The key innovation is the integration of two types of local operations:
+    1. Differential kernels: Learn finite difference stencils that converge to
+       differential operators under appropriate scaling.
+    2. Local integral kernels: Use discrete-continuous convolutions with locally
+       supported kernels to capture local interactions.
+
+    Parameters
+    ----------
+    in_channels : int
+        Number of input channels to Fourier layers
+    out_channels : int
+        Number of output channels after Fourier layers
+    n_modes : int, List[int]
+        Number of modes to keep along each dimension in frequency space.
+        Can either be specified as an int (for all dimensions)
+        or an iterable with one number per dimension
+    default_in_shape : Tuple[int]
+        Default input shape for spatiotemporal dimensions
+    resolution_scaling_factor : Optional[Union[Number, List[Number]]], optional
+        Factor by which to scale outputs for super-resolution, by default None
+    n_layers : int, optional
+        Number of neural operator layers to apply in sequence, by default 1
+    disco_layers : bool or List[bool], optional
+        Whether to include local integral kernel connections at each layer.
+        If a single bool, applies to all layers. If a list, must match n_layers.
+    disco_kernel_shape : Union[int, List[int]], optional
+        Kernel shape for local integral operations. Single int for isotropic kernels,
+        two ints for anisotropic kernels, by default [2,4]
+    domain_length : torch.Tensor, optional
+        Physical domain extent/length. Assumes square domain [-1, 1]^2 by default
+    disco_groups : int, optional
+        Number of groups in local integral convolution, by default 1
+    disco_bias : bool, optional
+        Whether to use bias for integral kernel, by default True
+    radius_cutoff : float, optional
+        Cutoff radius (relative to domain_length) for local integral kernel, by default None
+    diff_layers : bool or List[bool], optional
+        Whether to include differential kernel connections at each layer.
+        If a single bool, applies to all layers. If a list, must match n_layers.
+    conv_padding_mode : str, optional
+        Padding mode for spatial convolution kernels.
+        Options: 'periodic', 'circular', 'replicate', 'reflect', 'zeros'. By default 'periodic'
+    fin_diff_kernel_size : int, optional
+        Kernel size for finite difference convolution (must be odd), by default 3
+    mix_derivatives : bool, optional
+        Whether to mix derivatives across channels, by default True
+    max_n_modes : int or List[int], optional
+        Maximum number of modes to keep along each dimension, by default None
+    local_no_block_precision : str, optional
+        Floating point precision for computations, by default "full"
+    use_channel_mlp : bool, optional
+        Whether to use MLP layer after each block, by default False
+    channel_mlp_dropout : int, optional
+        Dropout parameter for channel MLP, by default 0
+    channel_mlp_expansion : float, optional
+        Expansion factor for channel MLP, by default 0.5
+    non_linearity : torch.nn.F module, optional
+        Nonlinear activation function between layers, by default F.gelu
+    stabilizer : Literal["tanh"], optional
+        Stabilizing module between layers. Options: "tanh". By default None
+    norm : Literal["ada_in", "group_norm", "instance_norm"], optional
+        Normalization layer to use, by default None
+    norm_groups : int, optional
+        Number of groups for GroupNorm, by default 1
+    ada_in_features : int, optional
+        Number of features for adaptive instance normalization, by default None
+    preactivation : bool, optional
+        Whether to call forward pass with pre-activation, by default False
+        if True, call nonlinear activation and norm before Fourier convolution
+        if False, call activation and norms after Fourier convolutions
+    local_no_skip : str, optional
+        Module to use for Local NO skip connections, by default "linear"
+        Options: "linear", "identity", "soft-gating", None.
+        If None, no skip connection is added. See layers.skip_connections for more details
+    channel_mlp_skip : str, optional
+        Module to use for ChannelMLP skip connections, by default "soft-gating"
+        Options: "linear", "identity", "soft-gating", None.
+        If None, no skip connection is added. See layers.skip_connections for more details
+
+    Other Parameters
+    ----------------
+    complex_data : bool, optional
+        Whether the data takes complex values in space, by default False
+    separable : bool, optional
+        Separable parameter for SpectralConv, by default False
+    factorization : str, optional
+        Factorization method for SpectralConv, by default None
+        Options: "factorized", "reconstructed".
+    rank : float, optional
+        Rank parameter for SpectralConv, by default 1.0
+    conv_module : BaseConv, optional
+        Convolution module for Local NO block, by default SpectralConv
+    joint_factorization : bool, optional
+        Whether to factorize all SpectralConv weights as one tensor, by default False
+    fixed_rank_modes : bool, optional
+        Fixed rank modes parameter for SpectralConv, by default False
+    implementation : str, optional
+        Implementation method for SpectralConv, by default "factorized"
+    decomposition_kwargs : dict, optional
+        Keyword arguments for tensor decomposition in SpectralConv, by default dict()
+    enforce_hermitian_symmetry : bool, optional
+        Whether to enforce Hermitian symmetry conditions when performing inverse FFT
+        for real-valued data. Only used when ``conv_module`` is :class:`SpectralConv`
+        or a subclass; ignored otherwise. When True, explicitly enforces that the 0th
+        frequency and Nyquist frequency are real-valued before calling irfft. When False,
+        relies on cuFFT's irfftn to handle symmetry automatically, which may fail on
+        certain GPUs or input sizes, causing line artifacts. By default True.
+
+    Notes
+    -----
+    - Differential kernels are only implemented for dimensions ≤ 3
+    - Local integral kernels are only implemented for 2D domains
+
+    References
+    ----------
+    .. [1] Li, Z. et al. "Fourier Neural Operator for Parametric Partial Differential
+           Equations" (2021). ICLR 2021, https://arxiv.org/pdf/2010.08895.
+    .. [2] Kossaifi, J., Kovachki, N., Azizzadenesheli, K., Anandkumar, A. "Multi-Grid
+           Tensorized Fourier Neural Operator for High-Resolution PDEs" (2024).
+           TMLR 2024, https://openreview.net/pdf?id=AWiDlO63bH.
+    .. [3] Liu-Schiaffini M., Berner J., Bonev B., Kurth T., Azizzadenesheli K., Anandkumar A.;
+           "Neural Operators with Localized Integral and Differential Kernels" (2024).
+           ICML 2024, https://arxiv.org/pdf/2402.16845.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        n_modes,
+        default_in_shape,
+        resolution_scaling_factor=None,
+        n_layers=1,
+        disco_layers=True,
+        disco_kernel_shape=[2, 4],
+        radius_cutoff=None,
+        domain_length=[2, 2],
+        disco_groups=1,
+        disco_bias=True,
+        diff_layers=True,
+        conv_padding_mode="periodic",
+        fin_diff_kernel_size=3,
+        mix_derivatives=True,
+        max_n_modes=None,
+        local_no_block_precision="full",
+        use_channel_mlp=False,
+        channel_mlp_dropout=0,
+        channel_mlp_expansion=0.5,
+        non_linearity=F.gelu,
+        stabilizer=None,
+        norm=None,
+        norm_groups=1,
+        ada_in_features=None,
+        preactivation=False,
+        local_no_skip="linear",
+        channel_mlp_skip="soft-gating",
+        separable=False,
+        factorization=None,
+        rank=1.0,
+        conv_module=SpectralConv,
+        fixed_rank_modes=False,
+        implementation="factorized",
+        decomposition_kwargs=dict(),
+        fft_norm="forward",
+        enforce_hermitian_symmetry=True,
+    ):
+        super().__init__()
+        if isinstance(n_modes, int):
+            n_modes = [n_modes]
+        self._n_modes = n_modes
+
+        assert len(n_modes) == len(default_in_shape), "Spatiotemporal dimensions must be consistent"
+        
+        # If a single bool is passed for disco_layers or diff_layers, set values for all layers
+        if isinstance(disco_layers, bool):
+            disco_layers = [disco_layers] * n_layers
+        if isinstance(diff_layers, bool):
+            diff_layers = [diff_layers] * n_layers
+
+        if len(n_modes) > 3 and True in diff_layers:
+            raise NotImplementedError("Differential convs not implemented for dimensions higher than 3.")
+
+        if len(n_modes) != 2 and True in disco_layers:
+            raise NotImplementedError("Local conv layers only implemented for dimension 2.")
+            
+        if conv_padding_mode not in ['circular', 'periodic', 'zeros'] and True in disco_layers:
+            warnings.warn("Local conv layers only support periodic or zero padding, defaulting to zero padding for local convs.")
+        
+        self.n_dim = len(n_modes)
+
+        self.resolution_scaling_factor: Union[
+            None, List[List[float]]
+        ] = validate_scaling_factor(resolution_scaling_factor, self.n_dim, n_layers)
+
+        self.max_n_modes = max_n_modes
+        self.local_no_block_precision = local_no_block_precision
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.n_layers = n_layers
+        self.non_linearity = non_linearity
+        self.stabilizer = stabilizer
+        self.rank = rank
+        self.factorization = factorization
+        self.fixed_rank_modes = fixed_rank_modes
+        self.decomposition_kwargs = decomposition_kwargs
+        self.local_no_skip = local_no_skip
+        self.channel_mlp_skip = channel_mlp_skip
+        self.use_channel_mlp = use_channel_mlp
+        self.channel_mlp_expansion = channel_mlp_expansion
+        self.channel_mlp_dropout = channel_mlp_dropout
+        self.fft_norm = fft_norm
+        self.implementation = implementation
+        self.separable = separable
+        self.preactivation = preactivation
+        self.ada_in_features = ada_in_features
+        self.enforce_hermitian_symmetry = enforce_hermitian_symmetry
+
+        self.diff_layers = diff_layers
+        self.conv_padding_mode = conv_padding_mode
+        self.default_in_shape = default_in_shape
+        self.fin_diff_kernel_size = fin_diff_kernel_size
+        self.mix_derivatives = mix_derivatives
+
+        self.disco_layers = disco_layers
+        self.disco_kernel_shape = disco_kernel_shape
+        self.radius_cutoff = radius_cutoff
+        self.domain_length = domain_length
+        self.disco_groups = disco_groups
+        self.disco_bias = disco_bias
+        self.periodic = self.conv_padding_mode in ["circular", "periodic"]
+
+        assert (
+            len(diff_layers) == n_layers
+        ), f"diff_layers must either provide a single bool value or a list of booleans of length n_layers,\
+                got {len(diff_layers)=}"
+        assert (
+            len(disco_layers) == n_layers
+        ), f"disco_layers must either provide a single bool value or a list of booleans of length n_layers,\
+                    got {len(disco_layers)=}"
+
+        # One conv per layer. Only resolution_scaling_factor varies by layer index
+        self.convs = nn.ModuleList(
+            [
+                conv_module(
+                    self.in_channels,
+                    self.out_channels,
+                    self.n_modes,
+                    # Per-layer scaling for super-resolution, or None if disabled
+                    resolution_scaling_factor=(
+                        self.resolution_scaling_factor[i]
+                        if resolution_scaling_factor is not None
+                        else None
+                    ),
+                    max_n_modes=max_n_modes,
+                    rank=rank,
+                    fixed_rank_modes=fixed_rank_modes,
+                    implementation=implementation,
+                    separable=separable,
+                    factorization=factorization,
+                    decomposition_kwargs=decomposition_kwargs,
+                    # Only SpectralConv (and subclasses) accept enforce_hermitian_symmetry. Others ignore it
+                    **(
+                        {"enforce_hermitian_symmetry": enforce_hermitian_symmetry}
+                        if issubclass(conv_module, SpectralConv)
+                        else {}
+                    ),
+                )
+                for i in range(n_layers)
+            ]
+        )
+
+        if local_no_skip is not None:
+            self.local_no_skips = nn.ModuleList(
+                [
+                    skip_connection(
+                        self.in_channels,
+                        self.out_channels,
+                        skip_type=local_no_skip,
+                        n_dim=self.n_dim,
+                    )
+                    for _ in range(n_layers)
+                ]
+            )
+        else:
+            self.local_no_skips = None
+
+        self.diff_groups = 1 if mix_derivatives else in_channels
+        self.differential = nn.ModuleList(
+            [
+                FiniteDifferenceConvolution(
+                    self.in_channels,
+                    self.out_channels,
+                    self.n_dim,
+                    self.fin_diff_kernel_size,
+                    self.diff_groups,
+                    self.conv_padding_mode,
+                )
+                for _ in range(sum(self.diff_layers))
+            ]
+        )
+
+        self.local_convs = nn.ModuleList(
+            [
+                EquidistantDiscreteContinuousConv2d(
+                    self.in_channels,
+                    self.out_channels,
+                    in_shape=self.default_in_shape,
+                    out_shape=self.default_in_shape,
+                    kernel_shape=self.disco_kernel_shape,
+                    domain_length=self.domain_length,
+                    radius_cutoff=self.radius_cutoff,
+                    periodic=self.periodic,
+                    groups=self.disco_groups,
+                    bias=self.disco_bias,
+                )
+                for _ in range(sum(self.disco_layers))
+            ]
+        )
+
+        # Helper for calling differential layers
+        self.differential_idx_list = []
+        j = 0
+        for i in range(n_layers):
+            if self.diff_layers[i]:
+                self.differential_idx_list.append(j)
+                j += 1
+            else:
+                self.differential_idx_list.append(-1)
+
+        assert max(self.differential_idx_list) == sum(self.diff_layers) - 1
+
+        # Helper for calling local conv layers
+        self.disco_idx_list = []
+        j = 0
+        for i in range(n_layers):
+            if self.disco_layers[i]:
+                self.disco_idx_list.append(j)
+                j += 1
+            else:
+                self.disco_idx_list.append(-1)
+
+        assert max(self.disco_idx_list) == sum(self.disco_layers) - 1
+
+        if use_channel_mlp:
+            self.mlp = nn.ModuleList(
+                [
+                    ChannelMLP(
+                        in_channels=self.out_channels,
+                        hidden_channels=round(self.out_channels * channel_mlp_expansion),
+                        dropout=channel_mlp_dropout,
+                        n_dim=self.n_dim,
+                    )
+                    for _ in range(n_layers)
+                ]
+            )
+            if channel_mlp_skip is not None:
+                self.channel_mlp_skips = nn.ModuleList(
+                    [
+                        skip_connection(
+                            self.in_channels,
+                            self.out_channels,
+                            skip_type=channel_mlp_skip,
+                            n_dim=self.n_dim,
+                        )
+                        for _ in range(n_layers)
+                    ]
+                )
+            else:
+                self.channel_mlp_skips = None
+        else:
+            self.mlp = None
+
+        # Each block will have 2 norms if we also use an MLP
+        self.n_norms = 1 if self.mlp is None else 2
+        if norm is None:
+            self.norm = None
+        elif norm == "instance_norm":
+            self.norm = nn.ModuleList(
+                [InstanceNorm() for _ in range(n_layers * self.n_norms)]
+            )
+        elif norm == "group_norm":
+            self.norm = nn.ModuleList(
+                [
+                    nn.GroupNorm(num_groups=norm_groups, num_channels=self.out_channels)
+                    for _ in range(n_layers * self.n_norms)
+                ]
+            )
+        elif norm == "ada_in":
+            self.norm = nn.ModuleList(
+                [
+                    AdaIN(ada_in_features, out_channels)
+                    for _ in range(n_layers * self.n_norms)
+                ]
+            )
+        else:
+            raise ValueError(
+                f"Got norm={norm} but expected None or one of "
+                "[instance_norm, group_norm, ada_in]"
+            )
+
+    def set_ada_in_embeddings(self, *embeddings):
+        """Sets the embeddings of each Ada-IN norm layers
+
+        Parameters
+        ----------
+        embeddings : tensor or list of tensor
+            if a single embedding is given, it will be used for each norm layer
+            otherwise, each embedding will be used for the corresponding norm layer
+        """
+        if len(embeddings) == 1:
+            for norm in self.norm:
+                norm.set_embedding(embeddings[0])
+        else:
+            for norm, embedding in zip(self.norm, embeddings):
+                norm.set_embedding(embedding)
+
+    def forward(self, x, index=0, output_shape=None):
+        if self.preactivation:
+            return self.forward_with_preactivation(x, index, output_shape)
+        else:
+            return self.forward_with_postactivation(x, index, output_shape)
+
+    def forward_with_postactivation(self, x, index=0, output_shape=None):
+        if self.local_no_skips is not None:
+            x_skip_local_no = self.local_no_skips[index](x)
+            x_skip_local_no = self.convs[index].transform(x_skip_local_no, output_shape=output_shape)
+
+        if self.mlp is not None and self.channel_mlp_skips is not None:
+            x_skip_mlp = self.channel_mlp_skips[index](x)
+            x_skip_mlp = self.convs[index].transform(x_skip_mlp, output_shape=output_shape)
+
+        if self.stabilizer == "tanh":
+            x = torch.tanh(x)
+
+        x_local_no = self.convs[index](x, output_shape=output_shape)
+
+        if self.differential_idx_list[index] != -1:
+            grid_width_scaling_factor = 1 / (x.shape[-1] / self.default_in_shape[0])
+            x_differential = self.differential[self.differential_idx_list[index]](x, grid_width_scaling_factor)
+            x_differential = self.convs[index].transform(x_differential, output_shape=output_shape)
+        else:
+            x_differential = 0
+
+        if self.disco_idx_list[index] != -1:
+            x_localconv = self.local_convs[self.disco_idx_list[index]](x)
+            x_localconv = self.convs[index].transform(x_localconv, output_shape=output_shape)
+        else:
+            x_localconv = 0
+
+        x_local_no_diff_disco = x_local_no + x_differential + x_localconv
+
+        if self.norm is not None:
+            x_local_no_diff_disco = self.norm[self.n_norms * index](x_local_no_diff_disco)
+
+        x = (
+            x_local_no_diff_disco + x_skip_local_no
+            if self.local_no_skips is not None
+            else x_local_no_diff_disco
+        )
+
+        if (self.mlp is not None) or (index < (self.n_layers - 1)):
+            x = self.non_linearity(x)
+
+        if self.mlp is not None:
+            if self.channel_mlp_skips is not None:
+                x = self.mlp[index](x) + x_skip_mlp
+            else:
+                x = self.mlp[index](x)
+
+            if self.norm is not None:
+                x = self.norm[self.n_norms * index + 1](x)
+
+            if index < (self.n_layers - 1):
+                x = self.non_linearity(x)
+
+        return x
+
+    def forward_with_preactivation(self, x, index=0, output_shape=None):
+        # Apply non-linear activation (and norm)
+        # before this block's convolution/forward pass:
+        x = self.non_linearity(x)
+
+        if self.norm is not None:
+            x = self.norm[self.n_norms * index](x)
+
+        if self.differential_idx_list[index] != -1:
+            grid_width_scaling_factor = 1 / (x.shape[-1] / self.default_grid_res)
+            x_differential = self.differential[self.differential_idx_list[index]](x, grid_width_scaling_factor)
+        else:
+            x_differential = 0
+
+        if self.disco_idx_list[index] != -1:
+            x_localconv = self.local_convs[self.disco_idx_list[index]](x)
+        else:
+            x_localconv = 0
+
+        if self.local_no_skips is not None:
+            x_skip_local_no = self.local_no_skips[index](x)
+            x_skip_local_local_no = self.convs[index].transform(x_skip_local_no + x_differential + x_localconv, output_shape=output_shape)
+        else:
+            x_skip_local_local_no = self.convs[index].transform(x_differential + x_localconv, output_shape=output_shape)
+
+        if self.mlp is not None:
+            if self.channel_mlp_skips is not None:
+                x_skip_mlp = self.channel_mlp_skips[index](x)
+                x_skip_mlp = self.convs[index].transform(x_skip_mlp, output_shape=output_shape)
+
+        if self.stabilizer == "tanh":
+            x = torch.tanh(x)
+
+        x_local_no = self.convs[index](x, output_shape=output_shape)
+
+        x = (
+            x_local_no + x_skip_local_local_no
+            if self.local_no_skips is not None
+            else x_local_no
+        )
+
+        if self.mlp is not None:
+            if index < (self.n_layers - 1):
+                x = self.non_linearity(x)
+
+            if self.norm is not None:
+                x = self.norm[self.n_norms * index + 1](x)
+
+            if self.channel_mlp_skips is not None:
+                x = self.mlp[index](x) + x_skip_mlp
+            else:
+                x = self.mlp[index](x)
+
+        return x
+
+    @property
+    def n_modes(self):
+        return self._n_modes
+
+    @n_modes.setter
+    def n_modes(self, n_modes):
+        for i in range(self.n_layers):
+            self.convs[i].n_modes = n_modes
+        self._n_modes = n_modes
+
+    def get_block(self, indices):
+        """Returns a sub-NO Block layer from the jointly parametrized main block
+
+        The parametrization of an LocalNOBlock layer is shared with the main one.
+        """
+        if self.n_layers == 1:
+            raise ValueError(
+                "A single layer is parametrized, directly use the main class."
+            )
+
+        return SubModule(self, indices)
+
+    def __getitem__(self, indices):
+        return self.get_block(indices)

sources/neuraloperator/neuralop/layers/neighbor_search.py

@@ -0,0 +1,119 @@
+import torch
+from torch import nn
+
+# only import open3d if built
+open3d_built = False
+try:
+    from open3d.ml.torch.layers import FixedRadiusSearch
+
+    open3d_built = True
+except:
+    pass
+
+
+# Uses open3d by default which, as of October 2024, requires torch 2.0 and cuda11.*
+class NeighborSearch(nn.Module):
+    """Neighborhood search between two arbitrary coordinate meshes.
+    
+    For each point `x` in `queries`, returns a set of the indices of all points `y` in `data`
+    within the ball of radius r `B_r(x)`
+
+    Parameters
+    ----------
+    use_open3d : bool, optional
+        Whether to use open3d or native PyTorch implementation, by default True
+        NOTE: open3d implementation requires 3d data
+    return_norm : bool, optional
+        Whether to return normalized distances, by default False
+    """
+
+    def __init__(self, use_open3d=True, return_norm=False):
+        super().__init__()
+        if use_open3d and open3d_built:  # slightly faster, works on GPU in 3d only
+            self.search_fn = FixedRadiusSearch()
+            self.use_open3d = use_open3d
+        else:  # slower fallback, works on GPU and CPU
+            self.search_fn = native_neighbor_search
+            self.use_open3d = False
+        self.return_norm = return_norm
+
+    def forward(self, data, queries, radius):
+        """
+        Find the neighbors, in data, of each point in queries
+        within a ball of radius. Returns in CRS format.
+
+        Parameters
+        ----------
+        data : torch.Tensor of shape [n, d]
+            Search space of possible neighbors
+            NOTE: open3d requires d=3
+        queries : torch.Tensor of shape [m, d]
+            Points for which to find neighbors
+            NOTE: open3d requires d=3
+        radius : float
+            Radius of each ball: B(queries[j], radius)
+
+        Returns
+        -------
+        return_dict : dict
+            Dictionary with keys: neighbors_index, neighbors_row_splits
+                neighbors_index: torch.Tensor with dtype=torch.int64
+                    Index of each neighbor in data for every point
+                    in queries. Neighbors are ordered in the same orderings
+                    as the points in queries. Open3d and torch_cluster
+                    implementations can differ by a permutation of the
+                    neighbors for every point.
+                neighbors_row_splits: torch.Tensor of shape [m+1] with dtype=torch.int64
+                    The value at index j is the sum of the number of
+                    neighbors up to query point j-1. First element is 0
+                    and last element is the total number of neighbors.
+        """
+        return_dict = {}
+
+        if self.use_open3d:
+            search_return = self.search_fn(data, queries, radius)
+            return_dict["neighbors_index"] = search_return.neighbors_index.long()
+            return_dict["neighbors_row_splits"] = search_return.neighbors_row_splits.long()
+
+        else:
+            return_dict = self.search_fn(data, queries, radius, self.return_norm)
+
+        return return_dict
+
+
+def native_neighbor_search(
+    data: torch.Tensor, queries: torch.Tensor, radius: float, return_norm: bool = False
+):
+    """
+    Native PyTorch implementation of a neighborhood search
+    between two arbitrary coordinate meshes.
+
+    Parameters
+    ----------
+    data : torch.Tensor
+        vector of data points from which to find neighbors
+    queries : torch.Tensor
+        centers of neighborhoods
+    radius : float
+        size of each neighborhood
+    """
+    nbr_dict = {}
+
+    # compute pairwise distances
+    all_dists = torch.cdist(queries, data).to(queries.device) # shaped num query points x num data points
+    # keep zero-distance points
+    eps = 1e-7
+    all_dists = torch.where(all_dists == 0., eps, all_dists)
+    dists = torch.where(all_dists <= radius, all_dists, 0.) # i,j is 1 if j is i's neighbor 
+    nbr_indices = dists.nonzero()[:,1:].reshape(-1,) # only keep the column indices
+    if return_norm:
+        weights = dists[dists.nonzero(as_tuple=True)]
+        nbr_dict["weights"] = weights **2 # weighting function computed on squared norms
+    in_nbr = torch.where(dists > 0, 1., 0.,)
+    nbrhd_sizes = torch.cumsum(torch.sum(in_nbr, dim=1), dim=0) # num points in each neighborhood, summed cumulatively
+    splits = torch.cat((torch.tensor([0.]).to(queries.device), nbrhd_sizes))
+    
+    nbr_dict["neighbors_index"] = nbr_indices.long().to(queries.device)
+    nbr_dict["neighbors_row_splits"] = splits.long()
+
+    return nbr_dict

sources/neuraloperator/neuralop/layers/normalization_layers.py

@@ -0,0 +1,165 @@
+import torch
+import torch.nn as nn
+
+
+class AdaIN(nn.Module):
+    """Adaptive Instance Normalization (AdaIN) layer for style transfer in neural operators.
+
+    AdaIN performs instance normalization followed by adaptive scaling and shifting
+    based on an external embedding vector. This allows for style transfer by
+    modulating the output characteristics based on a conditioning signal.
+
+    The layer first normalizes the input using instance normalization, then applies
+    learned scaling (weight) and shifting (bias) parameters derived from an embedding
+    vector through a multi-layer perceptron.
+
+    Parameters
+    ----------
+    embed_dim : int
+        Dimension of the embedding vector used for style conditioning
+    in_channels : int
+        Number of input channels to normalize
+    mlp : nn.Module, optional
+        Multi-layer perceptron that maps embedding to (weight, bias) parameters.
+        Should output 2*in_channels values. If None, a default MLP is created
+        with architecture: Linear(embed_dim, 512) -> GELU -> Linear(512, 2*in_channels)
+    eps : float, optional
+        Small value added to the denominator for numerical stability in normalization.
+        Default is 1e-5.
+    """
+
+    def __init__(self, embed_dim, in_channels, mlp=None, eps=1e-5):
+        super().__init__()
+        self.in_channels = in_channels
+        self.embed_dim = embed_dim
+        self.eps = eps
+
+        if mlp is None:
+            mlp = nn.Sequential(
+                nn.Linear(embed_dim, 512),
+                nn.GELU(),
+                nn.Linear(512, 2*in_channels)
+            )
+        self.mlp = mlp
+
+        self.embedding = None
+
+    def set_embedding(self, x):
+        """Set the embedding vector for style conditioning."""
+        self.embedding = x.reshape(self.embed_dim,)
+
+    def forward(self, x):
+        """Apply adaptive instance normalization to the input tensor."""
+        assert self.embedding is not None, "AdaIN: update embeddding before running forward"
+
+        weight, bias = torch.split(self.mlp(self.embedding), self.in_channels, dim=0)
+
+        return nn.functional.group_norm(x, self.in_channels, weight, bias, eps=self.eps)
+
+
+class InstanceNorm(nn.Module):
+    """Dimension-agnostic instance normalization layer for neural operators.
+
+    InstanceNorm normalizes each sample in the batch independently, computing
+    mean and variance across spatial dimensions for each sample and channel
+    separately. This is useful when the statistical properties of each sample
+    are distinct and should be treated separately.
+
+    Parameters
+    ----------
+    **kwargs : dict, optional
+        Additional parameters to pass to torch.nn.functional.instance_norm().
+        Common parameters include:
+        - eps : float, optional
+            Small value added to the denominator for numerical stability.
+            Default is 1e-5.
+        - momentum : float, optional
+            Value used for the running_mean and running_var computation.
+            Default is 0.1.
+        - use_input_stats : bool, optional
+            If True, use input statistics. Default is True.
+        - weight : torch.Tensor, optional
+            Weight tensor for affine transformation. If None, no scaling applied.
+        - bias : torch.Tensor, optional
+            Bias tensor for affine transformation. If None, no bias applied.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        self.kwargs = kwargs
+
+    def forward(self, x):
+        """Apply instance normalization to the input tensor."""
+        size = x.shape
+        x = torch.nn.functional.instance_norm(x, **self.kwargs)
+        assert x.shape == size
+        return x
+
+
+class BatchNorm(nn.Module):
+    """Dimension-agnostic batch normalization layer for neural operators.
+
+    BatchNorm normalizes data across the entire batch, computing a single mean
+    and standard deviation for all samples combined. This is the most common
+    form of normalization and is effective when batch statistics are a good
+    approximation of the overall data distribution.
+
+    For dimensions > 3, the layer automatically flattens spatial dimensions
+    and uses BatchNorm1d, as PyTorch doesn't implement batch norm for 4D+ tensors.
+
+    Parameters
+    ----------
+    n_dim : int
+        Spatial dimension of input data (e.g., 1 for 1D, 2 for 2D, 3 for 3D).
+        Determined by FNOBlocks.n_dim. If n_dim > 3, spatial dimensions are
+        flattened and BatchNorm1d is used.
+    num_features : int
+        Number of channels in the input tensor to be normalized
+    **kwargs : dict, optional
+        Additional parameters to pass to the underlying batch normalization layer.
+        Common parameters include:
+        - eps : float, optional
+            Small value added to the denominator for numerical stability.
+            Default is 1e-5.
+        - momentum : float, optional
+            Value used for the running_mean and running_var computation.
+            Default is 0.1.
+        - affine : bool, optional
+            If True, apply learnable affine transformation. Default is True.
+        - track_running_stats : bool, optional
+            If True, track running statistics. Default is True.
+    """
+
+    def __init__(self, n_dim: int, num_features: int, **kwargs):
+        super().__init__()
+        self.n_dim = n_dim
+        self.num_features = num_features
+        self.kwargs = kwargs
+
+        if self.n_dim <= 3:
+            self.norm = getattr(torch.nn, f"BatchNorm{n_dim}d")(
+                num_features=num_features, **kwargs
+            )
+        else:
+            print(
+                "Warning: torch does not implement batch norm for dimensions higher than 3.\
+                  We manually flatten the spatial dimension of 4+D tensors to apply batch norm. "
+            )
+            self.norm = torch.nn.BatchNorm1d(num_features=num_features, **kwargs)
+
+    def forward(self, x):
+        """Apply batch normalization to the input tensor."""
+        size = x.shape
+        num_channels = size[1]
+
+        # in 4+D, we flatten and use batchnorm1d.
+        if self.n_dim >= 4:
+            x = x.reshape(size[0], size[1], -1)
+        x = self.norm(x)
+
+        # if flattening occurred, unflatten
+        if self.n_dim >= 4:
+            x = x.reshape(size)
+
+        assert x.shape == size
+        return x

sources/neuraloperator/neuralop/layers/padding.py

@@ -0,0 +1,133 @@
+from typing import List, Union
+
+from torch import nn
+from torch.nn import functional as F
+
+from neuralop.utils import validate_scaling_factor
+
+
+class DomainPadding(nn.Module):
+    """Applies domain padding scaled automatically to the input's resolution.
+
+    Parameters
+    ----------
+    domain_padding : float or list
+        Typically, between zero and one, percentage of padding to use
+        if a list, make sure if matches the dim of (d1, ..., dN)
+    resolution_scaling_factor : int, optional
+        Resolution scaling factor, by default 1
+
+    Notes
+    -----
+    This class works for any input resolution. Expects inputs of shape
+    (batch-size, channels, d1, ...., dN)
+    """
+
+    def __init__(
+        self,
+        domain_padding: Union[float, list],
+        resolution_scaling_factor: Union[int, List[int]] = 1,
+    ):
+        super().__init__()
+        self.domain_padding = domain_padding
+        if resolution_scaling_factor is None:
+            resolution_scaling_factor = 1
+        self.resolution_scaling_factor: Union[int, List[int]] = resolution_scaling_factor
+
+        # dict(f'{resolution}'=padding) such that padded = F.pad(x, indices)
+        self._padding = dict()
+
+        # dict(f'{resolution}'=indices_to_unpad) such that unpadded = x[indices]
+        self._unpad_indices = dict()
+
+    def forward(self, x):
+        """
+        forward pass: pad the input
+        """
+        self.pad(x)
+
+    def pad(self, x, verbose=False):
+        """Take an input and pad it by the desired fraction
+
+        The amount of padding will be automatically scaled with the resolution
+        """
+        resolution = x.shape[2:]
+
+        # if domain_padding is list, then to pass on
+        if isinstance(self.domain_padding, (float, int)):
+            self.domain_padding = [float(self.domain_padding)] * len(resolution)
+
+        assert len(self.domain_padding) == len(resolution), (
+            "domain_padding length must match the number of spatial/time dimensions "
+            "(excluding batch, ch)"
+        )
+
+        resolution_scaling_factor = self.resolution_scaling_factor
+        if not isinstance(self.resolution_scaling_factor, list):
+            # if unset by the user, scaling_factor will be 1 be default,
+            # so `resolution_scaling_factor` should never be None.
+            resolution_scaling_factor: List[float] = validate_scaling_factor(
+                self.resolution_scaling_factor, len(resolution), n_layers=None
+            )
+
+        try:
+            padding = self._padding[f"{resolution}"]
+            return F.pad(x, padding, mode="constant")
+
+        except KeyError:
+            padding = [round(p * r) for (p, r) in zip(self.domain_padding, resolution)]
+
+            if verbose:
+                print(
+                    f"Padding inputs of resolution={resolution} with "
+                    f"padding={padding}, symmetric"
+                )
+
+            output_pad = padding
+
+            output_pad = [
+                round(i * j) for (i, j) in zip(resolution_scaling_factor, output_pad)
+            ]
+
+            # padding is being applied in reverse order
+            # (so we must reverse the padding list)
+            padding = padding[::-1]
+
+            # the F.pad(x, padding) funtion pads the tensor 'x' in reverse order
+            # of the "padding" list i.e. the last axis of tensor 'x' will be
+            # padded by the amount mention at the first position of the
+            # 'padding' vector. The details about F.pad can be found here:
+            # https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+
+            # Pad both sides (symmetric mode)
+            unpad_list = list()
+            for p in output_pad:
+                if p == 0:
+                    padding_end = None
+                    padding_start = None
+                else:
+                    padding_end = p
+                    padding_start = -p
+                unpad_list.append(slice(padding_end, padding_start, None))
+            unpad_indices = (Ellipsis,) + tuple(unpad_list)
+
+            padding = [i for p in padding for i in (p, p)]
+
+            self._padding[f"{resolution}"] = padding
+
+            padded = F.pad(x, padding, mode="constant")
+
+            output_shape = padded.shape[2:]
+
+            output_shape = [
+                round(i * j) for (i, j) in zip(resolution_scaling_factor, output_shape)
+            ]
+
+            self._unpad_indices[f"{[i for i in output_shape]}"] = unpad_indices
+
+            return padded
+
+    def unpad(self, x):
+        """Remove the padding from padding inputs"""
+        unpad_indices = self._unpad_indices[f"{list(x.shape[2:])}"]
+        return x[unpad_indices]

sources/neuraloperator/neuralop/layers/resample.py

@@ -0,0 +1,102 @@
+import numpy as np
+import itertools
+import torch
+import torch.nn.functional as F
+
+
+def resample(x, res_scale, axis, output_shape=None):
+    """A module for generic n-dimentional interpolation.
+
+    For 1D and 2D inputs, the ``resample`` function uses PyTorch’s built-in spatial interpolators
+    for efficiency, applying linear interpolation for 1D data and bicubic interpolation for 2D data
+    directly in the spatial domain.
+
+    For 3D or higher-dimensional inputs, the ``resample`` function switches to a spectral interpolation
+    method  based on the Fourier transform. The input is transformed into the frequency domain using a
+    real n-dimensional FFT, which decomposes the signal into its frequency components. By resizing
+    this frequency representation and then applying an inverse FFT, the function achieves smooth,
+    alias-free interpolation that preserves the signal’s overall structure.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+            input activation of size (batch_size, channels, d1, ..., dN)
+    res_scale: int or tuple
+            Scaling factor along each of the dimensions in 'axis' parameter. If res_scale is scaler, then isotropic
+            scaling is performed
+    axis: axis or dimensions along which interpolation will be performed.
+    output_shape : None or tuple[int]
+    """
+
+    if isinstance(res_scale, (float, int)):
+        if axis is None:
+            axis = list(range(2, x.ndim))
+            res_scale = [res_scale] * len(axis)
+        elif isinstance(axis, int):
+            axis = [axis]
+            res_scale = [res_scale]
+        else:
+            res_scale = [res_scale] * len(axis)
+    else:
+        assert len(res_scale) == len(axis), "leght of res_scale and axis are not same"
+
+    old_size = x.shape[-len(axis) :]
+    if output_shape is None:
+        new_size = tuple([int(round(s * r)) for (s, r) in zip(old_size, res_scale)])
+    else:
+        new_size = output_shape
+
+    if len(axis) == 1:
+        return F.interpolate(x, size=new_size[0], mode="linear", align_corners=True)
+    if len(axis) == 2:
+        return F.interpolate(x, size=new_size, mode="bicubic", align_corners=True)
+
+    X = torch.fft.rfftn(x.float(), norm="forward", dim=axis)
+
+    new_fft_size = list(new_size)
+    new_fft_size[-1] = new_fft_size[-1] // 2 + 1  # Redundant last coefficient
+    new_fft_size_c = [min(i, j) for (i, j) in zip(new_fft_size, X.shape[-len(axis) :])]
+    out_fft = torch.zeros(
+        [x.shape[0], x.shape[1], *new_fft_size], device=x.device, dtype=torch.cfloat
+    )
+
+    mode_indexing = [((None, m//2), (-m//2, None)) for m in new_fft_size_c[:-1]] + [((None, new_fft_size_c[-1]), )]
+    for i, boundaries in enumerate(itertools.product(*mode_indexing)):
+        idx_tuple = [slice(None), slice(None)] + [slice(*b) for b in boundaries]
+
+        idx_tuple = tuple(idx_tuple)
+        out_fft[idx_tuple] = X[idx_tuple]
+    y = torch.fft.irfftn(out_fft, s=new_size, norm="forward", dim=axis)
+
+    return y
+
+
+def iterative_resample(x, res_scale, axis):
+    if isinstance(axis, list) and isinstance(res_scale, (float, int)):
+        res_scale = [res_scale] * len(axis)
+    if not isinstance(axis, list) and isinstance(res_scale,list):
+      raise Exception("Axis is not a list but Scale factors are")
+    if isinstance(axis, list) and isinstance(res_scale,list) and len(res_scale) != len(axis):
+      raise Exception("Axis and Scal factor are in different sizes")
+
+    if isinstance(axis, list):
+        for i in range(len(res_scale)):
+            rs = res_scale[i]
+            a = axis[i]
+            x = resample(x, rs, a)
+        return x
+
+    old_res = x.shape[axis]
+    X = torch.fft.rfft(x, dim=axis, norm="forward")
+    newshape = list(x.shape)
+    new_res = int(round(res_scale * newshape[axis]))
+    newshape[axis] = new_res // 2 + 1
+
+    Y = torch.zeros(newshape, dtype=X.dtype, device=x.device)
+
+    modes = min(new_res, old_res)
+    sl = [slice(None)] * x.ndim
+    sl[axis] = slice(0, modes // 2 + 1)
+    Y[tuple(sl)] = X[tuple(sl)]
+    y = torch.fft.irfft(Y, n=new_res, dim=axis, norm="forward")
+    return y

sources/neuraloperator/neuralop/layers/rno_block.py

@@ -0,0 +1,432 @@
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ..layers.spectral_convolution import SpectralConv
+from ..layers.fno_block import FNOBlocks
+from ..layers.complex import cselu
+
+
+class RNOCell(nn.Module):
+    """N-Dimensional Recurrent Neural Operator cell. The RNO cell takes in an
+    input and history function, and it outputs the next step of the hidden function.
+
+    The RNO cell implements the GRU-like recurrence relation with Fourier layers:
+        z_t = σ(f1(x_t) + f2(h_{t-1}) + b1)            [update gate]
+        r_t = σ(f3(x_t) + f4(h_{t-1}) + b2)            [reset gate]
+        h̃_t = selu(f5(x_t) + f6(r_t ⊙ h_{t-1}) + b3)  [candidate state]
+        h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t         [next state]
+
+    where σ is the sigmoid function, ⊙ is element-wise multiplication,
+    and f1-f6 are FNO blocks (Fourier neural operators).
+
+    Parameters
+    ----------
+    n_modes : int tuple
+        number of modes to keep in Fourier Layer, along each dimension
+        The dimensionality of the RNO is inferred from ``len(n_modes)``
+    hidden_channels : int
+        number of hidden channels in the RNO
+
+    Other Parameters
+    ----------------
+    resolution_scaling_factor : Union[Number, List[Number]], optional
+        Factor by which to scale outputs for super-resolution, by default None
+    max_n_modes : int or List[int], optional
+        Maximum number of modes to keep along each dimension, by default None
+    fno_block_precision : str, optional
+        Floating point precision to use for computations. Options: "full", "half", "mixed", by default "full"
+    use_channel_mlp : bool, optional
+        Whether to use an MLP layer after each FNO block, by default True
+    channel_mlp_dropout : float, optional
+        Dropout parameter for self.channel_mlp, by default 0
+    channel_mlp_expansion : float, optional
+        Expansion parameter for self.channel_mlp, by default 0.5
+    non_linearity : torch.nn.F module, optional
+        Nonlinear activation function to use between layers, by default F.gelu
+    stabilizer : Literal["tanh"], optional
+        Stabilizing module to use between certain layers. Options: "tanh", None, by default None
+    norm : Literal["ada_in", "group_norm", "instance_norm", "batch_norm"], optional
+        Normalization layer to use. Options: "ada_in", "group_norm", "instance_norm", "batch_norm", None, by default None
+    norm_groups : int, optional
+        Number of groups for GroupNorm, by default 1
+    ada_in_features : int, optional
+        Number of features for adaptive instance norm above, by default None
+    preactivation : bool, optional
+        Whether to call forward pass with pre-activation, by default False
+        If True, call nonlinear activation and norm before Fourier convolution
+        If False, call activation and norms after Fourier convolutions
+    fno_skip : str, optional
+        Module to use for FNO skip connections. Options: "linear", "soft-gating", "identity", None, by default "linear"
+        If None, no skip connection is added. See layers.skip_connections for more details
+    channel_mlp_skip : str, optional
+        Module to use for ChannelMLP skip connections. Options: "linear", "soft-gating", "identity", None, by default "soft-gating"
+        If None, no skip connection is added. See layers.skip_connections for more details
+    complex_data : bool, optional
+        Whether the FNO's data takes on complex values in space, by default False
+    separable : bool, optional
+        Separable parameter for SpectralConv, by default False
+    factorization : str, optional
+        Factorization parameter for SpectralConv. Options: "tucker", "cp", "tt", None, by default None
+    rank : float, optional
+        Rank parameter for SpectralConv, by default 1.0
+    conv_module : BaseConv, optional
+        Module to use for convolutions in FNO block, by default SpectralConv
+    joint_factorization : bool, optional
+        Whether to factorize all spectralConv weights as one tensor, by default False
+    fixed_rank_modes : bool, optional
+        Fixed_rank_modes parameter for SpectralConv, by default False
+    implementation : str, optional
+        Implementation parameter for SpectralConv. Options: "factorized", "reconstructed", by default "factorized"
+    decomposition_kwargs : dict, optional
+        Kwargs for tensor decomposition in SpectralConv, by default dict()
+    enforce_hermitian_symmetry : bool, optional
+        Whether to enforce Hermitian symmetry conditions when performing inverse FFT
+        for real-valued data. Only used when ``conv_module`` is :class:`SpectralConv`
+        or a subclass; ignored otherwise. When True, explicitly enforces that the 0th
+        frequency and Nyquist frequency are real-valued before calling irfft. When False,
+        relies on cuFFT's irfftn to handle symmetry automatically, which may fail on
+        certain GPUs or input sizes, causing line artifacts. By default True.
+
+    References
+    ----------
+    .. [1] Paper: https://arxiv.org/abs/2308.08794
+    """
+
+    def __init__(
+        self,
+        n_modes,
+        hidden_channels,
+        resolution_scaling_factor=None,
+        max_n_modes=None,
+        fno_block_precision="full",
+        use_channel_mlp=True,
+        channel_mlp_dropout=0,
+        channel_mlp_expansion=0.5,
+        non_linearity=F.gelu,
+        stabilizer=None,
+        norm=None,
+        norm_groups=1,
+        ada_in_features=None,
+        preactivation=False,
+        fno_skip="linear",
+        channel_mlp_skip="soft-gating",
+        complex_data=False,
+        separable=False,
+        factorization=None,
+        rank=1.0,
+        conv_module=SpectralConv,
+        fixed_rank_modes=False,
+        implementation="factorized",
+        decomposition_kwargs=dict(),
+        enforce_hermitian_symmetry=True,
+    ):
+        super().__init__()
+        self.hidden_channels = hidden_channels
+        scaling_factor = (
+            None if not resolution_scaling_factor else [resolution_scaling_factor]
+        )
+        fno_kwargs = {
+            "n_layers": 1,
+            "max_n_modes": max_n_modes,
+            "fno_block_precision": fno_block_precision,
+            "use_channel_mlp": use_channel_mlp,
+            "channel_mlp_dropout": channel_mlp_dropout,
+            "channel_mlp_expansion": channel_mlp_expansion,
+            "non_linearity": non_linearity,
+            "stabilizer": stabilizer,
+            "norm": norm,
+            "norm_groups": norm_groups,
+            "preactivation": preactivation,
+            "fno_skip": fno_skip,
+            "channel_mlp_skip": channel_mlp_skip,
+            "complex_data": complex_data,
+            "separable": separable,
+            "factorization": factorization,
+            "rank": rank,
+            "conv_module": conv_module,
+            "fixed_rank_modes": fixed_rank_modes,
+            "implementation": implementation,
+            "decomposition_kwargs": decomposition_kwargs,
+            "enforce_hermitian_symmetry": enforce_hermitian_symmetry,
+        }
+
+        # For super-resolution: the hidden state h is always stored at the scaled resolution,
+        # while input x remains at the original resolution. Therefore, only f1, f3, and f5
+        # (which process x) need resolution scaling, while f2, f4, and f6 (which process h)
+        # operate at the already-scaled resolution.
+
+        self.input_gates = nn.ModuleList()
+        self.hidden_gates = nn.ModuleList()
+        self.biases = nn.ParameterList()
+
+        # 3 gates: Update (z), Reset (r), Candidate (h_tilde)
+        # Each gate involves one FNOBlock processing x (input_gate)
+        # and one FNOBlock processing h (hidden_gate)
+        for _ in range(3):
+            self.input_gates.append(
+                FNOBlocks(
+                    in_channels=hidden_channels,
+                    out_channels=hidden_channels,
+                    n_modes=n_modes,
+                    resolution_scaling_factor=scaling_factor,
+                    **fno_kwargs,
+                )
+            )
+            self.hidden_gates.append(
+                FNOBlocks(
+                    in_channels=hidden_channels,
+                    out_channels=hidden_channels,
+                    n_modes=n_modes,
+                    resolution_scaling_factor=None,
+                    **fno_kwargs,
+                )
+            )
+            if complex_data:
+                self.biases.append(nn.Parameter(torch.randn(()) + 1j * torch.randn(())))
+            else:
+                self.biases.append(nn.Parameter(torch.randn(())))
+
+    def forward(self, x, h):
+        """Forward pass for RNO cell.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input function at current timestep with shape (batch, hidden_channels, *spatial_dims)
+        h : torch.Tensor
+            Hidden state from previous timestep with shape (batch, hidden_channels, *spatial_dims_h)
+            where spatial_dims_h may differ from spatial_dims if resolution_scaling_factor is set
+
+        Returns
+        -------
+        torch.Tensor
+            Updated hidden state with shape (batch, hidden_channels, *spatial_dims_h)
+        """
+        # Update gate
+        update_gate = torch.sigmoid(
+            self.input_gates[0](x) + self.hidden_gates[0](h) + self.biases[0]
+        )
+
+        # Reset gate
+        reset_gate = torch.sigmoid(
+            self.input_gates[1](x) + self.hidden_gates[1](h) + self.biases[1]
+        )
+
+        # Candidate state
+        h_combined = self.input_gates[2](x) + self.hidden_gates[2](reset_gate * h) + self.biases[2]
+        
+        if x.dtype == torch.cfloat:
+            candidate_state = cselu(h_combined)  # complex SELU for complex data
+        else:
+            candidate_state = F.selu(h_combined)  # regular SELU for real data
+
+        h_next = (1.0 - update_gate) * h + update_gate * candidate_state
+
+        return h_next
+
+
+class RNOBlock(nn.Module):
+    """N-Dimensional Recurrent Neural Operator layer. The RNO layer extends the
+    action of the RNO cell to take in some sequence of time-steps as input
+    and output the next output function.
+
+    The layer applies the RNO cell recurrently over a sequence of inputs:
+        For t = 1 to T:
+            h_t = RNOCell(x_t, h_{t-1})
+
+    where the cell implements:
+        z_t = σ(f1(x_t) + f2(h_{t-1}) + b1)            [update gate]
+        r_t = σ(f3(x_t) + f4(h_{t-1}) + b2)            [reset gate]
+        h̃_t = selu(f5(x_t) + f6(r_t ⊙ h_{t-1}) + b3)  [candidate state]
+        h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t         [next state]
+
+    Parameters
+    ----------
+    n_modes : int tuple
+        number of modes to keep in Fourier Layer, along each dimension
+        The dimensionality of the RNO is inferred from ``len(n_modes)``
+    hidden_channels : int
+        number of hidden channels in the RNO
+    return_sequences : boolean, optional
+        Whether to return the sequence of hidden states associated with processing
+        the inputs sequence of functions. Default: False
+
+    Other Parameters
+    ----------------
+    resolution_scaling_factor : Union[Number, List[Number]], optional
+        Factor by which to scale outputs for super-resolution, by default None
+    max_n_modes : int or List[int], optional
+        Maximum number of modes to keep along each dimension, by default None
+    fno_block_precision : str, optional
+        Floating point precision to use for computations. Options: "full", "half", "mixed", by default "full"
+    use_channel_mlp : bool, optional
+        Whether to use an MLP layer after each FNO block, by default True
+    channel_mlp_dropout : float, optional
+        Dropout parameter for self.channel_mlp, by default 0
+    channel_mlp_expansion : float, optional
+        Expansion parameter for self.channel_mlp, by default 0.5
+    non_linearity : torch.nn.F module, optional
+        Nonlinear activation function to use between layers, by default F.gelu
+    stabilizer : Literal["tanh"], optional
+        Stabilizing module to use between certain layers. Options: "tanh", None, by default None
+    norm : Literal["ada_in", "group_norm", "instance_norm", "batch_norm"], optional
+        Normalization layer to use. Options: "ada_in", "group_norm", "instance_norm", "batch_norm", None, by default None
+    norm_groups : int, optional
+        Number of groups for GroupNorm, by default 1
+    ada_in_features : int, optional
+        Number of features for adaptive instance norm above, by default None
+    preactivation : bool, optional
+        Whether to call forward pass with pre-activation, by default False
+        If True, call nonlinear activation and norm before Fourier convolution
+        If False, call activation and norms after Fourier convolutions
+    fno_skip : str, optional
+        Module to use for FNO skip connections. Options: "linear", "soft-gating", "identity", None, by default "linear"
+        If None, no skip connection is added. See layers.skip_connections for more details
+    channel_mlp_skip : str, optional
+        Module to use for ChannelMLP skip connections. Options: "linear", "soft-gating", "identity", None, by default "soft-gating"
+        If None, no skip connection is added. See layers.skip_connections for more details
+    complex_data : bool, optional
+        Whether the FNO's data takes on complex values in space, by default False
+    separable : bool, optional
+        Separable parameter for SpectralConv, by default False
+    factorization : str, optional
+        Factorization parameter for SpectralConv. Options: "tucker", "cp", "tt", None, by default None
+    rank : float, optional
+        Rank parameter for SpectralConv, by default 1.0
+    conv_module : BaseConv, optional
+        Module to use for convolutions in FNO block, by default SpectralConv
+    joint_factorization : bool, optional
+        Whether to factorize all spectralConv weights as one tensor, by default False
+    fixed_rank_modes : bool, optional
+        Fixed_rank_modes parameter for SpectralConv, by default False
+    implementation : str, optional
+        Implementation parameter for SpectralConv. Options: "factorized", "reconstructed", by default "factorized"
+    decomposition_kwargs : dict, optional
+        Kwargs for tensor decomposition in SpectralConv, by default dict()
+    enforce_hermitian_symmetry : bool, optional
+        Whether to enforce Hermitian symmetry conditions when performing inverse FFT
+        for real-valued data. Only used when ``conv_module`` is :class:`SpectralConv`
+        or a subclass; ignored otherwise. When True, explicitly enforces that the 0th
+        frequency and Nyquist frequency are real-valued before calling irfft. When False,
+        relies on cuFFT's irfftn to handle symmetry automatically, which may fail on
+        certain GPUs or input sizes, causing line artifacts. By default True.
+
+    References
+    ----------
+    .. [1] Paper: https://arxiv.org/abs/2308.08794
+    """
+
+    def __init__(
+        self,
+        n_modes,
+        hidden_channels,
+        return_sequences=False,
+        resolution_scaling_factor=None,
+        max_n_modes=None,
+        fno_block_precision="full",
+        use_channel_mlp=True,
+        channel_mlp_dropout=0,
+        channel_mlp_expansion=0.5,
+        non_linearity=F.gelu,
+        stabilizer=None,
+        norm=None,
+        norm_groups=1,
+        ada_in_features=None,
+        preactivation=False,
+        fno_skip="linear",
+        channel_mlp_skip="soft-gating",
+        complex_data=False,
+        separable=False,
+        factorization=None,
+        rank=1.0,
+        conv_module=SpectralConv,
+        fixed_rank_modes=False,
+        implementation="factorized",
+        decomposition_kwargs=dict(),
+        enforce_hermitian_symmetry=True,
+    ):
+        super().__init__()
+
+        self.hidden_channels = hidden_channels
+        self.return_sequences = return_sequences
+        self.resolution_scaling_factor = resolution_scaling_factor
+
+        self.cell = RNOCell(
+            n_modes,
+            hidden_channels,
+            resolution_scaling_factor=resolution_scaling_factor,
+            max_n_modes=max_n_modes,
+            fno_block_precision=fno_block_precision,
+            use_channel_mlp=use_channel_mlp,
+            channel_mlp_dropout=channel_mlp_dropout,
+            channel_mlp_expansion=channel_mlp_expansion,
+            non_linearity=non_linearity,
+            stabilizer=stabilizer,
+            norm=norm,
+            norm_groups=norm_groups,
+            preactivation=preactivation,
+            fno_skip=fno_skip,
+            channel_mlp_skip=channel_mlp_skip,
+            complex_data=complex_data,
+            separable=separable,
+            factorization=factorization,
+            rank=rank,
+            conv_module=conv_module,
+            fixed_rank_modes=fixed_rank_modes,
+            implementation=implementation,
+            decomposition_kwargs=decomposition_kwargs,
+            enforce_hermitian_symmetry=enforce_hermitian_symmetry,
+        )
+        if complex_data:
+            self.bias_h = nn.Parameter(torch.randn(()) + 1j * torch.randn(()))
+        else:
+            self.bias_h = nn.Parameter(torch.randn(()))
+
+    def forward(self, x, h=None):
+        """Forward pass for RNO layer.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input sequence with shape (batch, timesteps, hidden_channels, *spatial_dims)
+        h : torch.Tensor, optional
+            Initial hidden state with shape (batch, hidden_channels, *spatial_dims_h).
+            If None, initialized to zeros with added bias. Default: None
+
+        Returns
+        -------
+        torch.Tensor
+            If return_sequences=True: hidden states for all timesteps with shape
+                (batch, timesteps, hidden_channels, *spatial_dims_h)
+            If return_sequences=False: final hidden state with shape
+                (batch, hidden_channels, *spatial_dims_h)
+        """
+        batch_size, timesteps, dim = x.shape[:3]
+        dom_sizes = x.shape[3:]
+
+        # Initialize hidden state if not provided
+        if h is None:
+            # Compute the spatial dimensions for h (scaled if resolution_scaling_factor is set)
+            if not self.resolution_scaling_factor:
+                h_shape = (batch_size, self.hidden_channels, *dom_sizes)
+            else:
+                scaled_sizes = tuple(
+                    [int(round(self.resolution_scaling_factor * s)) for s in dom_sizes]
+                )
+                h_shape = (batch_size, self.hidden_channels, *scaled_sizes)
+            h = torch.zeros(h_shape, dtype=x.dtype).to(x.device)
+            h += self.bias_h
+
+        outputs = []
+        # Process each timestep sequentially through the RNO cell
+        for i in range(timesteps):
+            h = self.cell(x[:, i], h)  # Update hidden state with current input
+            if self.return_sequences:
+                outputs.append(h)
+
+        if self.return_sequences:
+            return torch.stack(outputs, dim=1)
+        else:
+            return h

sources/neuraloperator/neuralop/layers/segment_csr.py

@@ -0,0 +1,98 @@
+from typing import Literal
+import importlib
+
+import torch
+from torch import einsum
+
+
+def segment_csr(
+    src: torch.Tensor,
+    indptr: torch.Tensor,
+    reduction: Literal["mean", "sum"],
+    use_scatter=True,
+):
+    """segment_csr reduces all entries of a CSR-formatted
+    matrix by summing or averaging over neighbors.
+
+    Used to reduce features over neighborhoods
+    in neuralop.layers.IntegralTransform
+
+    If use_scatter is set to False or torch_scatter is not
+    properly built, segment_csr falls back to a naive PyTorch implementation
+
+    Note: the native version is mainly intended for running tests on
+    CPU-only GitHub CI runners to get around a versioning issue.
+    torch_scatter should be installed and built if possible.
+
+    Parameters
+    ----------
+    src : torch.Tensor
+        tensor of features for each point
+    indptr : torch.Tensor
+        splits representing start and end indices
+        of each neighborhood in src
+    reduction : Literal['mean', 'sum']
+        How to reduce a neighborhood. Options: 'mean', 'sum'. If mean,
+        reduce by taking the average of all neighbors. Otherwise take the sum.
+    use_scatter : bool, optional
+        Whether to use torch-scatter.segment_csr. If False, uses native Python reduction, by default True
+
+        .. warning::
+
+            torch-scatter is an optional dependency that conflicts with the newest versions of PyTorch,
+            so you must handle the conflict explicitly in your environment. See :ref:`torch_scatter_dependency`
+            for more information.
+    """
+    if reduction not in ["mean", "sum"]:
+        raise ValueError("reduce must be one of 'mean', 'sum'")
+
+    if importlib.util.find_spec("torch_scatter") is not None and use_scatter:
+        """only import torch_scatter when cuda is available"""
+        import torch_scatter.segment_csr as scatter_segment_csr
+
+        return scatter_segment_csr(src, indptr, reduce=reduction)
+
+    else:
+        if use_scatter:
+            print(
+                "Warning: use_scatter is True but torch_scatter is not properly built. \
+                  Defaulting to naive PyTorch implementation"
+            )
+        # if batched, shape [b, n_reps, channels]
+        # otherwise shape [n_reps, channels]
+        if src.ndim == 3:
+            batched = True
+            point_dim = 1
+        else:
+            batched = False
+            point_dim = 0
+
+        # if batched, shape [b, n_out, channels]
+        # otherwise shape [n_out, channels]
+        output_shape = list(src.shape)
+        n_out = indptr.shape[point_dim] - 1
+        output_shape[point_dim] = n_out
+
+        out = torch.zeros(output_shape, device=src.device)
+
+        for i in range(n_out):
+            # reduce all indices pointed to in indptr from src into out
+            if batched:
+                from_idx = (slice(None), slice(indptr[0, i], indptr[0, i + 1]))
+                ein_str = "bio->bo"
+                start = indptr[0, i]
+                n_nbrs = indptr[0, i + 1] - start
+                to_idx = (slice(None), i)
+            else:
+                from_idx = slice(indptr[i], indptr[i + 1])
+                ein_str = "io->o"
+                start = indptr[i]
+                n_nbrs = indptr[i + 1] - start
+                to_idx = i
+            src_from = src[from_idx]
+            if n_nbrs > 0:
+                to_reduce = einsum(ein_str, src_from)
+                if reduction == "mean":
+                    to_reduce /= n_nbrs
+                out[to_idx] += to_reduce
+        return out

sources/neuraloperator/neuralop/layers/skip_connections.py

@@ -0,0 +1,130 @@
+import torch
+from torch import nn
+
+
+def skip_connection(
+    in_features, out_features, n_dim=2, bias=False, skip_type="soft-gating"
+):
+    """A wrapper for several types of skip connections.
+    Returns an nn.Module skip connections, one of  {'identity', 'linear', soft-gating'}
+
+    Parameters
+    ----------
+    in_features : int
+        Number of input features
+    out_features : int
+        Number of output features
+    n_dim : int, optional
+        Dimensionality of the input (excluding batch-size and channels).
+        n_dim=2 corresponds to having Module2D, by default 2
+    bias : bool, optional
+        Whether to use a bias, by default False
+    skip_type : {'identity', 'linear', 'soft-gating'}, optional
+        Kind of skip connection to use. Options: 'identity', 'linear', 'soft-gating', by default "soft-gating"
+
+    Returns
+    -------
+    nn.Module
+        module that takes in x and returns skip(x)
+    """
+    if skip_type.lower() == "soft-gating":
+        return SoftGating(
+            in_features=in_features,
+            out_features=out_features,
+            bias=bias,
+            n_dim=n_dim,
+        )
+    elif skip_type.lower() == "linear":
+        return Flattened1dConv(
+            in_channels=in_features,
+            out_channels=out_features,
+            kernel_size=1,
+            bias=bias,
+        )
+    elif skip_type.lower() == "identity":
+        return nn.Identity()
+    else:
+        raise ValueError(
+            f"Got skip-connection type={skip_type}, expected one of"
+            f" {'soft-gating', 'linear', 'id'}."
+        )
+
+
+class SoftGating(nn.Module):
+    """Applies soft-gating by weighting the channels of the given input.
+
+    Given an input x of size `(batch-size, channels, height, width)`,
+    this returns `x * w `
+    where w is of shape `(1, channels, 1, 1)`
+
+    Parameters
+    ----------
+    in_features : int
+        Number of input features
+    out_features : None
+        This is provided for API compatibility with nn.Linear only
+    n_dim : int, optional
+        Dimensionality of the input (excluding batch-size and channels).
+        n_dim=2 corresponds to having Module2D, by default 2
+    bias : bool, optional
+        Whether to use a bias, by default False
+    """
+
+    def __init__(self, in_features, out_features=None, n_dim=2, bias=False):
+        super().__init__()
+        if out_features is not None and in_features != out_features:
+            raise ValueError(
+                f"Got in_features={in_features} and out_features={out_features}, "
+                "but these two must be the same for soft-gating"
+            )
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = nn.Parameter(torch.ones(1, self.in_features, *(1,) * n_dim))
+        if bias:
+            self.bias = nn.Parameter(torch.ones(1, self.in_features, *(1,) * n_dim))
+        else:
+            self.bias = None
+
+    def forward(self, x):
+        """Applies soft-gating to a batch of activations"""
+        if self.bias is not None:
+            return self.weight * x + self.bias
+        else:
+            return self.weight * x
+
+
+class Flattened1dConv(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size, bias=False):
+        """Flattened1dConv is a Conv-based skip layer for
+        input tensors of ndim > 3 (batch, channels, d1, ...) that flattens all dimensions
+        past the batch and channel dims into one dimension, applies the Conv1d,
+        and un-flattens.
+
+        Parameters
+        ----------
+        in_channels : int
+            in_channels of Conv1d
+        out_channels : int
+            out_channels of Conv1d
+        kernel_size : int
+            kernel_size of Conv1d
+        bias : bool, optional
+            bias of Conv1d, by default False
+        """
+        super().__init__()
+        self.conv = nn.Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            bias=bias,
+        )
+
+    def forward(self, x):
+        # x.shape: b, c, x1, ..., xn x_ndim > 1
+        size = list(x.shape)
+        # flatten everything past 1st data dim
+        x = x.view(*size[:2], -1)
+        x = self.conv(x)
+        # reshape x into an Nd tensor b, c, x1, x2, ...
+        x = x.view(size[0], self.conv.out_channels, *size[2:])
+        return x

sources/neuraloperator/neuralop/layers/spectral_convolution.py

@@ -0,0 +1,570 @@
+from typing import List, Optional, Tuple, Union
+
+from ..utils import validate_scaling_factor
+
+import torch
+from torch import nn
+
+import tensorly as tl
+from tensorly.plugins import use_opt_einsum
+from tltorch.factorized_tensors.core import FactorizedTensor
+
+from .einsum_utils import einsum_complexhalf
+from .base_spectral_conv import BaseSpectralConv
+from .resample import resample
+
+tl.set_backend("pytorch")
+use_opt_einsum("optimal")
+einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
+def _contract_dense(x, weight, separable=False):
+    order = tl.ndim(x)
+    # batch-size, in_channels, x, y...
+    x_syms = list(einsum_symbols[:order])
+
+    # in_channels, out_channels, x, y...
+    weight_syms = list(x_syms[1:])  # no batch-size
+
+    # batch-size, out_channels, x, y...
+    if separable:
+        out_syms = [x_syms[0]] + list(weight_syms)
+    else:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+
+    eq = f'{"".join(x_syms)},{"".join(weight_syms)}->{"".join(out_syms)}'
+
+    if not torch.is_tensor(weight):
+        weight = weight.to_tensor()
+
+    if x.dtype == torch.complex32:
+        # if x is half precision, run a specialized einsum
+        return einsum_complexhalf(eq, x, weight)
+    else:
+        return tl.einsum(eq, x, weight)
+
+
+def _contract_dense_separable(x, weight, separable):
+    if not torch.is_tensor(weight):
+        weight = weight.to_tensor()
+    return x * weight
+
+
+def _contract_cp(x, cp_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    rank_sym = einsum_symbols[order]
+    out_sym = einsum_symbols[order + 1]
+    out_syms = list(x_syms)
+    if separable:
+        factor_syms = [einsum_symbols[1] + rank_sym]  # in only
+    else:
+        out_syms[1] = out_sym
+        factor_syms = [einsum_symbols[1] + rank_sym, out_sym + rank_sym]  # in, out
+    factor_syms += [xs + rank_sym for xs in x_syms[2:]]  # x, y, ...
+    eq = f'{x_syms},{rank_sym},{",".join(factor_syms)}->{"".join(out_syms)}'
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, cp_weight.weights, *cp_weight.factors)
+    else:
+        return tl.einsum(eq, x, cp_weight.weights, *cp_weight.factors)
+
+
+def _contract_tucker(x, tucker_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    out_sym = einsum_symbols[order]
+    out_syms = list(x_syms)
+    if separable:
+        core_syms = einsum_symbols[order + 1 : 2 * order]
+        # factor_syms = [einsum_symbols[1]+core_syms[0]] #in only
+        # x, y, ...
+        factor_syms = [xs + rs for (xs, rs) in zip(x_syms[1:], core_syms)]
+
+    else:
+        core_syms = einsum_symbols[order + 1 : 2 * order + 1]
+        out_syms[1] = out_sym
+        factor_syms = [
+            einsum_symbols[1] + core_syms[0],
+            out_sym + core_syms[1],
+        ]  # out, in
+        # x, y, ...
+        factor_syms += [xs + rs for (xs, rs) in zip(x_syms[2:], core_syms[2:])]
+
+    eq = f'{x_syms},{core_syms},{",".join(factor_syms)}->{"".join(out_syms)}'
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, tucker_weight.core, *tucker_weight.factors)
+    else:
+        return tl.einsum(eq, x, tucker_weight.core, *tucker_weight.factors)
+
+
+def _contract_tt(x, tt_weight, separable=False):
+    order = tl.ndim(x)
+
+    x_syms = list(einsum_symbols[:order])
+    weight_syms = list(x_syms[1:])  # no batch-size
+    if not separable:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+    else:
+        out_syms = list(x_syms)
+    rank_syms = list(einsum_symbols[order + 1 :])
+    tt_syms = []
+    for i, s in enumerate(weight_syms):
+        tt_syms.append([rank_syms[i], s, rank_syms[i + 1]])
+    eq = (
+        "".join(x_syms)
+        + ","
+        + ",".join("".join(f) for f in tt_syms)
+        + "->"
+        + "".join(out_syms)
+    )
+
+    if x.dtype == torch.complex32:
+        return einsum_complexhalf(eq, x, *tt_weight.factors)
+    else:
+        return tl.einsum(eq, x, *tt_weight.factors)
+
+
+def get_contract_fun(weight, implementation="reconstructed", separable=False):
+    """Generic ND implementation of Fourier Spectral Conv contraction
+
+    Parameters
+    ----------
+    weight : tensorly-torch's FactorizedTensor
+    implementation : {'reconstructed', 'factorized'}, default is 'reconstructed'
+        whether to reconstruct the weight and do a forward pass (reconstructed)
+        or contract directly the factors of the factorized weight with the input (factorized)
+    separable: bool
+        if True, performs contraction with individual tensor factors.
+        if False,
+    Returns
+    -------
+    function : (x, weight) -> x * weight in Fourier space
+    """
+    if implementation == "reconstructed":
+        if separable:
+            return _contract_dense_separable
+        else:
+            return _contract_dense
+    elif implementation == "factorized":
+        if torch.is_tensor(weight):
+            return _contract_dense
+        elif isinstance(weight, FactorizedTensor):
+            if weight.name.lower().endswith("dense"):
+                return _contract_dense
+            elif weight.name.lower().endswith("tucker"):
+                return _contract_tucker
+            elif weight.name.lower().endswith("tt"):
+                return _contract_tt
+            elif weight.name.lower().endswith("cp"):
+                return _contract_cp
+            else:
+                raise ValueError(f"Got unexpected factorized weight type {weight.name}")
+        else:
+            raise ValueError(
+                f"Got unexpected weight type of class {weight.__class__.__name__}"
+            )
+    else:
+        raise ValueError(
+            f'Got implementation={implementation}, expected "reconstructed" or "factorized"'
+        )
+
+
+Number = Union[int, float]
+
+
+class SpectralConv(BaseSpectralConv):
+    """SpectralConv implements the Spectral Convolution component of a Fourier layer
+    described. 
+    
+    It is implemented as described in [1]_ and [2]_.
+
+    Parameters
+    ----------
+    in_channels : int
+        Number of input channels
+    out_channels : int
+        Number of output channels
+    n_modes : int or int tuple
+        Number of modes to use for contraction in Fourier domain during training.
+
+        .. warning::
+
+            We take care of the redundancy in the Fourier modes, therefore, for an input
+            of size I_1, ..., I_N, please provide modes M_K that are I_1 < M_K <= I_N
+            We will automatically keep the right amount of modes: specifically, for the
+            last mode only, if you specify M_N modes we will use M_N // 2 + 1 modes
+            as the real FFT is redundant along that last dimension. See the theory guide for mode truncation details.
+
+
+        .. note::
+
+            Provided modes should be even integers. odd numbers will be rounded to the closest even number.
+
+        This can be updated dynamically during training.
+
+    complex_data : bool, optional
+        Whether data takes on complex values in the spatial domain, by default False.
+        If True, uses different logic for FFT contraction and uses full FFT instead of real-valued.
+    max_n_modes : int tuple or None, optional
+        If not None, maximum number of modes to keep in Fourier Layer along each dim
+        (n_modes cannot be increased beyond that). If None, all n_modes are used.
+        By default None.
+    bias : bool, optional
+        Whether to add a learnable bias to the output, by default True.
+    separable : bool, optional
+        Whether to use separable implementation of contraction.
+        If True, contracts factors of factorized tensor weight individually.
+        By default False.
+    resolution_scaling_factor : float, list of float, or None, optional
+        Scaling factor(s) for resolution scaling. If provided, the output resolution
+        will be scaled by this factor along each spatial dimension.
+        By default None.
+    fno_block_precision : str, optional
+        Precision mode for FNO block operations. Options: 'full', 'half', 'mixed'.
+        By default 'full'.
+    rank : float, optional
+        Rank of the tensor factorization of the Fourier weights, by default 1.0.
+        Ignored if ``factorization is None``.
+    factorization : str or None, optional
+        Tensor factorization type. Options: {'tucker', 'cp', 'tt'}.
+        If None, a single dense weight is learned for the FNO.
+        Otherwise, that weight, used for the contraction in the Fourier domain
+        is learned in factorized form. In that case, `factorization` is the
+        tensor factorization of the parameters weight used.
+        By default None.
+    implementation : {'factorized', 'reconstructed'}, optional
+        If factorization is not None, forward mode to use:
+        * `reconstructed` : the full weight tensor is reconstructed from the
+          factorization and used for the forward pass
+        * `factorized` : the input is directly contracted with the factors of
+          the decomposition
+        Ignored if ``factorization is None``.
+        By default 'reconstructed'.
+    enforce_hermitian_symmetry : bool, optional
+        Whether to enforce Hermitian symmetry conditions when performing inverse FFT
+        for real-valued data. When True, explicitly enforces that the 0th frequency
+        and Nyquist frequency are real-valued before calling irfft. 
+        When False, relies on cuFFT's irfftn to handle symmetry automatically, 
+        which may fail on certain GPUs or input sizes, causing line artifacts. 
+        Setting to True splits the inverse FFT into ifftn along (n-1) dimensions 
+        followed by irfft on the last dimension, with a small computational overhead. 
+        By default True.
+    fixed_rank_modes : bool, optional
+        Modes to not factorize, by default False.
+        Ignored if ``factorization is None``.
+    decomposition_kwargs : dict or None, optional
+        Optional additional parameters to pass to the tensor decomposition.
+        Ignored if ``factorization is None``.
+        By default None.
+    init_std : float or 'auto', optional
+        Standard deviation to use for weight initialization, by default 'auto'.
+        If 'auto', uses (2 / (in_channels + out_channels)) ** 0.5.
+    fft_norm : str, optional
+        FFT normalization parameter, by default 'forward'.
+    device : torch.device or None, optional
+        Device to place the layer on, by default None.
+
+    References
+    ----------
+    .. [1] Li, Z. et al. "Fourier Neural Operator for Parametric Partial Differential
+        Equations" (2021). ICLR 2021, https://arxiv.org/pdf/2010.08895.
+        
+    .. [2] Kossaifi, J., Kovachki, N., Azizzadenesheli, K., Anandkumar, A. "Multi-Grid
+        Tensorized Fourier Neural Operator for High-Resolution PDEs" (2024).
+        TMLR 2024, https://openreview.net/pdf?id=AWiDlO63bH.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        n_modes,
+        complex_data=False,
+        max_n_modes=None,
+        bias=True,
+        separable=False,
+        resolution_scaling_factor: Optional[Union[Number, List[Number]]] = None,
+        fno_block_precision="full",
+        rank=1.0,
+        factorization=None,
+        implementation="reconstructed",
+        enforce_hermitian_symmetry=True,
+        fixed_rank_modes=False,
+        decomposition_kwargs: Optional[dict] = None,
+        init_std="auto",
+        fft_norm="forward",
+        device=None,
+    ):
+        super().__init__(device=device)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        self.complex_data = complex_data
+
+        # n_modes is the total number of modes kept along each dimension
+        self.n_modes = n_modes
+        self.order = len(self.n_modes)
+
+        if max_n_modes is None:
+            max_n_modes = self.n_modes
+        elif isinstance(max_n_modes, int):
+            max_n_modes = [max_n_modes]
+        self.max_n_modes = max_n_modes
+
+        self.fno_block_precision = fno_block_precision
+        self.rank = rank
+        self.factorization = factorization
+        self.implementation = implementation
+        self.enforce_hermitian_symmetry = enforce_hermitian_symmetry
+        
+        self.resolution_scaling_factor: Union[
+            None, List[List[float]]
+        ] = validate_scaling_factor(resolution_scaling_factor, self.order)
+
+        if init_std == "auto":
+            init_std = (2 / (in_channels + out_channels)) ** 0.5
+
+        if isinstance(fixed_rank_modes, bool):
+            if fixed_rank_modes:
+                # If bool, keep the number of layers fixed
+                fixed_rank_modes = [0]
+            else:
+                fixed_rank_modes = None
+        self.fft_norm = fft_norm
+
+        if factorization is None:
+            factorization = "Dense"  # No factorization
+
+        if separable:
+            if in_channels != out_channels:
+                raise ValueError(
+                    "To use separable Fourier Conv, in_channels must be equal "
+                    f"to out_channels, but got in_channels={in_channels} and "
+                    f"out_channels={out_channels}",
+                )
+            weight_shape = (in_channels, *max_n_modes)
+        else:
+            weight_shape = (in_channels, out_channels, *max_n_modes)
+        self.separable = separable
+
+        tensor_kwargs = decomposition_kwargs if decomposition_kwargs is not None else {}
+
+        # Create/init spectral weight tensor
+        self.weight = FactorizedTensor.new(
+            weight_shape,
+            rank=self.rank,
+            factorization=factorization,
+            fixed_rank_modes=fixed_rank_modes,
+            **tensor_kwargs,
+            dtype=torch.cfloat,
+        )
+        self.weight.normal_(0, init_std)
+
+        self._contract = get_contract_fun(
+            self.weight, implementation=implementation, separable=separable
+        )
+
+        if bias:
+            self.bias = nn.Parameter(
+                init_std * torch.randn(*(tuple([self.out_channels]) + (1,) * self.order))
+            )
+        else:
+            self.bias = None
+
+    def transform(self, x, output_shape=None):
+        in_shape = list(x.shape[2:])
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            out_shape = tuple(
+                [round(s * r) for (s, r) in zip(in_shape, self.resolution_scaling_factor)]
+            )
+        elif output_shape is not None:
+            out_shape = output_shape
+        else:
+            out_shape = in_shape
+
+        if in_shape == out_shape:
+            return x
+        else:
+            return resample(x, 1.0, list(range(2, x.ndim)), output_shape=out_shape)
+
+    @property
+    def n_modes(self):
+        return self._n_modes
+
+    @n_modes.setter
+    def n_modes(self, n_modes):
+        if isinstance(n_modes, int):  # Should happen for 1D FNO only
+            n_modes = [n_modes]
+        else:
+            n_modes = list(n_modes)
+        # the real FFT is skew-symmetric, so the last mode has a redundacy if our data is real in space
+        # As a design choice we do the operation here to avoid users dealing with the +1
+        # if we use the full FFT we cannot cut off informtion from the last mode
+        if not self.complex_data:
+            n_modes[-1] = n_modes[-1] // 2 + 1
+        self._n_modes = n_modes
+
+    def forward(self, x: torch.Tensor, output_shape: Optional[Tuple[int]] = None):
+        """Generic forward pass for the Factorized Spectral Conv
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            input activation of size (batch_size, channels, d1, ..., dN)
+
+        Returns
+        -------
+        tensorized_spectral_conv(x)
+        """
+        batchsize, channels, *mode_sizes = x.shape
+
+        fft_size = list(mode_sizes)
+        if not self.complex_data:
+            fft_size[-1] = fft_size[-1] // 2 + 1  # Redundant last coefficient in real spatial data
+        fft_dims = list(range(-self.order, 0))
+
+        if self.fno_block_precision == "half":
+            x = x.half()
+
+        if self.complex_data:
+            x = torch.fft.fftn(x, norm=self.fft_norm, dim=fft_dims)
+            dims_to_fft_shift = fft_dims
+        else:
+            x = torch.fft.rfftn(x, norm=self.fft_norm, dim=fft_dims)
+            # When x is real in spatial domain, the last half of the last dim is redundant.
+            # See :ref:`fft_shift_explanation` for discussion of the FFT shift.
+            dims_to_fft_shift = fft_dims[:-1]
+
+        if self.order > 1:
+            x = torch.fft.fftshift(x, dim=dims_to_fft_shift)
+
+        if self.fno_block_precision == "mixed":
+            # if 'mixed', the above fft runs in full precision, but the
+            # following operations run at half precision
+            x = x.chalf()
+
+        if self.fno_block_precision in ["half", "mixed"]:
+            out_dtype = torch.chalf
+        else:
+            out_dtype = torch.cfloat
+        out_fft = torch.zeros(
+            [batchsize, self.out_channels, *fft_size], device=x.device, dtype=out_dtype
+        )
+
+        # if current modes are less than max, start indexing modes closer to the center of the weight tensor
+        starts = [
+            (max_modes - min(size, n_mode))
+            for (size, n_mode, max_modes) in zip(fft_size, self.n_modes, self.max_n_modes)
+        ]
+        # if contraction is separable, weights have shape (channels, modes_x, ...)
+        # otherwise they have shape (in_channels, out_channels, modes_x, ...)
+        if self.separable:
+            slices_w = [slice(None)]  # channels
+        else:
+            slices_w = [slice(None), slice(None)]  # in_channels, out_channels
+        if self.complex_data:
+            slices_w += [
+                slice(start // 2, -start // 2) if start else slice(start, None)
+                for start in starts
+            ]
+        else:
+            # The last mode already has redundant half removed in real FFT
+            slices_w += [
+                slice(start // 2, -start // 2) if start else slice(start, None)
+                for start in starts[:-1]
+            ]
+            slices_w += [slice(None, -starts[-1]) if starts[-1] else slice(None)]
+
+        slices_w = tuple(slices_w)
+        weight = self.weight[slices_w]
+
+        ### Pick the first n_modes modes of FFT signal along each dim
+
+        # if separable conv, weight tensor only has one channel dim
+        if self.separable:
+            weight_start_idx = 1
+        # otherwise drop first two dims (in_channels, out_channels)
+        else:
+            weight_start_idx = 2
+
+        slices_x = [slice(None), slice(None)]  # Batch_size, channels
+
+        for all_modes, kept_modes in zip(fft_size, list(weight.shape[weight_start_idx:])):
+            # After fft-shift, the 0th frequency is located at n // 2 in each direction
+            # We select n_modes modes around the 0th frequency (kept at index n//2) by grabbing indices
+            # n//2 - n_modes//2  to  n//2 + n_modes//2       if n_modes is even
+            # n//2 - n_modes//2  to  n//2 + n_modes//2 + 1   if n_modes is odd
+            center = all_modes // 2
+            negative_freqs = kept_modes // 2
+            positive_freqs = kept_modes // 2 + kept_modes % 2
+
+            # this slice represents the desired indices along each dim
+            slices_x += [slice(center - negative_freqs, center + positive_freqs)]
+
+        if weight.shape[-1] < fft_size[-1]:
+            slices_x[-1] = slice(None, weight.shape[-1])
+        else:
+            slices_x[-1] = slice(None)
+
+        slices_x = tuple(slices_x)
+        out_fft[slices_x] = self._contract(
+            x[slices_x], weight, separable=self.separable
+        )
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            mode_sizes = tuple([round(s * r) for (s, r) in zip(mode_sizes, self.resolution_scaling_factor)])
+
+        if output_shape is not None:
+            mode_sizes = output_shape
+
+
+        if self.order > 1:
+            out_fft = torch.fft.ifftshift(out_fft, dim=fft_dims[:-1])
+        
+
+        # Inverse FFT 
+        if self.complex_data:
+            # For complex data, we can use ifftn.
+            x = torch.fft.ifftn(out_fft, s=mode_sizes, dim=fft_dims, norm=self.fft_norm)
+        
+        else:
+            # For real data, we need to enforce Hermitian symmetry conditions for irfft.
+            # On certain GPUs and for certain input sizes, this is not handled within irfftn in cuFFT, 
+            # and as a result causes line artifacts.  
+            # To fix this, we split the ifftn into a ifftn in (n-1) dimensions and a irfft in the last dimension,
+            # although it incurs a small additional computational cost.
+            
+            if self.enforce_hermitian_symmetry:
+                out_fft = torch.fft.ifftn(out_fft, s=mode_sizes[:-1], dim=fft_dims[:-1], norm=self.fft_norm)
+                
+                # Enforce Hermitian symmetry conditions for irfft
+                # 0th frequency must be real
+                out_fft[..., 0].imag.zero_()
+                
+                # Nyquist frequency must be real if the spatial size is even
+                if mode_sizes[-1] % 2 == 0:
+                    out_fft[..., -1].imag.zero_()
+                
+                # Now that the Hermitian symmetry conditions are enforced, we can use irfft on the last dimension.
+                x = torch.fft.irfft(out_fft, n=mode_sizes[-1], dim=fft_dims[-1], norm=self.fft_norm)
+            
+            else:
+                
+                # If Hemrmitian symmetry is not a concern, we can use irfftn on all dimensions.
+                x = torch.fft.irfftn(out_fft, s=mode_sizes, dim=fft_dims, norm=self.fft_norm)
+            
+
+        if self.bias is not None:
+            x = x + self.bias
+          
+        return x

sources/neuraloperator/neuralop/layers/spectral_projection.py

@@ -0,0 +1,102 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+
+
+def spectral_projection_divergence_free(u, domain_size, constraint_modes):
+    """Apply spectral projection layer to make a velocity field divergence-free.
+    
+    Parameters
+    ----------
+    u : torch.Tensor
+        Input velocity field [batch, 2, height, width] where the last two
+        dimensions represent the 2D velocity components (u_x, u_y)
+    domain_size : float or tuple of float
+        Physical domain size. If float, assumes square domain with same size for height and width.
+        If tuple, should be (height_size, width_size) for non-square domains.
+    constraint_modes : tuple
+        Number of modes to use for constraint resolution (height_modes, width_modes).
+        If larger than input dimensions, they are truncated to the input dimensions.
+    
+    Returns
+    -------
+    torch.Tensor
+        Divergence-free projected velocity field with [batch, 2, height, width] shape.
+        The output maintains the same shape as the input while satisfying ∇·u = 0.
+
+    Notes
+    -----
+    **Mathematical formulation:** Helmholtz-Hodge projection in spectral domain:
+    û_proj = û - (k·û)/|k|² * k. Enforces ∇·u = 0 by removing the irrotational component.
+    **Periodicity:** Velocity fields are assumed periodic. For non-periodic fields, extend
+    via Fourier continuation (neuralop.layers.fourier_continuation), project, then truncate.
+
+    References
+    ----------
+    The method is based on the spectral projection approach described in:
+    
+        [1] Towards Enforcing Hard Physics Constraints in Operator Learning Frameworks
+        V. Duruisseaux, M. Liu-Schiaffini, J. Berner, and A. Anandkumar
+        ICML 2024 AI for Science Workshop
+        https://openreview.net/pdf?id=Zvxm14Rd1F
+        
+        [2] Enforcing physical constraints in CNNs through differentiable PDE layer. 
+        C. M. Jiang, K. Kashinath, P. Prabhat, and P. Marcus
+        ICLR 2020 Workshop on Integration of Deep Neural Models and Differential Equations, 2020.
+        https://openreview.net/pdf?id=q2noHUqMkK
+    
+    
+    """
+    
+    device = u.device
+    dtype = u.dtype
+    batch_size, channels, height, width = u.shape
+    
+    # Get domain size
+    if isinstance(domain_size, (int, float)):
+        # Square domain: use same size for both dimensions
+        domain_height = domain_width = float(domain_size)
+    elif isinstance(domain_size, (tuple, list)) and len(domain_size) == 2:
+        # Non-square domain: separate sizes for height and width
+        domain_height, domain_width = float(domain_size[0]), float(domain_size[1])
+    
+    # Ensure constraint modes do not exceed input dimensions
+    constraint_modes = (min(constraint_modes[0], height), min(constraint_modes[1], width))
+    
+    # 2D FFT over height and width
+    u_ft = torch.fft.fftn(u, dim=(2, 3))  
+    
+    # Extract lower modes for both dimensions where the constraint is applied
+    if (height != constraint_modes[0]) or (width != constraint_modes[1]):
+        u_ft = torch.fft.fftshift(u_ft, dim=(2, 3))
+        u_ft = u_ft[:, :, 
+                    (height - constraint_modes[0])//2 : (height - constraint_modes[0])//2 + constraint_modes[0],
+                    (width - constraint_modes[1])//2 : (width - constraint_modes[1])//2 + constraint_modes[1]]
+        u_ft = torch.fft.ifftshift(u_ft, dim=(2, 3))
+    
+    # Set up wavenumber grids for spectral operations
+    ky = 2*np.pi * torch.fft.fftfreq(constraint_modes[0], d=domain_height/constraint_modes[0]).to(dtype).to(device)
+    kx = 2*np.pi * torch.fft.fftfreq(constraint_modes[1], d=domain_width/constraint_modes[1]).to(dtype).to(device)
+    KX, KY = torch.meshgrid(kx, ky, indexing='ij' if constraint_modes[0] == constraint_modes[1] else 'xy')
+    
+    
+    # Apply Helmholtz-Hodge projection: û_proj = û - (k·û)/|k|² * k
+    k_dot_u = KX * u_ft[:, 0, :, :] + KY * u_ft[:, 1, :, :]
+    k_squared = KX**2 + KY**2 + 1e-8    # Add small epsilon to avoid division by zero
+    
+    projected_u_ft = u_ft - (k_dot_u / k_squared).unsqueeze(1) * torch.stack([KX, KY], dim=0).unsqueeze(0)
+    
+    # Handle zero mode explicitly
+    projected_u_ft[:, :, 0, 0] = 0.0
+    
+    
+    # Pad zeros back to full resolution if needed
+    if height != constraint_modes[0] or width != constraint_modes[1]:
+        projected_u_ft = torch.fft.fftshift(projected_u_ft)
+        pad_h = height - constraint_modes[0]
+        pad_w = width - constraint_modes[1]
+        projected_u_ft = F.pad(projected_u_ft, [pad_w//2, pad_w - pad_w//2, pad_h//2, pad_h - pad_h//2])
+        projected_u_ft = torch.fft.ifftshift(projected_u_ft)
+    
+    # Transform back to physical space
+    return torch.fft.ifftn(projected_u_ft, dim=(2, 3)).real

sources/neuraloperator/neuralop/layers/spherical_convolution.py

@@ -0,0 +1,484 @@
+from typing import List, Optional, Union
+
+import torch
+from torch import nn
+from torch_harmonics import RealSHT, InverseRealSHT
+
+import tensorly as tl
+from tensorly.plugins import use_opt_einsum
+from tltorch.factorized_tensors.core import FactorizedTensor
+
+from neuralop.utils import validate_scaling_factor
+from .base_spectral_conv import BaseSpectralConv
+
+tl.set_backend("pytorch")
+use_opt_einsum("optimal")
+
+einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
+def _contract_dense(x, weight, separable=False, dhconv=True):
+    order = tl.ndim(x)
+    # batch-size, in_channels, x, y...
+    x_syms = list(einsum_symbols[:order])
+
+    # in_channels, out_channels, x, y...
+    weight_syms = list(x_syms[1:])  # no batch-size
+
+    # batch-size, out_channels, x, y...
+    if separable:
+        out_syms = [x_syms[0]] + list(weight_syms)
+    else:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+    if dhconv:
+        weight_syms.pop()
+
+    eq = "".join(x_syms) + "," + "".join(weight_syms) + "->" + "".join(out_syms)
+
+    if not torch.is_tensor(weight):
+        weight = weight.to_tensor()
+
+    return tl.einsum(eq, x, weight)
+
+
+def _contract_dense_separable(x, weight, separable=True, dhconv=False):
+    if not separable:
+        raise ValueError("This function is only for separable=True")
+    if dhconv:
+        return x * weight.unsqueeze(-1)
+    return x * weight
+
+
+def _contract_cp(x, cp_weight, separable=False, dhconv=True):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    rank_sym = einsum_symbols[order]
+    out_sym = einsum_symbols[order + 1]
+    out_syms = list(x_syms)
+
+    if separable:
+        factor_syms = [einsum_symbols[1] + rank_sym]  # in only
+    else:
+        out_syms[1] = out_sym
+        factor_syms = [einsum_symbols[1] + rank_sym, out_sym + rank_sym]  # in, out
+
+    if dhconv:
+        factor_syms += [xs + rank_sym for xs in x_syms[2:-1]]  # x, y, ...
+    else:
+        factor_syms += [xs + rank_sym for xs in x_syms[2:]]  # x, y, ...
+
+    eq = (
+        x_syms + "," + rank_sym + "," + ",".join(factor_syms) + "->" + "".join(out_syms)
+    )
+
+    return tl.einsum(eq, x, cp_weight.weights, *cp_weight.factors)
+
+
+def _contract_tucker(x, tucker_weight, separable=False, dhconv=False):
+    order = tl.ndim(x)
+
+    x_syms = str(einsum_symbols[:order])
+    out_sym = einsum_symbols[order]
+    out_syms = list(x_syms)
+    if separable:
+        core_syms = einsum_symbols[order + 1 : 2 * order]
+        # factor_syms = [einsum_symbols[1]+core_syms[0]] #in only
+        factor_syms = [xs + rs for (xs, rs) in zip(x_syms[1:], core_syms)]  # x, y, ...
+
+    elif dhconv:
+        core_syms = einsum_symbols[order + 1 : 2 * order]
+        out_syms[1] = out_sym
+        factor_syms = [
+            einsum_symbols[1] + core_syms[0],
+            out_sym + core_syms[1],
+        ]  # out, in
+        factor_syms += [
+            xs + rs for (xs, rs) in zip(x_syms[2:], core_syms[2:])
+        ]  # x, y, ...
+    else:
+        core_syms = einsum_symbols[order + 1 : 2 * order + 1]
+        out_syms[1] = out_sym
+        factor_syms = [
+            einsum_symbols[1] + core_syms[0],
+            out_sym + core_syms[1],
+        ]  # out, in
+        factor_syms += [
+            xs + rs for (xs, rs) in zip(x_syms[2:], core_syms[2:])
+        ]  # x, y, ...
+
+    eq = (
+        x_syms
+        + ","
+        + core_syms
+        + ","
+        + ",".join(factor_syms)
+        + "->"
+        + "".join(out_syms)
+    )
+
+    return tl.einsum(eq, x, tucker_weight.core, *tucker_weight.factors)
+
+
+def _contract_tt(x, tt_weight, separable=False, dhconv=False):
+    order = tl.ndim(x)
+
+    x_syms = list(einsum_symbols[:order])
+    weight_syms = list(x_syms[1:])  # no batch-size
+    if not separable:
+        weight_syms.insert(1, einsum_symbols[order])  # outputs
+        out_syms = list(weight_syms)
+        out_syms[0] = x_syms[0]
+    else:
+        out_syms = list(x_syms)
+
+    if dhconv:
+        weight_syms = weight_syms[:-1]  # no batch-size, no y dim
+
+    rank_syms = list(einsum_symbols[order + 1 :])
+    tt_syms = []
+    for i, s in enumerate(weight_syms):
+        tt_syms.append([rank_syms[i], s, rank_syms[i + 1]])
+    eq = (
+        "".join(x_syms)
+        + ","
+        + ",".join("".join(f) for f in tt_syms)
+        + "->"
+        + "".join(out_syms)
+    )
+
+    return tl.einsum(eq, x, *tt_weight.factors)
+
+
+def get_contract_fun(weight, implementation="reconstructed", separable=False):
+    """Generic ND implementation of Fourier Spectral Conv contraction
+
+    Parameters
+    ----------
+    weight : tensorly-torch's FactorizedTensor
+    implementation : {'reconstructed', 'factorized'}, default is 'reconstructed'
+        whether to reconstruct the weight and do a forward pass (reconstructed)
+        or contract directly the factors of the factorized weight with the input
+        (factorized)
+    separable : bool
+        whether to use the separable implementation of contraction. This arg is
+        only checked when `implementation=reconstructed`.
+
+    Returns
+    -------
+    function : (x, weight) -> x * weight in Fourier space
+    """
+    if implementation == "reconstructed":
+        if separable:
+            return _contract_dense_separable
+        else:
+            return _contract_dense
+    elif implementation == "factorized":
+        if torch.is_tensor(weight):
+            return _contract_dense
+        elif isinstance(weight, FactorizedTensor):
+            if weight.name.lower().endswith("dense"):
+                return _contract_dense
+            elif weight.name.lower().endswith("tucker"):
+                return _contract_tucker
+            elif weight.name.lower().endswith("tt"):
+                return _contract_tt
+            elif weight.name.lower().endswith("cp"):
+                return _contract_cp
+            else:
+                raise ValueError(f"Got unexpected factorized weight type {weight.name}")
+        else:
+            raise ValueError(
+                f"Got unexpected weight type of class {weight.__class__.__name__}"
+            )
+    else:
+        raise ValueError(
+            f'Got implementation={implementation}, expected "reconstructed" or '
+            f'"factorized"'
+        )
+
+
+Number = Union[int, float]
+
+
+class SHT(nn.Module):
+    """A wrapper for the Spherical Harmonics transform.
+
+    Allows to call it with an interface similar to that of FFT
+    """
+
+    def __init__(self, dtype=torch.float32, device=None):
+        super().__init__()
+        self.device = device
+        self.dtype = dtype
+        self._SHT_cache = nn.ModuleDict()
+        self._iSHT_cache = nn.ModuleDict()
+
+    def sht(self, x, s=None, norm="ortho", grid="equiangular"):
+        *_, height, width = x.shape  # height = latitude, width = longitude
+        if s is None:
+            if grid == "equiangular":
+                modes_width = height // 2
+            else:
+                modes_width = height
+            modes_height = height
+        else:
+            modes_height, modes_width = s
+
+        cache_key = f"{height}_{width}_{modes_height}_{modes_width}_{norm}_{grid}"
+
+        try:
+            sht = self._SHT_cache[cache_key]
+        except KeyError:
+            sht = (
+                RealSHT(
+                    nlat=height,
+                    nlon=width,
+                    lmax=modes_height,
+                    mmax=modes_width,
+                    grid=grid,
+                    norm=norm,
+                )
+                .to(device=x.device)
+                .to(dtype=self.dtype)
+            )
+            self._SHT_cache[cache_key] = sht
+
+        return sht(x)
+
+    def isht(self, x, s=None, norm="ortho", grid="equiangular"):
+        *_, modes_height, modes_width = x.shape  # height = latitude, width = longitude
+        if s is None:
+            if grid == "equiangular":
+                width = modes_width * 2
+            else:
+                width = modes_width
+            height = modes_height
+        else:
+            height, width = s
+
+        cache_key = f"{height}_{width}_{modes_height}_{modes_width}_{norm}_{grid}"
+
+        try:
+            isht = self._iSHT_cache[cache_key]
+        except KeyError:
+            isht = (
+                InverseRealSHT(
+                    nlat=height,
+                    nlon=width,
+                    lmax=modes_height,
+                    mmax=modes_width,
+                    grid=grid,
+                    norm=norm,
+                )
+                .to(device=x.device)
+                .to(dtype=self.dtype)
+            )
+            self._iSHT_cache[cache_key] = isht
+
+        return isht(x)
+
+
+class SphericalConv(BaseSpectralConv):
+    """Spherical Convolution for the SFNO. 
+    
+    It is implemented as described in [1]_.
+
+    Parameters
+    ----------
+    sht_norm : str, {'ortho'}
+    sht_grids : str or str list, default is "equiangular", {"equiangular", "legendre-gauss"}
+                * If str, the same grid is used for all layers
+                * If list, should have n_layers + 1 values, corresponding to the input and output grid of each layer
+                  e.g. for 1 layer, ["input_grid", "output_grid"]
+
+    See SpectralConv for full list of other parameters
+
+    References
+    ----------
+    .. [1] Spherical Fourier Neural Operators: Learning Stable Dynamics on the Sphere,
+           Boris Bonev, Thorsten Kurth, Christian Hundt, Jaideep Pathak, Maximilian Baust, Karthik Kashinath, Anima Anandkumar,
+           ICML 2023.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        n_modes,
+        max_n_modes=None,
+        bias=True,
+        separable=False,
+        resolution_scaling_factor: Optional[Union[Number, List[Number]]] = None,
+        fno_block_precision="full",
+        rank=0.5,
+        factorization="cp",
+        implementation="reconstructed",
+        fixed_rank_modes=False,
+        joint_factorization=False,
+        decomposition_kwargs=dict(),
+        init_std="auto",
+        sht_norm="ortho",
+        sht_grids="equiangular",
+        device=None,
+        dtype=torch.float32,
+        complex_data=False,  # dummy param until we unify dtype interface
+    ):
+        super().__init__(dtype=dtype, device=device)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.joint_factorization = joint_factorization
+
+        if isinstance(n_modes, int):
+            n_modes = [n_modes]
+        self._n_modes = n_modes
+        self.order = len(n_modes)
+
+        if max_n_modes is None:
+            max_n_modes = self.n_modes
+        elif isinstance(max_n_modes, int):
+            max_n_modes = [max_n_modes]
+        self.max_n_modes = max_n_modes
+
+        self.rank = rank
+        self.factorization = factorization
+        self.implementation = implementation
+
+        self.resolution_scaling_factor: Union[
+            None, List[List[float]]
+        ] = validate_scaling_factor(resolution_scaling_factor, self.order)
+
+        if init_std == "auto":
+            init_std = (2 / (in_channels + out_channels)) ** 0.5
+
+        if isinstance(fixed_rank_modes, bool):
+            if fixed_rank_modes:
+                # If bool, keep the number of layers fixed
+                fixed_rank_modes = [0]
+            else:
+                fixed_rank_modes = None
+
+        # Make sure we are using a Complex Factorized Tensor to parametrize the conv
+        if factorization is None:
+            factorization = "Dense"  # No factorization
+        if not factorization.lower().startswith("complex"):
+            factorization = f"Complex{factorization}"
+
+        if separable:
+            if in_channels != out_channels:
+                raise ValueError(
+                    "To use separable Fourier Conv, in_channels must be equal "
+                    f"to out_channels, but got in_channels={in_channels} "
+                    f"and out_channels={out_channels}",
+                )
+            weight_shape = (in_channels, *self.n_modes[:-1])
+        else:
+            weight_shape = (in_channels, out_channels, *self.n_modes[:-1])
+        self.separable = separable
+        self.weight = FactorizedTensor.new(
+            weight_shape,
+            rank=self.rank,
+            factorization=factorization,
+            fixed_rank_modes=fixed_rank_modes,
+            **decomposition_kwargs,
+        )
+        self.weight.normal_(0, init_std)
+
+        self._contract = get_contract_fun(
+            self.weight, implementation=implementation, separable=separable
+        )
+
+        if bias:
+            self.bias = nn.Parameter(
+                init_std
+                * torch.randn(*(tuple([self.out_channels]) + (1,) * self.order))
+            )
+        else:
+            self.bias = None
+
+        self.sht_norm = sht_norm
+        if isinstance(sht_grids, str):
+            sht_grids = [sht_grids] * 2
+        self.sht_grids = sht_grids
+        self.sht_handle = SHT(dtype=self.dtype, device=self.device)
+
+    def transform(self, x, output_shape=None):
+        *_, in_height, in_width = x.shape
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            height = round(in_height * self.resolution_scaling_factor[0])
+            width = round(in_width * self.resolution_scaling_factor[1])
+        elif output_shape is not None:
+            height, width = output_shape[0], output_shape[1]
+        else:
+            height, width = in_height, in_width
+
+        # Return the identity if the resolution and grid of the input and output are the same
+        if ((in_height, in_width) == (height, width)) and (self.sht_grids[0] == self.sht_grids[1]):
+            return x
+        else:
+            coefs = self.sht_handle.sht(
+                x, s=self.n_modes, norm=self.sht_norm, grid=self.sht_grids[0]
+            )
+            return self.sht_handle.isht(
+                coefs, s=(height, width), norm=self.sht_norm, grid=self.sht_grids[1]
+            )
+
+    def forward(self, x, output_shape=None):
+        """Generic forward pass for the Factorized Spectral Conv
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            input activation of size (batch_size, channels, d1, ..., dN)
+
+        Returns
+        -------
+        tensorized_spectral_conv(x)
+        """
+        batchsize, channels, height, width = x.shape
+
+        if self.resolution_scaling_factor is not None and output_shape is None:
+            scaling_factors = self.resolution_scaling_factor
+            height = round(height * scaling_factors[0])
+            width = round(width * scaling_factors[1])
+        elif output_shape is not None:
+            height, width = output_shape[0], output_shape[1]
+
+        out_fft = self.sht_handle.sht(
+            x,
+            s=(self.n_modes[0], self.n_modes[1] // 2),
+            norm=self.sht_norm,
+            grid=self.sht_grids[0],
+        )
+
+        out_fft = self._contract(
+            out_fft[:, :, : self.n_modes[0], : self.n_modes[1] // 2],
+            self.weight[:, :, : self.n_modes[0]],
+            separable=self.separable,
+            dhconv=True,
+        )
+
+        x = self.sht_handle.isht(
+            out_fft, s=(height, width), norm=self.sht_norm, grid=self.sht_grids[1]
+        )
+
+        if self.bias is not None:
+            x = x + self.bias
+
+        return x
+
+    @property
+    def n_modes(self):
+        return self._n_modes
+
+    @n_modes.setter
+    def n_modes(self, n_modes):
+        if isinstance(n_modes, int):  # Should happen for 1D FNO only
+            n_modes = [n_modes]
+        else:
+            n_modes = list(n_modes)
+        self._n_modes = n_modes

sources/neuraloperator/neuralop/layers/tests/test_attention_layer.py

@@ -0,0 +1,32 @@
+import pytest
+import torch
+from ..attention_kernel_integral import AttentionKernelIntegral
+from ..embeddings import RotaryEmbedding2D
+
+
+def test_AttentionWithRoPE():
+    """Test for Attention kernel integral with rotary position embeddings
+
+    Checks the output size
+    """
+    head_n_channels = 32
+    channels = 32
+    num_heads = 4
+    n_dim = 2
+    num_points = 64
+    batch_size = 4
+
+    attn_layer = AttentionKernelIntegral(channels, channels, num_heads, head_n_channels)
+    pos_emb_module = RotaryEmbedding2D(head_n_channels // n_dim)
+
+    x = torch.randn(batch_size, num_points, channels)
+    pos = torch.randn(batch_size, num_points, n_dim)
+
+    freqs_0 = pos_emb_module(pos[..., 0])
+    assert freqs_0.shape == (batch_size, num_points, head_n_channels // n_dim)
+
+    freqs_1 = pos_emb_module(pos[..., 1])
+    assert freqs_1.shape == (batch_size, num_points, head_n_channels // n_dim)
+
+    res = attn_layer(x, pos, positional_embedding_module=pos_emb_module)
+    assert res.shape == (batch_size, num_points, channels)

sources/neuraloperator/neuralop/layers/tests/test_coda_layer.py

@@ -0,0 +1,57 @@
+import pytest
+import torch
+from ..coda_layer import *
+from ..spectral_convolution import *
+
+device = "cuda" if torch.backends.cuda.is_built() else "cpu"
+# device = 'cpu'
+
+
+@pytest.mark.parametrize("token_codimension", [1, 2, 5])
+@pytest.mark.parametrize("n_dim", [2, 3])
+@pytest.mark.parametrize("norm", ["instance_norm", None])
+@pytest.mark.parametrize("nonlinear_attention", ["True", "False"])
+@pytest.mark.parametrize("per_channel_attention", ["False", "True"])
+@pytest.mark.parametrize("output_scale", [1, 2])
+def test_Codano(
+    token_codimension,
+    n_dim,
+    norm,
+    nonlinear_attention,
+    per_channel_attention,
+    output_scale,
+):
+    """
+    Test CoDA-NO layers
+    """
+    n_modes = [64] * n_dim
+    n_heads = 3
+    head_codimension = 3
+    codimension_size = None
+    permutation_eq = True
+    temperature = 1.0
+
+    layer = CODALayer(
+        n_modes=n_modes,
+        n_heads=n_heads,
+        token_codimension=token_codimension,
+        head_codimension=head_codimension,
+        norm=norm,
+        codimension_size=codimension_size,
+        per_channel_attention=per_channel_attention,
+        permutation_eq=permutation_eq,
+        temperature=temperature,
+        nonlinear_attention=nonlinear_attention,
+    ).to(device)
+
+    spatial_res = [64] * n_dim
+    x = torch.randn(2, 10, *spatial_res).to(device)
+    output_shape = [int(s * output_scale) for s in spatial_res]
+    out = layer(x, output_shape)
+    assert list(out.shape[-n_dim:]) == output_shape
+
+    # test different spatial resolution
+    spatial_res = [48] * n_dim
+    x = torch.randn(2, 10, *spatial_res).to(device)
+    out = layer(x)
+    assert out.shape == x.shape

sources/neuraloperator/neuralop/layers/tests/test_disco_conv.py

@@ -0,0 +1,98 @@
+import pytest
+import torch
+
+# Skip tests if torch_harmonics is not installed
+try:
+    import torch_harmonics
+except ModuleNotFoundError:
+    pytest.skip(
+        "Skipping because torch_harmonics is not installed", allow_module_level=True
+    )
+
+from ..discrete_continuous_convolution import (
+    DiscreteContinuousConv2d,
+    DiscreteContinuousConvTranspose2d,
+    EquidistantDiscreteContinuousConv2d,
+    EquidistantDiscreteContinuousConvTranspose2d,
+)
+
+from ..embeddings import regular_grid_2d
+
+# global params
+batch_size = 4
+in_channels = 6
+out_channels = 3
+side_length_in = 64
+side_length_out = 48
+
+device = "cuda" if torch.backends.cuda.is_built() else "cpu"
+
+
+@pytest.mark.parametrize(
+    "conv_type", [DiscreteContinuousConv2d, DiscreteContinuousConvTranspose2d]
+)
+@pytest.mark.parametrize("groups", [1, 3])
+@pytest.mark.parametrize("basis_type", ["piecewise_linear", "morlet", "zernike"])
+def test_regular_disco_conv2d(conv_type, groups, basis_type):
+    # create regular grids of in and output coords
+    grid_in = torch.stack(
+        regular_grid_2d(spatial_dims=[side_length_in, side_length_in])
+    )
+    grid_out = torch.stack(
+        regular_grid_2d(spatial_dims=[side_length_out, side_length_out])
+    )
+
+    # reshape grids to point clouds (channels, n_pts)
+    grid_in = grid_in.view(2, -1)
+    grid_out = grid_out.view(2, -1)
+
+    # quad weights: one weight per point
+    quadrature_weights = torch.randn(grid_in.shape[1])
+
+    conv_layer = conv_type(
+        in_channels=in_channels,
+        out_channels=out_channels,
+        basis_type=basis_type,
+        grid_in=grid_in,
+        grid_out=grid_out,
+        kernel_shape=3,
+        quadrature_weights=quadrature_weights,
+        groups=groups,
+    )
+
+    # start with a grid, pass to forward as a point cloud
+    x = torch.randn(batch_size, in_channels, side_length_in, side_length_in)
+    x = x.reshape(batch_size, in_channels, -1)
+
+    res = conv_layer(x)
+    assert res.shape == (batch_size, out_channels, side_length_out**2)
+
+
+@pytest.mark.parametrize(
+    "conv_type",
+    [EquidistantDiscreteContinuousConv2d, EquidistantDiscreteContinuousConvTranspose2d],
+)
+@pytest.mark.parametrize("groups", [1, 3])
+@pytest.mark.parametrize("basis_type", ["piecewise_linear", "morlet", "zernike"])
+def test_equidistant_disco_conv2d(conv_type, groups, basis_type):
+    in_shape = (side_length_in, side_length_in)
+    if conv_type == EquidistantDiscreteContinuousConv2d:
+        out_shape = (side_length_in // 2, side_length_in // 2)
+    else:
+        out_shape = (side_length_in * 2, side_length_in * 2)
+
+    conv_layer = conv_type(
+        in_channels=in_channels,
+        out_channels=out_channels,
+        in_shape=in_shape,
+        out_shape=out_shape,
+        basis_type=basis_type,
+        kernel_shape=3,
+        groups=groups,
+    )
+
+    # start with a grid, pass to forward as a grid
+    x = torch.randn(batch_size, in_channels, *in_shape)
+
+    res = conv_layer(x)
+    assert res.shape == (batch_size, out_channels, *out_shape)

sources/neuraloperator/neuralop/layers/tests/test_finite_difference_conv.py

@@ -0,0 +1,67 @@
+####### ####### #######
+# This script discretizes a parabola on a 2d grid and check to see that
+# the output converges to the theoretical limit.
+####### ####### #######
+
+import pytest
+import numpy as np
+import torch
+import math
+
+from ..differential_conv import FiniteDifferenceConvolution
+
+
+def get_grid(S, batchsize, device):
+    gridx = torch.tensor(np.linspace(0, 1, S), dtype=torch.float)
+    gridx = gridx.reshape(1, 1, S, 1).repeat([batchsize, 1, 1, S])
+    gridy = torch.tensor(np.linspace(0, 1, S), dtype=torch.float)
+    gridy = gridy.reshape(1, 1, 1, S).repeat([batchsize, 1, S, 1])
+    return torch.cat((gridx, gridy), dim=1).to(device)
+
+
+@pytest.mark.parametrize("resolution", [500, 700, 1000])
+def test_convergence_FiniteDifferenceConvolution_subtract_middle(resolution):
+    torch.manual_seed(0)
+    device = torch.device("cpu")
+
+    num_channels = 10
+    kernel_size = 3
+    coeff = torch.rand((num_channels,))
+
+    differential_block = FiniteDifferenceConvolution(
+        in_channels=num_channels,
+        out_channels=1,
+        n_dim=2,
+        kernel_size=kernel_size,
+        groups=1,  # mixing derivatives
+    ).to(device)
+
+    with torch.no_grad():
+        weight = differential_block.conv.weight[0]  # [0] because output channels is 1
+
+    diff_block_output_list = []
+    grid_width = 1 / resolution
+    grid = get_grid(resolution, 1, device)
+
+    channels = [
+        torch.sum(coeff[i] * torch.square(grid), dim=1) for i in range(num_channels)
+    ]
+    parabola = torch.stack(channels, dim=1).to(device)
+
+    diff_block_output = differential_block(parabola, grid_width)
+    diff_block_output_list.append(diff_block_output)
+
+    theoretical_value = 0
+    for k in range(num_channels):
+        direction_k = 0
+        for i in range(kernel_size):
+            for j in range(kernel_size):
+                direction_k += weight[k, i, j] * torch.tensor(
+                    [[[[i - kernel_size // 2, j - kernel_size // 2]]]]
+                ).to(device)
+        direction_k = direction_k.movedim(-1, 1).repeat([1, 1, resolution, resolution])
+        theoretical_value += 2 * coeff[k] * torch.sum(grid * direction_k, dim=1)
+    
+    error = 1/(resolution-2) * torch.norm(diff_block_output.squeeze()[1:-1, 1:-1] - theoretical_value.squeeze()[1:-1, 1:-1]).item()
+
+    assert math.isclose(0, error, abs_tol=0.1)

sources/neuraloperator/neuralop/layers/tests/test_fno_block.py

@@ -0,0 +1,250 @@
+import pytest
+import torch
+from ..fno_block import FNOBlocks
+
+
+def test_FNOBlock_resolution_scaling_factor():
+    """Test FNOBlocks with upsampled or downsampled outputs"""
+    max_n_modes = [8, 8, 8, 8]
+    n_modes = [4, 4, 4, 4]
+
+    size = [10] * 4
+    channel_mlp_dropout = 0
+    channel_mlp_expansion = 0.5
+    channel_mlp_skip = "linear"
+    for dim in [1, 2, 3, 4]:
+        block = FNOBlocks(
+            3,
+            4,
+            max_n_modes[:dim],
+            max_n_modes=max_n_modes[:dim],
+            n_layers=1,
+            channel_mlp_skip=channel_mlp_skip,
+        )
+
+        assert block.convs[0].n_modes[:-1] == max_n_modes[: dim - 1]
+        assert block.convs[0].n_modes[-1] == max_n_modes[dim - 1] // 2 + 1
+
+        block.n_modes = n_modes[:dim]
+        assert block.convs[0].n_modes[:-1] == n_modes[: dim - 1]
+        assert block.convs[0].n_modes[-1] == n_modes[dim - 1] // 2 + 1
+
+        block.n_modes = max_n_modes[:dim]
+        assert block.convs[0].n_modes[:-1] == max_n_modes[: dim - 1]
+        assert block.convs[0].n_modes[-1] == max_n_modes[dim - 1] // 2 + 1
+
+        # Downsample outputs
+        block = FNOBlocks(
+            3,
+            4,
+            n_modes[:dim],
+            n_layers=1,
+            resolution_scaling_factor=0.5,
+            use_channel_mlp=True,
+            channel_mlp_dropout=channel_mlp_dropout,
+            channel_mlp_expansion=channel_mlp_expansion,
+            channel_mlp_skip=channel_mlp_skip,
+        )
+
+        x = torch.randn(2, 3, *size[:dim])
+        res = block(x)
+        assert list(res.shape[2:]) == [m // 2 for m in size[:dim]]
+
+        # Upsample outputs
+        block = FNOBlocks(
+            3,
+            4,
+            n_modes[:dim],
+            n_layers=1,
+            resolution_scaling_factor=2,
+            channel_mlp_dropout=channel_mlp_dropout,
+            channel_mlp_expansion=channel_mlp_expansion,
+            channel_mlp_skip=channel_mlp_skip,
+        )
+
+        x = torch.randn(2, 3, *size[:dim])
+        res = block(x)
+        assert res.shape[1] == 4  # Check out channels
+        assert list(res.shape[2:]) == [m * 2 for m in size[:dim]]
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3, 4])
+@pytest.mark.parametrize(
+    "norm", ["instance_norm", "ada_in", "group_norm", "batch_norm"]
+)
+def test_FNOBlock_norm(norm, n_dim):
+    """Test SpectralConv with upsampled or downsampled outputs"""
+    modes = (8, 8, 8)
+    size = [10] * 3
+    channel_mlp_dropout = 0
+    channel_mlp_expansion = 0.5
+    channel_mlp_skip = "linear"
+    ada_in_features = 4
+    block = FNOBlocks(
+        3,
+        4,
+        modes[:n_dim],
+        n_layers=1,
+        norm=norm,
+        ada_in_features=ada_in_features,
+        channel_mlp_dropout=channel_mlp_dropout,
+        channel_mlp_expansion=channel_mlp_expansion,
+        channel_mlp_skip=channel_mlp_skip,
+    )
+
+    if norm == "ada_in":
+        embedding = torch.randn(ada_in_features)
+        block.set_ada_in_embeddings(embedding)
+
+    x = torch.randn(2, 3, *size[:n_dim])
+    res = block(x)
+    assert list(res.shape[2:]) == size[:n_dim]
+
+
+@pytest.mark.parametrize("norm_groups", [1, 2, 4, 8])
+def test_FNOBlock_group_norm(norm_groups):
+    """Test FNOBlocks with group_norm and custom norm_groups"""
+    modes = (8, 8, 8)
+    hidden_channels = 16
+    n_layers = 1
+    
+    block = FNOBlocks(
+        in_channels=hidden_channels,
+        out_channels=hidden_channels,
+        n_modes=modes,
+        n_layers=n_layers,
+        norm="group_norm",
+        norm_groups=norm_groups,
+    )
+    
+    # Check that GroupNorm layers are correctly initialized
+    assert block.norm is not None
+    for norm_layer in block.norm:
+        assert isinstance(norm_layer, torch.nn.GroupNorm)
+        assert norm_layer.num_groups == norm_groups
+        assert norm_layer.num_channels == hidden_channels
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+def test_FNOBlock_complex_data(n_dim):
+    """Test FNO layers with complex input data"""
+    modes = (8, 8, 8)
+    size = [10] * 3
+    channel_mlp_dropout = 0
+    channel_mlp_expansion = 0.5
+    channel_mlp_skip = "linear"
+    # Instantiate a complex-valued FNO block
+    block = FNOBlocks(
+        3,
+        4,
+        modes[:n_dim],
+        n_layers=1,
+        channel_mlp_dropout=channel_mlp_dropout,
+        channel_mlp_expansion=channel_mlp_expansion,
+        channel_mlp_skip=channel_mlp_skip,
+        complex_data=True,
+    )
+
+    x = torch.randn(2, 3, *size[:n_dim], dtype=torch.cfloat)
+    res = block(x)
+
+    assert list(res.shape[2:]) == size[:n_dim]
+
+
+@pytest.mark.parametrize("fno_skip", ["linear", None])
+@pytest.mark.parametrize("channel_mlp_skip", ["linear", None])
+def test_FNOBlock_skip_connections(fno_skip, channel_mlp_skip):
+    """Test FNOBlocks with different skip connection options including None"""
+    modes = (8, 8, 8)
+    size = [10, 10, 10]
+
+    # Skip test cases that are incompatible
+    # Soft-gating requires same input/output channels
+    if fno_skip == "soft-gating" or channel_mlp_skip == "soft-gating":
+        pytest.skip("Soft-gating requires same input/output channels")
+
+    # Test with channel MLP enabled
+    block = FNOBlocks(
+        3,
+        4,
+        modes,
+        n_layers=2,
+        fno_skip=fno_skip,
+        channel_mlp_skip=channel_mlp_skip,
+        use_channel_mlp=True,
+        channel_mlp_expansion=0.5,
+        channel_mlp_dropout=0.0,
+    )
+
+    x = torch.randn(2, 3, *size)
+    res = block(x)
+
+    # Check output shape
+    assert res.shape == (2, 4, *size)
+
+    # Test with channel MLP disabled
+    block_no_mlp = FNOBlocks(
+        3,
+        4,
+        modes,
+        n_layers=2,
+        fno_skip=fno_skip,
+        channel_mlp_skip=channel_mlp_skip,
+        use_channel_mlp=False,
+    )
+
+    res_no_mlp = block_no_mlp(x)
+    assert res_no_mlp.shape == (2, 4, *size)
+
+
+@pytest.mark.parametrize("fno_skip", ["linear", None])
+@pytest.mark.parametrize("channel_mlp_skip", ["linear", None])
+def test_FNOBlock_skip_connections_preactivation(fno_skip, channel_mlp_skip):
+    """Test FNOBlocks with preactivation and different skip connection options"""
+    modes = (8, 8, 8)
+    size = [10, 10, 10]
+
+    # Test with preactivation enabled
+    block = FNOBlocks(
+        3,
+        4,
+        modes,
+        n_layers=2,
+        fno_skip=fno_skip,
+        channel_mlp_skip=channel_mlp_skip,
+        use_channel_mlp=True,
+        channel_mlp_expansion=0.5,
+        channel_mlp_dropout=0.0,
+        preactivation=True,
+    )
+
+    x = torch.randn(2, 3, *size)
+    res = block(x)
+
+    # Check output shape
+    assert res.shape == (2, 4, *size)
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+def test_FNOBlock_conv_bias_kernel(n_dim):
+    """Test local convolutional bias kernels beside spectral convolution."""
+    modes = (8, 8, 8)
+    size = [10, 10, 10]
+    conv_bias_kernel = 3
+
+    block = FNOBlocks(
+        3,
+        4,
+        modes[:n_dim],
+        n_layers=2,
+        conv_bias_kernel=conv_bias_kernel,
+        fno_skip="linear",
+        use_channel_mlp=False,
+    )
+
+    x = torch.randn(2, 3, *size[:n_dim])
+    res = block(x)
+
+    assert res.shape == (2, 4, *size[:n_dim])
+    assert block.conv_bias_kernel == conv_bias_kernel
+    assert block.fno_skips[0].kernel_size == (conv_bias_kernel,) * n_dim

sources/neuraloperator/neuralop/layers/tests/test_fourier_continuation.py

@@ -0,0 +1,135 @@
+import torch
+import pytest
+from ..fourier_continuation import FCLegendre, FCGram
+
+
+@pytest.mark.parametrize("FC_class", [FCLegendre, FCGram])
+@pytest.mark.parametrize("dim", [1, 2, 3])
+@pytest.mark.parametrize("d", [3, 4])
+def test_fourier_continuation(FC_class, dim: int, d: int):
+    if dim == 1:
+        batch_size = 3
+        length_signal = 101
+        add_pts = 50
+
+        x = torch.linspace(0, 1, length_signal).repeat(batch_size, 1)
+        f = torch.sin(16 * x) - torch.cos(8 * x)
+
+        Extension = FC_class(d=d, n_additional_pts=add_pts)
+
+        f_extend = Extension(f, dim=1)
+
+        # Check shape
+        assert f_extend.shape[-1] == f.shape[-1] + add_pts
+        # Check values of original signal
+        torch.testing.assert_close(f, f_extend[..., add_pts // 2 : -add_pts // 2])
+
+    if dim == 2:
+        batch_size = 3
+        length_signal = 101
+        add_pts = 50
+
+        x = torch.linspace(0, 1, length_signal).view(1, length_signal, 1).repeat(batch_size, 1, length_signal)
+        y = torch.linspace(0, 1, length_signal).view(1, 1, length_signal).repeat(batch_size, length_signal, 1)
+        f = torch.sin(12 * x)  - torch.cos(14 * y) + 3*x*y
+        
+        Extension = FC_class(d=d, n_additional_pts=add_pts)
+
+        f_extend = Extension(f, dim=2)
+
+        # Check shape
+        assert f_extend.shape[-1] == f.shape[-1] + add_pts
+        assert f_extend.shape[-2] == f.shape[-2] + add_pts
+        # Check values of original signal
+        torch.testing.assert_close(
+            f, f_extend[..., add_pts // 2 : -add_pts // 2, add_pts // 2 : -add_pts // 2]
+        )
+
+    if dim == 3:
+        batch_size = 2
+        length_signal = 81
+        add_pts = 50
+
+        # Create 3D grid
+        x = torch.linspace(0, 1, length_signal).view(1, length_signal, 1, 1).repeat(batch_size, 1, length_signal, length_signal)
+        y = torch.linspace(0, 1, length_signal).view(1, 1, length_signal, 1).repeat(batch_size, length_signal, 1, length_signal)
+        z = torch.linspace(0, 1, length_signal).view(1, 1, 1, length_signal).repeat(batch_size, length_signal, length_signal, 1)
+
+        # Create 3D function
+        f = torch.exp(-2*z) + 2*z*x + torch.sin(12*x*y) + y*torch.sin(10*y*z) 
+
+        Extension = FC_class(d=d, n_additional_pts=add_pts)
+
+        f_extend = Extension(f, dim=3)
+
+        # Check shape
+        assert f_extend.shape[-1] == f.shape[-1] + add_pts
+        assert f_extend.shape[-2] == f.shape[-2] + add_pts
+        assert f_extend.shape[-3] == f.shape[-3] + add_pts
+        # Check values of original signal
+        torch.testing.assert_close(
+            f,
+            f_extend[
+                ...,
+                add_pts // 2 : -add_pts // 2,
+                add_pts // 2 : -add_pts // 2,
+                add_pts // 2 : -add_pts // 2,
+            ],
+        )
+
+
+@pytest.mark.parametrize("FC_class", [FCLegendre, FCGram])
+@pytest.mark.parametrize(
+    "dim_tuple",
+    [(1,), (2,), (1, 2), (1, 3), (2, 3), (-1,), (-2,), (-1, -2), (-1, -3), (1, -1)],
+)
+@pytest.mark.parametrize("d", [3, 4])
+def test_fourier_continuation_tuple_dims(FC_class, dim_tuple, d: int):
+    """
+    Test Fourier continuation with tuple dimensions.
+
+    Tests various combinations of positive and negative axis indices
+    to ensure the extension works correctly along specific axes.
+    """
+    batch_size = 2
+    add_pts = 30
+
+    # Create a 4D tensor for comprehensive testing
+    x = torch.randn(batch_size, 20, 25, 30)
+
+    try:
+        Extension = FC_class(d=d, n_additional_pts=add_pts)
+    except FileNotFoundError as e:
+        if FC_class.__name__ == "FCGram":
+            pytest.skip(f"FCGram matrices not available: {e}")
+        else:
+            raise
+
+    # Extend along specified dimensions
+    f_extend = Extension(x, dim=dim_tuple)
+
+    # Calculate expected shape
+    expected_shape = list(x.shape)
+    for dim in dim_tuple:
+        # Convert negative indices to positive
+        if dim < 0:
+            dim = x.ndim + dim
+        expected_shape[dim] += add_pts
+
+    # Check shape
+    assert f_extend.shape == tuple(
+        expected_shape
+    ), f"Expected shape {tuple(expected_shape)}, got {f_extend.shape}"
+
+    # Test restrict functionality
+    f_restricted = Extension.restrict(f_extend, dim=dim_tuple)
+
+    # Check that restrict returns original shape
+    assert (
+        f_restricted.shape == x.shape
+    ), f"Restrict failed: expected {x.shape}, got {f_restricted.shape}"
+
+    # Check that restrict returns original values
+    torch.testing.assert_close(
+        x, f_restricted, msg="Restrict did not return original values"
+    )

sources/neuraloperator/neuralop/layers/tests/test_gno_block.py

@@ -0,0 +1,110 @@
+import torch
+from torch.autograd import grad
+import pytest
+from tensorly import tenalg
+
+tenalg.set_backend("einsum")
+
+# Parameterize use of torch_scatter if it is built
+try:
+    from torch_scatter import segment_csr
+
+    use_torch_scatter = [True, False]
+except:
+    use_torch_scatter = [False]
+
+from ..gno_block import GNOBlock
+
+# Fixed variables
+in_channels = 3
+out_channels = 3
+mlp_hidden_layers = [16, 16, 16]
+
+# data parameters
+n_in = 100
+n_out = 100
+
+# test open3d mode if built
+try:
+    from neighbor_search import FixedRadiusSearch
+
+    open3d_built = True
+except:
+    open3d_built = False
+
+if open3d_built:
+    use_open3d_parametrize = [True, False]
+else:
+    use_open3d_parametrize = [False]
+
+
+@pytest.mark.parametrize("batch_size", [1, 4])
+@pytest.mark.parametrize("gno_coord_dim", [2, 3])
+@pytest.mark.parametrize("gno_pos_embed_type", ["nerf", "transformer", None])
+@pytest.mark.parametrize(
+    "gno_transform_type", ["linear", "nonlinear_kernelonly", "nonlinear"]
+)
+@pytest.mark.parametrize("use_open3d", use_open3d_parametrize)
+@pytest.mark.parametrize("use_torch_scatter", use_torch_scatter)
+def test_gno_block(
+    gno_transform_type,
+    gno_coord_dim,
+    gno_pos_embed_type,
+    batch_size,
+    use_open3d,
+    use_torch_scatter,
+):
+    if torch.backends.cuda.is_built():
+        device = torch.device("cuda:0")
+    else:
+        device = torch.device("cpu:0")
+
+    use_open3d = use_open3d and (gno_coord_dim == 3)
+
+    gno_block = GNOBlock(
+        in_channels=in_channels,
+        out_channels=out_channels,  # dummy var currently
+        coord_dim=gno_coord_dim,
+        pos_embedding_type=gno_pos_embed_type,
+        radius=0.25,
+        channel_mlp_layers=mlp_hidden_layers,
+        transform_type=gno_transform_type,
+        use_open3d_neighbor_search=use_open3d,
+        use_torch_scatter_reduce=use_torch_scatter,
+    ).to(device)
+
+    # create input geometry and output queries
+    input_geom_shape = [n_in, gno_coord_dim]
+    input_geom = torch.randn(*input_geom_shape, device=device)
+
+    output_queries_shape = [n_out, gno_coord_dim]
+    output_queries = torch.randn(*output_queries_shape, device=device)
+
+    f_y = None
+    if gno_transform_type != "linear":
+        # create data and features
+        f_y_shape = [batch_size, n_in, in_channels]
+        f_y = torch.randn(*f_y_shape, device=device)
+        # require and retain grad to check for backprop
+        f_y.requires_grad_(True)
+
+    out = gno_block(y=input_geom, x=output_queries, f_y=f_y)
+
+    # Check output size
+    # Batched outputs only matter in the nonlinear kernel use case
+    if gno_transform_type != "linear":
+        assert list(out.shape) == [batch_size, n_out, out_channels]
+    else:
+        assert list(out.shape) == [n_out, out_channels]
+
+    # Check backward pass
+    assert out.isfinite().all()
+    if batch_size > 1:
+        loss = out[0].sum()
+    else:
+        loss = out.sum()
+    loss.backward()
+
+    if batch_size > 1 and gno_transform_type != "linear":
+        # assert f_y[1:] accumulates no grad if it's used
+        assert not f_y.grad[1:].nonzero().any()

sources/neuraloperator/neuralop/layers/tests/test_grid_embeddings.py

@@ -0,0 +1,42 @@
+import random
+
+import torch
+from torch.testing import assert_close
+import pytest
+
+from ..embeddings import GridEmbedding2D, GridEmbeddingND
+
+# Testing grid-based pos encoding: choose a random grid
+# point and assert the proper encoding is applied there
+
+
+def test_GridEmbedding2D():
+    grid_boundaries = [[0, 1], [0, 1]]
+    pos_embed = GridEmbedding2D(in_channels=1, grid_boundaries=grid_boundaries)
+
+    input_res = (20, 20)
+    x = torch.randn(1, 1, *input_res)
+    x = pos_embed(x)
+
+    index = [random.randint(0, res-1) for res in input_res]
+    true_coords = x[0,1:,index[0], index[1]].squeeze() # grab pos encoding channels at coord index
+    expected_coords = torch.tensor([i/j for i,j in zip(index,input_res)])
+    assert_close(true_coords, expected_coords)
+
+
+@pytest.mark.parametrize("dim", [1, 2, 3, 4])
+def test_GridEmbeddingND(dim):
+    grid_boundaries = [[0, 1]] * dim
+    pos_embed = GridEmbeddingND(in_channels=1, dim=dim, grid_boundaries=grid_boundaries)
+
+    input_res = [20] * dim
+    x = torch.randn(1, 1, *input_res)
+    x = pos_embed(x)
+
+    index = [random.randint(0, res - 1) for res in input_res]
+    # grab pos encoding channels at coord index
+    pos_channels = x[0, 1:, ...]
+    indices = (slice(None), *index)
+    true_coords = pos_channels[indices]
+    expected_coords = torch.tensor([i / j for i, j in zip(index, input_res)])
+    assert_close(true_coords, expected_coords)

sources/neuraloperator/neuralop/layers/tests/test_legacy_spectral_convolution.py

@@ -0,0 +1,228 @@
+import pytest
+import torch
+from tltorch import FactorizedTensor
+from ..legacy_spectral_convolution import (
+    SpectralConv3d,
+    SpectralConv2d,
+    SpectralConv1d,
+    SpectralConv,
+)
+
+
+@pytest.mark.parametrize(
+    "factorization", ["ComplexDense", "ComplexCP", "ComplexTucker", "ComplexTT"]
+)
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+def test_SpectralConv(factorization, implementation):
+    """Test for SpectralConv of any order
+
+    Compares Factorized and Dense convolution output
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+
+    Checks the output size
+
+    Verifies that dynamically changing the number of Fourier modes doesn't break the conv
+    """
+    modes = (10, 8, 6, 6)
+    incremental_modes = (6, 6, 4, 4)
+
+    # Test for Conv1D to Conv4D
+    for dim in [1, 2, 3, 4]:
+        conv = SpectralConv(
+            3,
+            3,
+            modes[:dim],
+            n_layers=1,
+            bias=False,
+            implementation=implementation,
+            factorization=factorization,
+        )
+
+        conv_dense = SpectralConv(
+            3,
+            3,
+            modes[:dim],
+            n_layers=1,
+            bias=False,
+            implementation="reconstructed",
+            factorization=None,
+        )
+
+        for i in range(2 ** (dim - 1)):
+            conv_dense.weight[i] = FactorizedTensor.from_tensor(
+                conv.weight[i].to_tensor(), rank=None, factorization="ComplexDense"
+            )
+
+        x = torch.randn(2, 3, *(12,) * dim)
+
+        res_dense = conv_dense(x)
+        res = conv(x)
+        res_shape = res.shape
+
+        torch.testing.assert_close(res_dense, res)
+
+        # Dynamically reduce the number of modes in Fourier space
+        conv.incremental_n_modes = incremental_modes[:dim]
+        res = conv(x)
+        assert res_shape == res.shape
+
+        # Downsample outputs
+        block = SpectralConv(3, 4, modes[:dim], n_layers=1, resolution_scaling_factor=0.5)
+    
+        x = torch.randn(2, 3, *(12, )*dim)
+        res = block(x)
+        assert list(res.shape[2:]) == [12 // 2] * dim
+
+        # Upsample outputs
+        block = SpectralConv(3, 4, modes[:dim], n_layers=1, resolution_scaling_factor=2)
+
+        x = torch.randn(2, 3, *(12,) * dim)
+        res = block(x)
+        assert res.shape[1] == 4  # Check out channels
+        assert list(res.shape[2:]) == [12 * 2] * dim
+
+
+def test_SpectralConv_resolution_scaling_factor():
+    """Test SpectralConv with upsampled or downsampled outputs"""
+    modes = (4, 4, 4, 4)
+    size = [6] * 4
+    for dim in [1, 2, 3, 4]:
+        # Downsample outputs
+        conv = SpectralConv(
+            3, 3, modes[:dim], n_layers=1, resolution_scaling_factor=0.5
+        )
+
+        x = torch.randn(2, 3, *size[:dim])
+        res = conv(x)
+        assert list(res.shape[2:]) == [m // 2 for m in size[:dim]]
+
+        # Upsample outputs
+        conv = SpectralConv(3, 3, modes[:dim], n_layers=1, resolution_scaling_factor=2)
+
+        x = torch.randn(2, 3, *size[:dim])
+        res = conv(x)
+        assert list(res.shape[2:]) == [m * 2 for m in size[:dim]]
+
+
+@pytest.mark.parametrize("factorization", ["ComplexCP", "ComplexTucker"])
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+def test_SpectralConv3D(factorization, implementation):
+    """Compare generic SpectralConv with hand written SpectralConv2D
+
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+    Note that this implies the order in which the conv is done in the manual implementation matches the automatic one,
+    take with a grain of salt
+    """
+    conv = SpectralConv(
+        3,
+        6,
+        (4, 5, 2),
+        n_layers=1,
+        bias=False,
+        implementation=implementation,
+        factorization=factorization,
+    )
+
+    conv_dense = SpectralConv3d(
+        3,
+        6,
+        (4, 5, 2),
+        n_layers=1,
+        bias=False,
+        implementation="reconstructed",
+        factorization=None,
+    )
+    for i, w in enumerate(conv.weight):
+        rec = w.to_tensor()
+        dtype = rec.dtype
+        assert dtype == torch.cfloat
+        conv_dense.weight[i] = FactorizedTensor.from_tensor(
+            rec, rank=None, factorization="ComplexDense"
+        )
+
+    x = torch.randn(2, 3, 12, 12, 12)
+    res_dense = conv_dense(x)
+    res = conv(x)
+    torch.testing.assert_close(res_dense, res)
+
+
+@pytest.mark.parametrize("factorization", ["ComplexCP", "ComplexTucker"])
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+def test_SpectralConv2D(factorization, implementation):
+    """Compare generic SpectralConv with hand written SpectralConv2D
+
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+    Note that this implies the order in which the conv is done in the manual implementation matches the automatic one,
+    take with a grain of salt
+    """
+    conv = SpectralConv(
+        10,
+        11,
+        (4, 5),
+        n_layers=1,
+        bias=False,
+        implementation=implementation,
+        factorization=factorization,
+    )
+
+    conv_dense = SpectralConv2d(
+        10,
+        11,
+        (4, 5),
+        n_layers=1,
+        bias=False,
+        implementation="reconstructed",
+        factorization=None,
+    )
+    for i, w in enumerate(conv.weight):
+        rec = w.to_tensor()
+        dtype = rec.dtype
+        assert dtype == torch.cfloat
+        conv_dense.weight[i] = FactorizedTensor.from_tensor(
+            rec, rank=None, factorization="ComplexDense"
+        )
+
+    x = torch.randn(2, 10, 12, 12)
+    res_dense = conv_dense(x)
+    res = conv(x)
+    torch.testing.assert_close(res_dense, res)
+
+
+@pytest.mark.parametrize("factorization", ["ComplexCP", "ComplexTucker"])
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+def test_SpectralConv1D(factorization, implementation):
+    """Test for SpectralConv1D
+
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+    """
+    conv = SpectralConv(
+        10,
+        11,
+        (5,),
+        n_layers=1,
+        bias=False,
+        implementation=implementation,
+        factorization=factorization,
+    )
+
+    conv_dense = SpectralConv1d(
+        10,
+        11,
+        (5,),
+        n_layers=1,
+        bias=False,
+        implementation="reconstructed",
+        factorization=None,
+    )
+    for i, w in enumerate(conv.weight):
+        rec = w.to_tensor()
+        dtype = rec.dtype
+        assert dtype == torch.cfloat
+        conv_dense.weight[i] = FactorizedTensor.from_tensor(
+            rec, rank=None, factorization="ComplexDense"
+        )
+
+    x = torch.randn(2, 10, 12)
+    res_dense = conv_dense(x)
+    res = conv(x)
+    torch.testing.assert_close(res_dense, res)

sources/neuraloperator/neuralop/layers/tests/test_local_no_block.py

@@ -0,0 +1,194 @@
+import pytest
+import torch
+
+try:
+    import torch_harmonics
+except ModuleNotFoundError:
+    pytest.skip(
+        "Skipping because torch_harmonics is not installed", allow_module_level=True
+    )
+
+from ..local_no_block import LocalNOBlocks
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+def test_LocalNOBlock_resolution_scaling_factor(n_dim):
+    """Test LocalNOBlocks with upsampled or downsampled outputs"""
+    max_n_modes = [8, 8, 8]
+    n_modes = [4, 4, 4]
+
+    size = [10] * 3
+    channel_mlp_dropout = 0
+    channel_mlp_expansion = 0.5
+    channel_mlp_skip = "linear"
+    block = LocalNOBlocks(
+        3,
+        4,
+        default_in_shape=tuple(size[:n_dim]),
+        n_modes=max_n_modes[:n_dim],
+        max_n_modes=max_n_modes[:n_dim],
+        n_layers=1,
+        diff_layers=[True],
+        disco_layers=[(n_dim == 2)],
+    )
+
+    assert block.convs[0].n_modes[:-1] == max_n_modes[: n_dim - 1]
+    assert block.convs[0].n_modes[-1] == max_n_modes[n_dim - 1] // 2 + 1
+
+    block.n_modes = n_modes[:n_dim]
+    assert block.convs[0].n_modes[:-1] == n_modes[: n_dim - 1]
+    assert block.convs[0].n_modes[-1] == n_modes[n_dim - 1] // 2 + 1
+
+    block.n_modes = max_n_modes[:n_dim]
+    assert block.convs[0].n_modes[:-1] == max_n_modes[: n_dim - 1]
+    assert block.convs[0].n_modes[-1] == max_n_modes[n_dim - 1] // 2 + 1
+
+    # Downsample outputs
+    block = LocalNOBlocks(
+        3,
+        4,
+        n_modes[:n_dim],
+        default_in_shape=tuple(size[:n_dim]),
+        n_layers=1,
+        diff_layers=[True],
+        disco_layers=[(n_dim == 2)],
+        resolution_scaling_factor=0.5,
+        use_channel_mlp=True,
+        channel_mlp_dropout=channel_mlp_dropout,
+        channel_mlp_expansion=channel_mlp_expansion,
+        channel_mlp_skip=channel_mlp_skip,
+    )
+
+    x = torch.randn(2, 3, *size[:n_dim])
+    res = block(x)
+    assert list(res.shape[2:]) == [m // 2 for m in size[:n_dim]]
+
+    # Upsample outputs
+    block = LocalNOBlocks(
+        3,
+        4,
+        n_modes[:n_dim],
+        default_in_shape=tuple(size[:n_dim]),
+        n_layers=1,
+        diff_layers=[True],
+        disco_layers=[(n_dim == 2)],
+        resolution_scaling_factor=2,
+        use_channel_mlp=True,
+        channel_mlp_dropout=channel_mlp_dropout,
+        channel_mlp_expansion=channel_mlp_expansion,
+        channel_mlp_skip=channel_mlp_skip,
+    )
+
+    x = torch.randn(2, 3, *size[:n_dim])
+    res = block(x)
+    assert res.shape[1] == 4  # Check out channels
+    assert list(res.shape[2:]) == [m * 2 for m in size[:n_dim]]
+
+
+@pytest.mark.parametrize("norm", ["instance_norm", "ada_in", "group_norm"])
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+def test_LocalNOBlock_norm(norm, n_dim):
+    """Test LocalNOBlock with normalization"""
+    modes = (8, 8, 8)
+    size = [10] * 3
+    channel_mlp_dropout = 0
+    channel_mlp_expansion = 0.5
+    channel_mlp_skip = "linear"
+    ada_in_features = 4
+    block = LocalNOBlocks(
+        3,
+        4,
+        modes[:n_dim],
+        default_in_shape=tuple(size[:n_dim]),
+        n_layers=1,
+        diff_layers=[True],
+        disco_layers=[(n_dim == 2)],
+        use_channel_mlp=True,
+        norm=norm,
+        ada_in_features=ada_in_features,
+        channel_mlp_dropout=channel_mlp_dropout,
+        channel_mlp_expansion=channel_mlp_expansion,
+        channel_mlp_skip=channel_mlp_skip,
+    )
+
+    if norm == "ada_in":
+        embedding = torch.randn(ada_in_features)
+        block.set_ada_in_embeddings(embedding)
+
+    x = torch.randn(2, 3, *size[:n_dim])
+    res = block(x)
+    assert list(res.shape[2:]) == size[:n_dim]
+
+
+@pytest.mark.parametrize("local_no_skip", ["linear", None])
+@pytest.mark.parametrize("channel_mlp_skip", ["linear", None])
+def test_LocalNOBlock_skip_connections(local_no_skip, channel_mlp_skip):
+    """Test LocalNOBlocks with different skip connection options including None"""
+    modes = (8, 8, 8)
+    size = [10, 10, 10]
+
+    # Test with channel MLP enabled
+    block = LocalNOBlocks(
+        3,
+        4,
+        modes,
+        default_in_shape=tuple(size),
+        n_layers=2,
+        local_no_skip=local_no_skip,
+        channel_mlp_skip=channel_mlp_skip,
+        use_channel_mlp=True,
+        channel_mlp_expansion=0.5,
+        channel_mlp_dropout=0.0,
+        diff_layers=[True, True],
+        disco_layers=[False, False],
+    )
+
+    x = torch.randn(2, 3, *size)
+    res = block(x)
+
+    # Check output shape
+    assert res.shape == (2, 4, *size)
+
+    # Test with channel MLP disabled
+    block_no_mlp = LocalNOBlocks(
+        3,
+        4,
+        modes,
+        default_in_shape=tuple(size),
+        n_layers=2,
+        local_no_skip=local_no_skip,
+        channel_mlp_skip=channel_mlp_skip,
+        use_channel_mlp=False,
+        diff_layers=[True, True],
+        disco_layers=[False, False],
+    )
+
+    res_no_mlp = block_no_mlp(x)
+    assert res_no_mlp.shape == (2, 4, *size)
+
+
+@pytest.mark.parametrize("norm_groups", [1, 2, 4, 8])
+def test_LocalNOBlock_group_norm(norm_groups):
+    """Test LocalNOBlocks with group_norm and custom norm_groups"""
+    modes = (8, 8)
+    hidden_channels = 16
+    n_layers = 1
+    size = [12] * 2
+
+    block = LocalNOBlocks(
+        in_channels=hidden_channels,
+        out_channels=hidden_channels,
+        n_modes=modes,
+        default_in_shape=tuple(size),
+        n_layers=n_layers,
+        norm="group_norm",
+        norm_groups=norm_groups,
+        diff_layers=[True],
+        disco_layers=[False],
+    )
+
+    assert block.norm is not None
+    for norm_layer in block.norm:
+        assert isinstance(norm_layer, torch.nn.GroupNorm)
+        assert norm_layer.num_groups == norm_groups
+        assert norm_layer.num_channels == hidden_channels

sources/neuraloperator/neuralop/layers/tests/test_neighbor_search.py

@@ -0,0 +1,55 @@
+"""
+Tests fallback neighbor search on a small 2d grid
+that was calculated manually
+"""
+
+import numpy as np
+import torch
+import pytest
+
+from ..neighbor_search import native_neighbor_search
+
+# Manually-calculated CSR list of neighbors
+# in a 5x5 grid on [0,1] X [0,1] for radius=0.3
+
+indices = [0, 1, 5, 0, 1, 2, 6, 1, 2, 3, 7, 2, 3, 4, 8,
+           3, 4, 9, 0, 5, 6, 10, 1, 5, 6, 7, 11, 2, 6, 7,
+           8, 12, 3, 7, 8, 9, 13, 4, 8, 9, 14, 5, 10, 11,
+           15, 6, 10, 11, 12, 16, 7, 11, 12, 13, 17, 8, 12,
+           13, 14, 18, 9, 13, 14, 19, 10, 15, 16, 20, 11, 15,
+           16, 17, 21, 12, 16, 17, 18, 22, 13, 17, 18, 19, 23,
+           14, 18, 19, 24, 15, 20, 21, 16, 20, 21, 22, 17, 21,
+           22, 23, 18, 22, 23, 24, 19, 23, 24]
+
+splits = [0, 3, 7, 11, 15, 18, 22, 27, 32, 37, 41, 45, 50,
+          55, 60, 64, 68, 73, 78, 83, 87, 90, 94, 98, 102, 105]
+
+def test_fallback_nb_search():
+    mesh_grid = np.stack(
+        np.meshgrid(*[np.linspace(0, 1, 5) for _ in range(2)], indexing="ij"), axis=-1
+    )
+    coords = torch.Tensor(
+        mesh_grid.reshape(-1, 2)
+    )  # reshape into n**d x d coord points
+    return_dict = native_neighbor_search(
+        data=coords, queries=coords, radius=0.3, return_norm=True
+    )
+
+    assert return_dict["neighbors_index"].tolist() == indices
+    assert return_dict["neighbors_row_splits"].tolist() == splits
+    print(f"{return_dict['weights']=}")
+
+    def compute_norm_separate(nbrs, data, queries):
+        return_dict = nbrs
+        num_reps = (
+            return_dict["neighbors_row_splits"][1:]
+            - return_dict["neighbors_row_splits"][:-1]
+        )
+        rep_queries = torch.repeat_interleave(queries, num_reps, dim=0)
+        rep_data = data[return_dict["neighbors_index"]]
+        rep_dist = rep_queries - rep_data
+        return_dict["squared_norm"] = (rep_dist**2).sum(dim=-1)
+        return return_dict
+
+    return_dict = compute_norm_separate(return_dict, coords, coords)
+    print(return_dict["squared_norm"])

sources/neuraloperator/neuralop/layers/tests/test_padding.py

@@ -0,0 +1,17 @@
+import torch
+from ..padding import DomainPadding
+import pytest
+
+
+def test_DomainPadding():
+    data = torch.randn((2, 3, 10, 10))
+    padder = DomainPadding(0.2)
+    padded = padder.pad(data)
+
+    # With 0.2 padding and symmetric mode, output size should be 14
+    target_shape = list(padded.shape)
+    target_shape[-1] = target_shape[-2] = 14
+    assert list(padded.shape) == target_shape
+
+    unpadded = padder.unpad(padded)
+    assert unpadded.shape == data.shape

sources/neuraloperator/neuralop/layers/tests/test_resample.py

@@ -0,0 +1,24 @@
+from ..resample import resample
+import torch
+
+
+def test_resample():
+    a = torch.randn(10, 20, 40, 50)
+
+    res_scale = [2, 3]
+    axis = [-2, -1]
+
+    b = resample(a, res_scale, axis)
+    assert b.shape[-1] == 3 * a.shape[-1] and b.shape[-2] == 2 * a.shape[-2]
+
+    a = torch.randn((10, 20, 40, 50, 60))
+
+    res_scale = [0.5, 3, 4]
+    axis = [-3, -2, -1]
+    b = resample(a, res_scale, axis)
+
+    assert (
+        b.shape[-1] == 4 * a.shape[-1]
+        and b.shape[-2] == 3 * a.shape[-2]
+        and b.shape[-3] == int(0.5 * a.shape[-3])
+    )

sources/neuraloperator/neuralop/layers/tests/test_rno_block.py

@@ -0,0 +1,252 @@
+import pytest
+import torch
+from ..rno_block import RNOBlock
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_basic(n_dim, complex_data):
+    """Test RNOBlock with basic functionality"""
+    modes = (8, 8, 8)
+    width = 16
+    size = [12] * n_dim
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes[:n_dim],
+        hidden_channels=width,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    # Test forward pass
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+    # Test with custom hidden state
+    h_init = torch.randn(batch_size, width, *size, dtype=dtype)
+    out_custom = layer(x, h_init)
+    assert out_custom.shape == (batch_size, width, *size)
+    assert out_custom.dtype == dtype
+
+
+@pytest.mark.parametrize("return_sequences", [False, True])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_return_sequences(return_sequences, complex_data):
+    """Test RNOBlock with return_sequences option"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        return_sequences=return_sequences,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+
+    if return_sequences:
+        assert out.shape == (batch_size, num_timesteps, width, *size)
+    else:
+        assert out.shape == (batch_size, width, *size)
+
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("n_dim", [1, 2, 3])
+@pytest.mark.parametrize("complex_data", [False])  # Skip complex for resolution scaling (interpolation not supported)
+def test_RNOBlock_resolution_scaling(n_dim, complex_data):
+    """Test RNOBlock with resolution scaling"""
+    modes = (8, 8, 8)
+    width = 16
+    size = [12] * n_dim
+    batch_size = 2
+    num_timesteps = 3
+
+    # Test upsampling
+    layer_up = RNOBlock(
+        n_modes=modes[:n_dim],
+        hidden_channels=width,
+        resolution_scaling_factor=2.0,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out_up = layer_up(x)
+    expected_size_up = tuple(s * 2 for s in size)
+    assert out_up.shape == (batch_size, width, *expected_size_up)
+    assert out_up.dtype == dtype
+
+    # Test downsampling
+    layer_down = RNOBlock(
+        n_modes=modes[:n_dim],
+        hidden_channels=width,
+        resolution_scaling_factor=0.5,
+        complex_data=complex_data,
+    )
+
+    out_down = layer_down(x)
+    expected_size_down = tuple(s // 2 for s in size)
+    assert out_down.shape == (batch_size, width, *expected_size_down)
+    assert out_down.dtype == dtype
+
+
+@pytest.mark.parametrize("norm", [None, "group_norm", "instance_norm"])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_norm(norm, complex_data):
+    """Test RNOBlock with different normalization options"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        norm=norm,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("stabilizer", [None, "tanh"])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_stabilizer(stabilizer, complex_data):
+    """Test RNOBlock with stabilizer options"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        stabilizer=stabilizer,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("separable", [False, True])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_separable(separable, complex_data):
+    """Test RNOBlock with separable convolutions"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        separable=separable,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("preactivation", [False, True])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_preactivation(preactivation, complex_data):
+    """Test RNOBlock with preactivation"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        preactivation=preactivation,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("factorization", [None, "Tucker"])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_RNOBlock_factorization(factorization, complex_data):
+    """Test RNOBlock with factorization"""
+    modes = (8, 8)
+    width = 16
+    size = [12, 12]
+    batch_size = 2
+    num_timesteps = 3
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=width,
+        factorization=factorization,
+        rank=0.5 if factorization else 1.0,
+        complex_data=complex_data,
+    )
+
+    dtype = torch.cfloat if complex_data else torch.float32
+    x = torch.randn(batch_size, num_timesteps, width, *size, dtype=dtype)
+
+    out = layer(x)
+    assert out.shape == (batch_size, width, *size)
+    assert out.dtype == dtype
+
+
+@pytest.mark.parametrize("norm_groups", [1, 2, 4, 8])
+def test_RNOBlock_group_norm(norm_groups):
+    """Test RNOBlock with group_norm and custom norm_groups"""
+    modes = (8, 8)
+    hidden_channels = 16
+
+    layer = RNOBlock(
+        n_modes=modes,
+        hidden_channels=hidden_channels,
+        norm="group_norm",
+        norm_groups=norm_groups,
+    )
+
+    # RNOBlock contains an RNOCell which contains 6 FNOBlocks (3 input + 3 hidden gates)
+    for fno_block in [*layer.cell.input_gates, *layer.cell.hidden_gates]:
+        assert fno_block.norm is not None
+        for norm_layer in fno_block.norm:
+            assert isinstance(norm_layer, torch.nn.GroupNorm)
+            assert norm_layer.num_groups == norm_groups
+            assert norm_layer.num_channels == hidden_channels

sources/neuraloperator/neuralop/layers/tests/test_segment_csr.py

@@ -0,0 +1,46 @@
+import torch
+from ..segment_csr import segment_csr
+
+import pytest
+
+
+@pytest.mark.parametrize("batch_size", [1, 4])
+def test_native_segcsr_shapes(batch_size):
+    n_pts = 25
+    n_channels = 5
+    max_nbrhd_size = 7  # prevent degenerate cases in testing
+
+    # tensor to reduce
+    src = torch.randn((batch_size, n_pts, n_channels))
+
+    # randomly generate index pointer tensor for CSR format
+    nbrhd_sizes = [torch.tensor([0])]
+    while sum(nbrhd_sizes) < n_pts:
+        nbrhd_sizes.append(torch.randint(0, max_nbrhd_size + 1, size=(1,)))
+        max_nbrhd_size = min(max_nbrhd_size, n_pts - sum(nbrhd_sizes))
+    indptr = torch.cumsum(torch.tensor(nbrhd_sizes, dtype=torch.long), dim=0)
+    if batch_size > 1:
+        indptr = indptr.repeat([batch_size] + [1] * indptr.ndim)
+    else:
+        src = src.squeeze(0)
+    out = segment_csr(src, indptr, reduction="sum", use_scatter=False)
+
+    if batch_size == 1:
+        assert out.shape == (len(indptr) - 1, n_channels)
+    else:
+        assert out.shape == (batch_size, indptr.shape[1] - 1, n_channels)
+
+
+def test_native_segcsr_reductions():
+    src = torch.ones([10, 3])
+    indptr = torch.tensor([0, 3, 8, 10], dtype=torch.long)
+
+    out_sum = segment_csr(src, indptr, reduction="sum", use_scatter=False)
+    assert out_sum.shape == (3, 3)
+    diff = out_sum - torch.tensor([[3, 5, 2]]).T * torch.ones([3, 3])
+    assert not diff.nonzero().any()
+
+    out_mean = segment_csr(src, indptr, reduction="mean", use_scatter=False)
+    assert out_mean.shape == (3, 3)
+    diff = out_mean - torch.ones([3, 3])
+    assert not diff.nonzero().any()

sources/neuraloperator/neuralop/layers/tests/test_sin_embeddings.py

@@ -0,0 +1,110 @@
+import math
+
+import torch
+from torch.testing import assert_close
+import pytest
+
+from ..embeddings import SinusoidalEmbedding
+
+# Testing NeRF Embedding: start with a simple range
+# and see that it is embedded properly
+
+batch_size = 4
+num_freqs = 3
+in_channels = 3
+n_in = 2
+max_pos = 10000
+
+if torch.backends.cuda.is_built():
+    device = "cuda"
+else:
+    device = "cpu"
+
+
+def test_NeRFEmbedding():
+    nerf_embed = SinusoidalEmbedding(
+        in_channels=in_channels, num_frequencies=3, embedding_type="nerf"
+    )
+    unbatched_inputs = torch.arange(in_channels) * torch.tensor([[1.0], [0.5]])
+    embeds = nerf_embed(unbatched_inputs.to(device))
+
+    true_outputs = torch.zeros(n_in, in_channels * num_freqs * 2).to(device)
+
+    # True values are (sin(2^0 * pi * p), cos(2^0 * pi * p), ... cos(2^(L-1) * pi * p))
+    for channel in range(in_channels):
+        for wavenumber in range(num_freqs):
+            for i in range(2):
+                idx = channel * (num_freqs * 2) + wavenumber * 2 + i
+                freqs = 2**wavenumber * math.pi * unbatched_inputs[:, channel]
+                if i == 0:
+                    true_outputs[:, idx] = freqs.sin()
+                else:
+                    true_outputs[:, idx] = freqs.cos()
+    assert_close(embeds, true_outputs)
+
+    batched_inputs = torch.stack(
+        [torch.arange(in_channels) * torch.tensor([[1.0], [0.5]])] * batch_size
+    )
+    embeds = nerf_embed(batched_inputs.to(device))
+
+    true_outputs = torch.zeros(batch_size, n_in, in_channels * num_freqs * 2).to(device)
+
+    # True values are (sin(2^0 * pi * p), cos(2^0 * pi * p), ... cos(2^(L-1) * pi * p))
+    for channel in range(in_channels):
+        for wavenumber in range(num_freqs):
+            for i in range(2):
+                idx = channel * (num_freqs * 2) + wavenumber * 2 + i
+                freqs = 2**wavenumber * math.pi * batched_inputs[:, :, channel]
+                if i == 0:
+                    true_outputs[:, :, idx] = freqs.sin()
+                else:
+                    true_outputs[:, :, idx] = freqs.cos()
+    assert_close(embeds, true_outputs)
+
+
+def test_TransformerEmbedding():
+    sin_embed = SinusoidalEmbedding(
+        in_channels=in_channels,
+        num_frequencies=3,
+        embedding_type="transformer",
+        max_positions=max_pos,
+    )
+    unbatched_inputs = torch.arange(in_channels) * torch.tensor([[1.0], [0.5]])
+    embeds = sin_embed(unbatched_inputs.to(device))
+
+    true_outputs = torch.zeros(n_in, in_channels * num_freqs * 2).to(device)
+
+    # True values are (sin(2^0 * pi * p), cos(2^0 * pi * p), ... cos(2^(L-1) * pi * p))
+    for channel in range(in_channels):
+        for wavenumber in range(num_freqs):
+            for i in range(2):
+                idx = channel * (num_freqs * 2) + wavenumber * 2 + i
+                freqs = (
+                    (1 / max_pos) ** (wavenumber / sin_embed.num_frequencies * 2)
+                ) * unbatched_inputs[:, channel]
+                if i == 0:
+                    true_outputs[:, idx] = freqs.sin()
+                else:
+                    true_outputs[:, idx] = freqs.cos()
+    assert_close(embeds, true_outputs)
+
+    batched_inputs = torch.stack(
+        [torch.arange(in_channels) * torch.tensor([[1.0], [0.5]])] * batch_size
+    )
+    embeds = sin_embed(batched_inputs.to(device))
+
+    true_outputs = torch.zeros(batch_size, n_in, in_channels * num_freqs * 2).to(device)
+
+    # True values are (sin(2^0 * pi * p), cos(2^0 * pi * p), ... cos(2^(L-1) * pi * p))
+    for channel in range(in_channels):
+        for wavenumber in range(num_freqs):
+            for i in range(2):
+                idx = channel * (num_freqs * 2) + wavenumber * 2 + i
+                freqs = (
+                    (1 / max_pos) ** (wavenumber / sin_embed.num_frequencies * 2)
+                ) * batched_inputs[:, :, channel]
+                if i == 0:
+                    true_outputs[:, :, idx] = freqs.sin()
+                else:
+                    true_outputs[:, :, idx] = freqs.cos()
+    assert_close(embeds, true_outputs)

sources/neuraloperator/neuralop/layers/tests/test_spectral_convolution.py

@@ -0,0 +1,115 @@
+import pytest
+import torch
+from tltorch import FactorizedTensor
+from ..spectral_convolution import SpectralConv
+
+
+@pytest.mark.parametrize("factorization", ["Dense", "CP", "Tucker", "TT"])
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+@pytest.mark.parametrize("separable", [False, True])
+@pytest.mark.parametrize("dim", [1, 2, 3, 4])
+@pytest.mark.parametrize("complex_data", [False, True])
+def test_SpectralConv(factorization, implementation, separable, dim, complex_data):
+    """Test for SpectralConv of any order
+
+    Compares Factorized and Dense convolution output
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+
+    Checks the output size
+
+    Verifies that dynamically changing the number of Fourier modes doesn't break the conv
+    """
+    modes = (10, 8, 6, 6)
+    incremental_modes = (6, 6, 4, 4)
+    dtype = torch.cfloat if complex_data else torch.float32
+
+    # Test for Conv1D to Conv4D
+    conv = SpectralConv(
+        3,
+        3,
+        modes[:dim],
+        bias=False,
+        implementation=implementation,
+        factorization=factorization,
+        complex_data=complex_data,
+        separable=separable,
+    )
+
+    conv_dense = SpectralConv(
+        3,
+        3,
+        modes[:dim],
+        bias=False,
+        implementation="reconstructed",
+        factorization=None,
+        complex_data=complex_data,
+    )
+
+    x = torch.randn(2, 3, *(12,) * dim, dtype=dtype)
+
+    assert torch.is_complex(conv.weight)
+    assert torch.is_complex(conv_dense.weight)
+
+    # this closeness test only works if the weights in full form have the same shape
+    if not separable:
+        conv_dense.weight = FactorizedTensor.from_tensor(
+            conv.weight.to_tensor(), rank=None, factorization="ComplexDense"
+        )
+
+    res_dense = conv_dense(x)
+    res = conv(x)
+    res_shape = res.shape
+
+    # this closeness test only works if the weights in full form have the same shape
+    if not separable:
+        torch.testing.assert_close(res_dense, res)
+
+    # Dynamically reduce the number of modes in Fourier space
+    conv.n_modes = incremental_modes[:dim]
+    res = conv(x)
+    assert res_shape == res.shape
+
+    # Downsample outputs
+    block = SpectralConv(3, 4, modes[:dim], resolution_scaling_factor=0.5)
+
+    x = torch.randn(2, 3, *(12,) * dim)
+    res = block(x)
+    assert list(res.shape[2:]) == [12 // 2] * dim
+
+    # Upsample outputs
+    block = SpectralConv(3, 4, modes[:dim], resolution_scaling_factor=2)
+
+    x = torch.randn(2, 3, *(12,) * dim)
+    res = block(x)
+    assert res.shape[1] == 4  # Check out channels
+    assert list(res.shape[2:]) == [12 * 2] * dim
+
+
+@pytest.mark.parametrize("enforce_hermitian_symmetry", [True, False])
+@pytest.mark.parametrize("dim", [1, 2, 3])
+@pytest.mark.parametrize("spatial_size", [8, 9])  # Even and odd: Nyquist handling differs
+@pytest.mark.parametrize("resolution_scaling_factor", [None, 0.5, 2])
+@pytest.mark.parametrize("modes", [(4, 4, 4), (4, 5, 7)])
+def test_SpectralConv2(enforce_hermitian_symmetry, dim, spatial_size, modes, resolution_scaling_factor):
+    modes = modes[:dim]
+    size = [spatial_size] * dim
+    if resolution_scaling_factor is None:
+        out_size = size
+    else:
+        out_size = [round(s * resolution_scaling_factor) for s in size]
+
+    # Test with real-valued data
+    conv = SpectralConv(
+        3,
+        4,
+        modes,
+        enforce_hermitian_symmetry=enforce_hermitian_symmetry,
+        complex_data=False,
+        resolution_scaling_factor=resolution_scaling_factor,
+    )
+    x = torch.randn(2, 3, *size, dtype=torch.float32)
+    res = conv(x)
+
+    assert res.shape == (2, 4, *out_size)
+    assert res.dtype == torch.float32
+    assert not torch.is_complex(res)

sources/neuraloperator/neuralop/layers/tests/test_spectral_projection.py

@@ -0,0 +1,36 @@
+import torch
+import pytest
+import numpy as np
+from ..spectral_projection import spectral_projection_divergence_free
+
+@pytest.mark.parametrize("resolution", [(64, 64), (80, 60), (60, 80)])
+@pytest.mark.parametrize("constraint_modes", [(64, 64), (50, 64), (72, 60)])
+@pytest.mark.parametrize("dtype", [torch.float32, torch.float64])
+def test_spectral_projection(resolution, constraint_modes, dtype):
+    """Test spectral projection functionality with different resolutions, constraint modes and dtypes."""
+    
+    height, width = resolution
+    batch_size = 3
+    domain_size = 2 * np.pi
+    
+    # Create a simple velocity field with some divergence
+    x = torch.linspace(0, domain_size, width)
+    y = torch.linspace(0, domain_size, height)
+    X, Y = torch.meshgrid(x, y, indexing='ij')
+    
+    # Example u_x = sin(y), u_y = cos(x)
+    u_x = torch.sin(Y.T).unsqueeze(0).unsqueeze(0).expand(batch_size, 1, height, width)
+    u_y = torch.cos(X.T).unsqueeze(0).unsqueeze(0).expand(batch_size, 1, height, width)
+    u = torch.cat([u_x, u_y], dim=1).to(dtype)
+    
+    # Apply spectral projection
+    u_projected = spectral_projection_divergence_free(u, domain_size, constraint_modes)
+    
+    # Check output shape and properties
+    assert u_projected.shape == u.shape
+    assert u_projected.dtype == dtype
+    assert u_projected.device == u.device
+    
+    # Check no NaN or inf values
+    assert not torch.isnan(u_projected).any()
+    assert not torch.isinf(u_projected).any()

sources/neuraloperator/neuralop/layers/tests/test_spherical_convolution.py

@@ -0,0 +1,108 @@
+import pytest
+import torch
+from tltorch import FactorizedTensor
+
+try:
+    import torch_harmonics
+except ModuleNotFoundError:
+    pytest.skip(
+        "Skipping because torch_harmonics is not installed", allow_module_level=True
+    )
+
+from ..spherical_convolution import SphericalConv
+from ..spherical_convolution import SHT
+
+
+@pytest.mark.parametrize(
+    "factorization", ["ComplexDense", "ComplexCP", "ComplexTucker", "ComplexTT"]
+)
+@pytest.mark.parametrize("implementation", ["factorized", "reconstructed"])
+def test_SphericalConv(factorization, implementation):
+    """Test for SphericalConv (2D only)
+
+    Compares Factorized and Dense convolution output
+    Verifies that a dense conv and factorized conv with the same weight produce the same output
+
+    Checks the output size
+
+    Verifies that dynamically changing the number of Fourier modes doesn't break the conv
+    """
+    n_modes = (6, 6)
+
+    conv = SphericalConv(
+        3,
+        3,
+        n_modes,
+        bias=False,
+        implementation=implementation,
+        factorization=factorization,
+    )
+
+    conv_dense = SphericalConv(
+        3, 3, n_modes, bias=False, implementation="reconstructed", factorization=None
+    )
+
+    conv_dense.weight = FactorizedTensor.from_tensor(
+        conv.weight.to_tensor(), rank=None, factorization="ComplexDense"
+    )
+    x = torch.randn(2, 3, *(12, 12))
+
+    res_dense = conv_dense(x)
+    res = conv(x)
+
+    torch.testing.assert_close(res_dense, res)
+
+    # Downsample outputs
+    block = SphericalConv(3, 4, n_modes, resolution_scaling_factor=0.5)
+
+    x = torch.randn(2, 3, *(12, 12))
+    res = block(x)
+    assert list(res.shape[2:]) == [12 // 2, 12 // 2]
+
+    # Upsample outputs
+    block = SphericalConv(3, 4, n_modes, resolution_scaling_factor=2)
+
+    x = torch.randn(2, 3, *(12, 12))
+    res = block(x)
+    assert res.shape[1] == 4  # Check out channels
+    assert list(res.shape[2:]) == [12 * 2, 12 * 2]
+
+    # Test change of grid
+    block_0 = SphericalConv(4, 4, n_modes, sht_grids=["equiangular", "legendre-gauss"])
+
+    block_1 = SphericalConv(4, 4, n_modes, sht_grids=["legendre-gauss", "equiangular"])
+
+    x = torch.randn(2, 4, *(12, 12))
+    res = block_0(x)
+    res = block_1(res)
+    assert res.shape[2:] == x.shape[2:]
+
+    res = block_0.transform(x)
+    res = block_1.transform(res)
+    assert res.shape[2:] == x.shape[2:]
+
+
+@pytest.mark.parametrize("grid", ["equiangular", "legendre-gauss"])
+def test_sht(grid):
+    nlat = 16
+    nlon = 2 * nlat
+    batch_size = 2
+    if grid == "equiangular":
+        mmax = nlat // 2
+    else:
+        mmax = nlat
+    lmax = mmax
+    norm = "ortho"
+    dtype = torch.float32
+
+    sht_handle = SHT(dtype=dtype)
+
+    # Create input
+    coeffs = torch.zeros(batch_size, lmax, mmax, dtype=torch.complex64)
+    coeffs[:, :lmax, :mmax] = torch.randn(batch_size, lmax, mmax, dtype=torch.complex64)
+    
+    signal = sht_handle.isht(coeffs, s=(nlat, nlon), grid=grid, norm=norm).to(torch.float32)
+
+    coeffs = sht_handle.sht(signal, s=(lmax, mmax), grid=grid, norm=norm)
+    rec = sht_handle.isht(coeffs, s=(nlat, nlon), grid=grid, norm=norm)
+    torch.testing.assert_close(signal, rec, rtol=1e-4, atol=1e-4)

sources/neuraloperator/neuralop/losses/__init__.py

@@ -0,0 +1,10 @@
+from .data_losses import LpLoss, H1Loss
+from .equation_losses import BurgersEqnLoss, ICLoss
+from .differentiation import FourierDiff, non_uniform_fd, FiniteDiff
+from .meta_losses import (
+    WeightedSumLoss,
+    FieldwiseAggregatorLoss,
+    Aggregator,
+    Relobralo,
+    SoftAdapt,
+)