ml4gw 0.7.5__py3-none-any.whl → 0.7.7__py3-none-any.whl

ml4gw/transforms/spectral.py

@@ -14,39 +14,39 @@ class SpectralDensity(torch.nn.Module):
     of a batch of multichannel timeseries, or the cross spectral
     density of two batches of multichannel timeseries.
 
-    On `SpectralDensity.forward` call, if only one tensor is provided,
+    On ``SpectralDensity.forward`` call, if only one tensor is provided,
     this transform will compute its power spectral density. If a second
     tensor is provided, the cross spectral density between the two
     timeseries will be computed. For information about the allowed
     relationships between these two tensors, see the documentation to
-    `ml4gw.spectral.fast_spectral_density`.
+    :meth:`~ml4gw.spectral.fast_spectral_density`.
 
     Note that the cross spectral density computation is currently
-    only available for the `fast_spectral_density` option. If
-    `fast=False` and a second tensor is passed to `SpectralDensity.forward`,
-    a `NotImplementedError` will be raised.
+    only available for :meth:`~ml4gw.spectral.fast_spectral_density`. If
+    ``fast=False`` and a second tensor is passed to ``SpectralDensity.forward``,  # noqa E501
+    a ``NotImplementedError`` will be raised.
 
     Args:
         sample_rate:
-            Rate at which tensors passed to `forward` will be sampled
+            Rate at which tensors passed to ``forward`` will be sampled
         fftlength:
             Length of the window, in seconds, to use for FFT estimates
         overlap:
             Overlap between windows used for FFT calculation. If left
-            as `None`, this will be set to `fftlength / 2`.
+            as ``None``, this will be set to ``fftlength / 2``.
         average:
             Aggregation method to use for combining windowed FFTs.
-            Allowed values are `"mean"` and `"median"`.
+            Allowed values are ``"mean"`` and ``"median"``.
         window:
             Window array to multiply by each FFT window before
-            FFT computation. Should have length `nperseg`.
+            FFT computation. Should have length ``nperseg``.
             Defaults to a hanning window.
         fast:
             Whether to use a faster spectral density computation that
             support cross spectral density, or a slower one which does
             not. The cost of the fast implementation is that it is not
             exact for the two lowest frequency bins.
-    """
+    """  # noqa E501
 
     def __init__(
         self,

ml4gw/transforms/spectrogram.py

@@ -14,18 +14,18 @@ class MultiResolutionSpectrogram(torch.nn.Module):
     """
     Create a batch of multi-resolution spectrograms
     from a batch of timeseries. Input is expected to
-    have the shape `(B, C, T)`, where `B` is the number
-    of batches, `C` is the number of channels, and `T`
+    have the shape ``(B, C, T)``, where ``B`` is the number
+    of batches, ``C`` is the number of channels, and ``T``
     is the number of time samples.
 
     For each timeseries, calculate multiple normalized
-    spectrograms based on the `Spectrogram` `kwargs` given.
+    spectrograms based on the ``Spectrogram`` ``kwargs`` given.
     Combine the spectrograms by taking the maximum value
     from the nearest time-frequncy bin.
 
     If the largest number of time bins among the spectrograms
-    is `N` and the largest number of frequency bins is `M`,
-    the output will have dimensions `(B, C, M, N)`
+    is ``N`` and the largest number of frequency bins is ``M``,
+    the output will have dimensions ``(B, C, M, N)``
 
     Args:
         kernel_length:
@@ -34,10 +34,11 @@ class MultiResolutionSpectrogram(torch.nn.Module):
             spectrogram
         sample_rate:
             The sample rate of the timeseries in Hz
-        kwargs:
+        **kwargs:
             Arguments passed in kwargs will used to create
-            `torchaudio.transforms.Spectrogram`s. Each
-            argument should be a list of values. Any list
+            ``torchaudio.transforms.Spectrogram`` (see
+            `documentation <https://docs.pytorch.org/audio/main/generated/torchaudio.transforms.Spectrogram.html>`_).
+            Each argument should be a list of values. Any list
             of length greater than 1 should be the same
             length
     """
@@ -140,9 +141,9 @@ class MultiResolutionSpectrogram(torch.nn.Module):
                 Batch of multichannel timeseries which will
                 be used to calculate the multi-resolution
                 spectrogram. Should have the shape
-                `(B, C, T)`, where `B` is the number of
-                batches, `C` is the  number of channels,
-                and `T` is the number of time samples.
+                ``(B, C, T)``, where ``B`` is the number of
+                batches, ``C`` is the  number of channels,
+                and ``T`` is the number of time samples.
         """
         if X.shape[-1] != self.kernel_size:
             raise ValueError(

ml4gw/transforms/spline_interpolation.py

@@ -1,131 +1,29 @@
 """
-Adaptation of code from https://github.com/dottormale/Qtransform
+Adaptation of code from https://github.com/dottormale/Qtransform_torch/
 """
 
 from typing import Optional, Tuple
 
 import torch
-import torch.nn.functional as F
 from torch import Tensor
 
 
-class SplineInterpolate(torch.nn.Module):
+class SplineInterpolateBase(torch.nn.Module):
     """
-    Perform 1D or 2D spline interpolation based on De Boor's method.
-    Supports batched, multi-channel inputs, so acceptable data
-    shapes are `(width)`, `(height, width)`, `(batch, width)`,
-    `(batch, height, width)`, `(batch, channel, width)`, and
-    `(batch, channel, height, width)`.
-
-    During initialization of this Module, both the desired input
-    and output coordinate Tensors can be specified to allow
-    pre-computation of the B-spline basis matrices, though the only
-    mandatory argument is the coordinates of the data along the
-    `width` dimension. If no argument is given for coordinates along
-    the `height` dimension, it is assumed that 1D interpolation is
-    desired.
-
-    Unlike scipy's implementation of spline interpolation, the data
-    to be interpolated is not passed until actually calling the
-    object. This is useful for cases where the input and output
-    coordinates are known in advance, but the data is not, so that
-    the interpolator can be set up ahead of time.
-
-    WARNING: compared to scipy's spline interpolation, this method
-    produces edge artifacts when the output coordinates are near
-    the boundaries of the input coordinates. Therefore, it is
-    recommended to interpolate only to coordinates that are well
-    within the input coordinate range. Unfortunately, the specific
-    definition of "well within" changes based on the size of the
-    data, so some testing may be required to get good results.
-
-    Args:
-        x_in:
-            Coordinates of the width dimension of the data
-        y_in:
-            Coordinates of the height dimension of the data. If not
-            specified, it is assumed the 1D interpolation is desired,
-            and so the default value is a Tensor of length 1
-        kx:
-            Degree of spline interpolation along the width dimension.
-            Default is cubic.
-        ky:
-            Degree of spline interpolation along the height dimension.
-            Default is cubic.
-        sx:
-            Regularization factor to avoid singularities during matrix
-            inversion for interpolation along the width dimension. Not
-            to be confused with the `s` parameter in scipy's spline
-            methods, which controls the number of knots.
-        sy:
-            Regularization factor to avoid singularities during matrix
-            inversion for interpolation along the height dimension.
-        x_out:
-            Coordinates for the data to be interpolated to along the
-            width dimension. If not specified during initialization,
-            this must be specified during the object call.
-        y_out:
-            Coordinates for the data to be interpolated to along the
-            height dimension. If not specified during initialization,
-            this must be specified during the object call.
-
+    Base class for spline interpolation.
     """
 
-    def __init__(
-        self,
-        x_in: Tensor,
-        y_in: Tensor = None,
-        kx: int = 3,
-        ky: int = 3,
-        sx: float = 0.001,
-        sy: float = 0.001,
-        x_out: Optional[Tensor] = None,
-        y_out: Optional[Tensor] = None,
-    ):
-        super().__init__()
-        if y_in is None:
-            y_in = Tensor([1])
-        self.kx = kx
-        self.ky = ky
-        self.sx = sx
-        self.sy = sy
-        self.register_buffer("x_in", x_in)
-        self.register_buffer("y_in", y_in)
-        self.register_buffer("x_out", x_out)
-        self.register_buffer("y_out", y_out)
-
-        tx, Bx, BxT_Bx = self._compute_knots_and_basis_matrices(x_in, kx, sx)
-        self.register_buffer("tx", tx)
-        self.register_buffer("Bx", Bx)
-        self.register_buffer("BxT_Bx", BxT_Bx)
-
-        ty, By, ByT_By = self._compute_knots_and_basis_matrices(y_in, ky, sy)
-        self.register_buffer("ty", ty)
-        self.register_buffer("By", By)
-        self.register_buffer("ByT_By", ByT_By)
-
-        if self.x_out is not None:
-            Bx_out = self.bspline_basis_natural(x_out, kx, self.tx)
-            self.register_buffer("Bx_out", Bx_out)
-        if self.y_out is not None:
-            By_out = self.bspline_basis_natural(y_out, ky, self.ty)
-            self.register_buffer("By_out", By_out)
-
     def _compute_knots_and_basis_matrices(self, x, k, s):
-        knots = self.generate_natural_knots(x, k)
+        knots = self.generate_fitpack_knots(x, k)
         basis_matrix = self.bspline_basis_natural(x, k, knots)
         identity = torch.eye(basis_matrix.shape[-1])
         B_T_B = basis_matrix.T @ basis_matrix + s * identity
         return knots, basis_matrix, B_T_B
 
-    def generate_natural_knots(self, x: Tensor, k: int) -> Tensor:
+    def generate_fitpack_knots(self, x: Tensor, k: int) -> Tensor:
         """
-        Generates a natural knot sequence for B-spline interpolation.
-        Natural knot sequence means that 2*k knots are added to the beginning
-        and end of datapoints as replicas of first and last datapoint
-        respectively in order to enforce natural boundary conditions,
-        i.e. second derivative = 0.
-        The other n nodes are placed in correspondece of the data points.
+        Generates a knot sequence for B-spline interpolation
+        in the same way as the FITPACK algorithm used by SciPy.
 
         Args:
             x: Tensor of data point positions.
@@ -134,7 +32,17 @@ class SplineInterpolate(torch.nn.Module):
         Returns:
             Tensor of knot positions.
         """
-        return F.pad(x[None], (k, k), mode="replicate")[0]
+        num_knots = x.shape[-1] + k + 1
+        knots = torch.zeros(num_knots, dtype=x.dtype)
+        knots[: k + 1] = x[0]
+        knots[-(k + 1) :] = x[-1]
+
+        # Interior knots are the rolling average of the data points
+        # excluding the first and last points
+        windows = x[1:-1].unfold(dimension=-1, size=k, step=1)
+        knots[k + 1 : -k - 1] = windows.mean(dim=-1)
+
+        return knots
 
     def compute_L_R(
         self,
@@ -233,9 +141,6 @@ class SplineInterpolate(torch.nn.Module):
         Returns:
             Tensor containing the kth-order B-spline basis functions
         """
-
-        if len(x) == 1:
-            return torch.eye(1)
         n = x.shape[0]
         m = t.shape[0] - k - 1
 
@@ -255,12 +160,272 @@ class SplineInterpolate(torch.nn.Module):
 
         return b[:, :, -1]
 
-    def bivariate_spline_fit_natural(self, Z):
-        if len(Z.shape) == 3:
-            Z_Bx = torch.matmul(Z, self.Bx)
-            # ((BxT @ Bx)^-1 @ (Z @ Bx)T)T = Z @ BxT^-1
-            return torch.linalg.solve(self.BxT_Bx, Z_Bx.mT).mT
 
+class SplineInterpolate1D(SplineInterpolateBase):
+    """
+    Perform 1D spline interpolation based on De Boor's method.
+    It is allowed to have two spatial dimensions, but the second
+    dimension cannot be interpolated along. To interpolate along both
+    dimensions, use :class:`SplineInterpolate2D`.
+
+    Supports batched, multi-channel inputs, so acceptable data
+    shapes are ``(width)``, ``(height, width)``, ``(batch, width)``,
+    ``(batch, height, width)``, ``(batch, channel, width)``, and
+    ``(batch, channel, height, width)``.
+
+    During initialization of this Module, both the desired input
+    and output coordinate Tensors can be specified to allow
+    pre-computation of the B-spline basis matrices, though the only
+    mandatory argument is the coordinates of the data along the
+    ``width`` dimension.
+
+    Unlike scipy's implementation of spline interpolation, the data
+    to be interpolated is not passed until actually calling the
+    object. This is useful for cases where the input and output
+    coordinates are known in advance, but the data is not, so that
+    the interpolator can be set up ahead of time.
+
+    Args:
+        x_in:
+            Coordinates of the width dimension of the data
+        kx:
+            Degree of spline interpolation along the width dimension.
+            Default is cubic.
+        sx:
+            Regularization factor to avoid singularities during matrix
+            inversion for interpolation along the width dimension. Not
+            to be confused with the ``s`` parameter in scipy's spline
+            methods, which controls the number of knots.
+        x_out:
+            Coordinates for the data to be interpolated to along the
+            width dimension. If not specified during initialization,
+            this must be specified during the object call.
+
+    """
+
+    def __init__(
+        self,
+        x_in: Tensor,
+        kx: int = 3,
+        sx: float = 0.0,
+        x_out: Optional[Tensor] = None,
+    ):
+        super().__init__()
+
+        if len(x_in) < kx + 2:
+            raise ValueError(
+                "Input x-coordinates must have at least kx + 2 points."
+            )
+
+        # Ensure that coordinates are floats
+        x_in = x_in.float()
+        x_out = x_out.float() if x_out is not None else None
+
+        self.kx = kx
+        self.sx = sx
+        self.register_buffer("x_in", x_in)
+        self.register_buffer("x_out", x_out)
+
+        tx, Bx, BxT_Bx = self._compute_knots_and_basis_matrices(x_in, kx, sx)
+        self.register_buffer("tx", tx)
+        self.register_buffer("Bx", Bx)
+        self.register_buffer("BxT_Bx", BxT_Bx)
+
+        if self.x_out is not None:
+            x_clamped = torch.clamp(x_out, tx[kx], tx[-kx - 1])
+            Bx_out = self.bspline_basis_natural(x_clamped, kx, self.tx)
+            self.register_buffer("Bx_out", Bx_out)
+
+    def spline_fit_natural(self, Z):
+        # Adding batch/channel dimension handling
+        # Bx @ Z
+        BxT_Z = torch.einsum("ij,bchj->bchi", self.Bx.T, Z)
+        # (BxT @ Bx)^-1 @ (BxT @ Z) = Bx^-1 @ Z
+        C = torch.linalg.solve(self.BxT_Bx, BxT_Z.unsqueeze(-1))
+        return C.squeeze(-1)
+
+    def evaluate_spline(self, C: Tensor):
+        """
+        Evaluate a bivariate spline on a grid of x and y points.
+
+        Args:
+            C: Coefficient tensor of shape (batch_size, mx, my).
+
+        Returns:
+            Z_interp: Interpolated values at the grid points.
+        """
+        # Perform matrix multiplication using einsum to get Z_interp
+        return torch.einsum("ij,bchj->bchi", self.Bx_out, C)
+
+    def _validate_inputs(self, Z, x_out):
+        if x_out is None and self.x_out is None:
+            raise ValueError(
+                "Output x-coordinates were not specified in either object "
+                "creation or in forward call"
+            )
+
+        dims = len(Z.shape)
+        if dims > 4:
+            raise ValueError("Input data has more than 4 dimensions")
+
+        if Z.shape[-1] != len(self.x_in):
+            raise ValueError(
+                "The spatial dimensions of the data tensor do not match "
+                "the given input dimensions. "
+                f"Expected {len(self.x_in)}, but got {Z.shape[-1]}"
+            )
+
+        # Expand Z to have a batch, channel, and height dimension if needed
+        while len(Z.shape) < 4:
+            Z = Z.unsqueeze(0)
+
+        return Z
+
+    def forward(
+        self,
+        Z: Tensor,
+        x_out: Optional[Tensor] = None,
+    ) -> Tensor:
+        """
+        Compute the interpolated data
+
+        Args:
+            Z:
+                Tensor of data to be interpolated. Must be between 2 and 4
+                dimensions. The shape of the tensor must agree with the
+                input coordinates given on initialization.
+            x_out:
+                Coordinates to interpolate the data to along the width
+                dimension. Overrides any value that was set during
+                initialization.
+
+        Returns:
+            A 4D tensor with shape ``(batch, channel, height, width)``.
+            Depending on the input data shape, many of these dimensions
+            may have length 1.
+        """
+
+        Z = self._validate_inputs(Z, x_out)
+
+        if x_out is not None:
+            x_out = x_out.float()
+            x_clamped = torch.clamp(
+                x_out, self.tx[self.kx], self.tx[-self.kx - 1]
+            )
+            self.Bx_out = self.bspline_basis_natural(
+                x_clamped, self.kx, self.tx
+            )
+
+        coef = self.spline_fit_natural(Z)
+        Z_interp = self.evaluate_spline(coef)
+        return Z_interp
+
+
+class SplineInterpolate2D(SplineInterpolateBase):
+    """
+    Perform 2D spline interpolation based on De Boor's method.
+    Supports batched, multi-channel inputs, so acceptable data
+    shapes are ``(height, width)``, ``(batch, height, width)``,
+    and ``(batch, channel, height, width)``.
+
+    During initialization of this Module, both the desired input
+    and output coordinate Tensors can be specified to allow
+    pre-computation of the B-spline basis matrices, though the only
+    mandatory arguments are the input coordinates.
+
+    Unlike scipy's implementation of spline interpolation, the data
+    to be interpolated is not passed until actually calling the
+    object. This is useful for cases where the input and output
+    coordinates are known in advance, but the data is not, so that
+    the interpolator can be set up ahead of time.
+
+    Args:
+        x_in:
+            Coordinates of the width dimension of the data
+        y_in:
+            Coordinates of the height dimension of the data.
+        kx:
+            Degree of spline interpolation along the width dimension.
+            Default is cubic.
+        ky:
+            Degree of spline interpolation along the height dimension.
+            Default is cubic.
+        sx:
+            Regularization factor to avoid singularities during matrix
+            inversion for interpolation along the width dimension. Not
+            to be confused with the ``s`` parameter in scipy's spline
+            methods, which controls the number of knots.
+        sy:
+            Regularization factor to avoid singularities during matrix
+            inversion for interpolation along the height dimension.
+        x_out:
+            Coordinates for the data to be interpolated to along the
+            width dimension. If not specified during initialization,
+            this must be specified during the object call.
+        y_out:
+            Coordinates for the data to be interpolated to along the
+            height dimension. If not specified during initialization,
+            this must be specified during the object call.
+
+    """
+
+    def __init__(
+        self,
+        x_in: Tensor,
+        y_in: Tensor,
+        kx: int = 3,
+        ky: int = 3,
+        sx: float = 0.0,
+        sy: float = 0.0,
+        x_out: Optional[Tensor] = None,
+        y_out: Optional[Tensor] = None,
+    ):
+        super().__init__()
+
+        if len(x_in) < kx + 2:
+            raise ValueError(
+                "Input x-coordinates must have at least kx + 2 points."
+            )
+        if len(y_in) < ky + 2:
+            raise ValueError(
+                "Input y-coordinates must have at least ky + 2 points."
+            )
+
+        # Ensure that coordinates are floats
+        x_in = x_in.float()
+        y_in = y_in.float()
+        x_out = x_out.float() if x_out is not None else None
+        y_out = y_out.float() if y_out is not None else None
+
+        self.kx = kx
+        self.ky = ky
+        self.sx = sx
+        self.sy = sy
+        self.register_buffer("x_in", x_in)
+        self.register_buffer("y_in", y_in)
+        self.register_buffer("x_out", x_out)
+        self.register_buffer("y_out", y_out)
+
+        tx, Bx, BxT_Bx = self._compute_knots_and_basis_matrices(x_in, kx, sx)
+        self.register_buffer("tx", tx)
+        self.register_buffer("Bx", Bx)
+        self.register_buffer("BxT_Bx", BxT_Bx)
+
+        ty, By, ByT_By = self._compute_knots_and_basis_matrices(y_in, ky, sy)
+        self.register_buffer("ty", ty)
+        self.register_buffer("By", By)
+        self.register_buffer("ByT_By", ByT_By)
+
+        if self.x_out is not None:
+            x_clamped = torch.clamp(x_out, tx[kx], tx[-kx - 1])
+            Bx_out = self.bspline_basis_natural(x_clamped, kx, self.tx)
+            self.register_buffer("Bx_out", Bx_out)
+        if self.y_out is not None:
+            y_clamped = torch.clamp(y_out, ty[ky], ty[-ky - 1])
+            By_out = self.bspline_basis_natural(y_clamped, ky, self.ty)
+            self.register_buffer("By_out", By_out)
+
+    def bivariate_spline_fit_natural(self, Z):
         # Adding batch/channel dimension handling
         # ByT @ Z @ BxW
         ByT_Z_Bx = torch.einsum("ij,bcik,kl->bcjl", self.By, Z, self.Bx)
@@ -280,8 +445,6 @@ class SplineInterpolate(torch.nn.Module):
             Z_interp: Interpolated values at the grid points.
         """
         # Perform matrix multiplication using einsum to get Z_interp
-        if len(C.shape) == 3:
-            return torch.matmul(C, self.Bx_out.mT)
         return torch.einsum("ik,bckm,mj->bcij", self.By_out, C, self.Bx_out.mT)
 
     def _validate_inputs(self, Z, x_out, y_out):
@@ -292,29 +455,16 @@ class SplineInterpolate(torch.nn.Module):
             )
 
         if y_out is None and self.y_out is None:
-            y_out = self.y_in
+            raise ValueError(
+                "Output y-coordinates were not specified in either object "
+                "creation or in forward call"
+            )
 
         dims = len(Z.shape)
         if dims > 4:
             raise ValueError("Input data has more than 4 dimensions")
-
-        if len(self.y_in) > 1 and dims == 1:
-            raise ValueError(
-                "An input y-coordinate array with length greater than 1 "
-                "was given, but the input data is 1-dimensional. Expected "
-                "input data to be at least 2-dimensional"
-            )
-
-        # Expand Z to have 4 dimensions
-        # There are 6 valid input shapes: (w), (b, w), (b, c, w),
-        # (h, w), (b, h, w), and (b, c, h, w).
-
-        # If the input y coordinate array has length 1,
-        # assume the first dimension(s) are batch dimensions
-        # and that no height dimension is included in Z
-        idx = -2 if len(self.y_in) == 1 else -3
-        while len(Z.shape) < 4:
-            Z = Z.unsqueeze(idx)
+        if dims < 2:
+            raise ValueError("Input data has fewer than 2 dimensions")
 
         if Z.shape[-2:] != torch.Size([len(self.y_in), len(self.x_in)]):
             raise ValueError(
@@ -324,6 +474,10 @@ class SplineInterpolate(torch.nn.Module):
                 f"[{Z.shape[-2]}, {Z.shape[-1]}]"
             )
 
+        # Expand Z to have a batch and channel dimension if needed
+        while len(Z.shape) < 4:
+            Z = Z.unsqueeze(0)
+
         return Z, y_out
 
     def forward(
@@ -337,11 +491,9 @@ class SplineInterpolate(torch.nn.Module):
 
         Args:
             Z:
-                Tensor of data to be interpolated. Must be between 1 and 4
+                Tensor of data to be interpolated. Must be between 2 and 4
                 dimensions. The shape of the tensor must agree with the
-                input coordinates given on initialization. If `y_in` was
-                not specified during initialization, it is assumed that
-                Z does not have a height dimension.
+                input coordinates given on initialization.
             x_out:
                 Coordinates to interpolate the data to along the width
                 dimension. Overrides any value that was set during
@@ -352,7 +504,7 @@ class SplineInterpolate(torch.nn.Module):
                 initialization.
 
         Returns:
-            A 4D tensor with shape `(batch, channel, height, width)`.
+            A 4D tensor with shape ``(batch, channel, height, width)``.
             Depending on the input data shape, many of these dimensions
             may have length 1.
         """
@@ -360,9 +512,21 @@ class SplineInterpolate(torch.nn.Module):
         Z, y_out = self._validate_inputs(Z, x_out, y_out)
 
         if x_out is not None:
-            self.Bx_out = self.bspline_basis_natural(x_out, self.kx, self.tx)
+            x_out = x_out.float()
+            x_clamped = torch.clamp(
+                x_out, self.tx[self.kx], self.tx[-self.kx - 1]
+            )
+            self.Bx_out = self.bspline_basis_natural(
+                x_clamped, self.kx, self.tx
+            )
         if y_out is not None:
-            self.By_out = self.bspline_basis_natural(y_out, self.ky, self.ty)
+            y_out = y_out.float()
+            y_clamped = torch.clamp(
+                y_out, self.ty[self.ky], self.ty[-self.ky - 1]
+            )
+            self.By_out = self.bspline_basis_natural(
+                y_clamped, self.ky, self.ty
+            )
 
         coef = self.bivariate_spline_fit_natural(Z)
         Z_interp = self.evaluate_bivariate_spline(coef)

ml4gw/transforms/transform.py

@@ -70,7 +70,7 @@ class FittableSpectralTransform(FittableTransform):
             )
 
         # add two dummy dimensions in case we need to interpolate
-        # the frequency dimension, since `interpolate` expects
+        # the frequency dimension, since ``interpolate`` expects
         # a (batch, channel, spatial) formatted tensor as input
         x = x.view(1, 1, -1)
         if x.size(-1) != num_freqs: