ml4gw 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

ml4gw/spectral.py

@@ -27,8 +27,8 @@ def median(x: Float[Tensor, "... size"], axis: int) -> Float[Tensor, "..."]:
     """
     Implements a median calculation that matches numpy's
     behavior for an even number of elements and includes
-    the same bias correction used by scipy's implementation.
-    see https://github.com/scipy/scipy/blob/main/scipy/signal/_spectral_py.py#L2066
+    the same bias correction used by
+    `scipy's implementation <https://github.com/scipy/scipy/blob/main/scipy/signal/_spectral_py.py#L2066>`_.
     """  # noqa: E501
     n = x.shape[axis]
     ii_2 = 2 * torch.arange(1.0, (n - 1) // 2 + 1)
@@ -111,50 +111,50 @@ def fast_spectral_density(
             The timeseries tensor whose power spectral density
             to compute, or for cross spectral density the
             timeseries whose fft will be conjugated. Can have
-            shape `(batch_size, num_channels, length * sample_rate)`,
-            `(num_channels, length * sample_rate)`, or
-            `(length * sample_rate)`.
+            shape ``(batch_size, num_channels, length * sample_rate)``,
+            ``(num_channels, length * sample_rate)``, or
+            ``(length * sample_rate)``.
         nperseg:
             Number of samples included in each FFT window
         nstride:
             Stride between FFT windows
         window:
             Window array to multiply by each FFT window before
-            FFT computation. Should have length `nperseg // 2 + 1`.
+            FFT computation. Should have length ``nperseg // 2 + 1``.
         scale:
             Scale factor to multiply the FFT'd data by, related to
             desired units for output tensor (e.g. letting this equal
-            `1 / (sample_rate * (window**2).sum())` will give output
-            units of density, $\\text{Hz}^-1$$.
+            ``1 / (sample_rate * (window**2).sum())`` will give output
+            units of density, :math``\\text{Hz}^-1``.
         average:
             How to aggregate the contributions of each FFT window to
-            the spectral density. Allowed options are `'mean'` and
-            `'median'`.
+            the spectral density. Allowed options are ``'mean'`` and
+            ``'median'``.
         y:
             Timeseries tensor to compute cross spectral density
-            with `x`. If left as `None`, `x`'s power spectral
-            density will be returned. Otherwise, if `x` is 1D,
-            `y` must also be 1D. If `x` is 2D, the assumption
+            with ``x``. If left as ``None``, ``x``'s power spectral
+            density will be returned. Otherwise, if ``x`` is 1D,
+            ``y`` must also be 1D. If ``x`` is 2D, the assumption
             is that this represents a single multi-channel timeseries,
-            and `y` must be either 2D or 1D. In the former case,
+            and ``y`` must be either 2D or 1D. In the former case,
             the cross-spectral densities of each channel will be
-            computed individually, so `y` must have the same shape as `x`.
-            Otherwise, this will compute the CSD of each of `x`'s channels
-            with `y`. If `x` is 3D, this will be assumed to be a batch
-            of multi-channel timeseries. In this case, `y` can either
+            computed individually, so ``y`` must have the same shape as ``x``.
+            Otherwise, this will compute the CSD of each of ``x``'s channels
+            with ``y``. If ``x`` is 3D, this will be assumed to be a batch
+            of multi-channel timeseries. In this case, ``y`` can either
             be 3D, in which case each channel of each batch element will
             have its CSD calculated or 2D, which has two different options.
-            If `y`'s 0th dimension matches `x`'s 0th dimension, it will
-            be assumed that `y` represents a batch of 1D timeseries, and
+            If ``y``'s 0th dimension matches ``x``'s 0th dimension, it will
+            be assumed that ``y`` represents a batch of 1D timeseries, and
             for each batch element this timeseries will have its CSD with
-            each channel of the corresponding batch element of `x`
-            calculated. Otherwise, it sill be assumed that `y` represents
+            each channel of the corresponding batch element of ``x``
+            calculated. Otherwise, it sill be assumed that ``y`` represents
             a single multi-channel timeseries, in which case each channel
-            of `y` will have its CSD calculated with the corresponding
-            channel in `x` across _all_ of `x`'s batch elements.
+            of ``y`` will have its CSD calculated with the corresponding
+            channel in ``x`` across _all_ of ``x``'s batch elements.
     Returns:
-        Tensor of power spectral densities of `x` or its cross spectral
-        density with the timeseries in `y`.
+        Tensor of power spectral densities of ``x`` or its cross spectral
+        density with the timeseries in ``y``.
     """
 
     _validate_shapes(x, nperseg, y)
@@ -262,25 +262,25 @@ def spectral_density(
             The timeseries tensor whose power spectral density
             to compute, or for cross spectral density the
             timeseries whose fft will be conjugated. Can have
-            shape `(batch_size, num_channels, length * sample_rate)`,
-            `(num_channels, length * sample_rate)`, or
-            `(length * sample_rate)`.
+            shape ``(batch_size, num_channels, length * sample_rate)``,
+            ``(num_channels, length * sample_rate)``, or
+            ``(length * sample_rate)``.
         nperseg:
             Number of samples included in each FFT window
         nstride:
             Stride between FFT windows
         window:
             Window array to multiply by each FFT window before
-            FFT computation. Should have length `nperseg // 2 + 1`.
+            FFT computation. Should have length ``nperseg // 2 + 1``.
         scale:
             Scale factor to multiply the FFT'd data by, related to
             desired units for output tensor (e.g. letting this equal
-            `1 / (sample_rate * (window**2).sum())` will give output
-            units of density, $\\text{Hz}^-1$$.
+            ``1 / (sample_rate * (window**2).sum())`` will give output
+            units of density, :math:`\\text{Hz}^-1`.
         average:
             How to aggregate the contributions of each FFT window to
-            the spectral density. Allowed options are `'mean'` and
-            `'median'`.
+            the spectral density. Allowed options are ``'mean'`` and
+            ``'median'``.
     """
 
     _validate_shapes(x, nperseg)
@@ -348,18 +348,18 @@ def truncate_inverse_power_spectrum(
     """
     Truncate the length of the time domain response
     of a whitening filter built using the specified
-    `psd` so that it has maximum length `fduration`
+    ``psd`` so that it has maximum length ``fduration``
     seconds. This is meant to mitigate the impact
     of sharp features in the background PSD causing
     time domain responses longer than the segments
     to which the whitening filter will be applied.
 
     Implementation details adapted from
-    https://github.com/vivinousi/gw-detection-deep-learning/blob/203966cc2ee47c32c292be000fb009a16824b7d9/modules/whiten.py#L8
+    `here <https://github.com/vivinousi/gw-detection-deep-learning/blob/203966cc2ee47c32c292be000fb009a16824b7d9/modules/whiten.py#L8>`_.
 
     Args:
         psd:
-            The one-sided power spectraul density used
+            The one-sided power spectral density used
             to construct a whitening filter.
         fduration:
             Desired length in seconds of the time domain
@@ -375,14 +375,14 @@ def truncate_inverse_power_spectrum(
         highpass:
             If specified, will zero out the frequency response
             of all frequencies below this value in Hz. If left
-            as `None`, no highpass filtering will be applied.
+            as ``None``, no highpass filtering will be applied.
         lowpass:
             If specified, will zero out the frequency response
             of all frequencies above this value in Hz. If left
-            as `None`, no lowpass filtering will be applied.
+            as ``None``, no lowpass filtering will be applied.
     Returns:
         The PSD with its time domain response truncated
-            to `fduration` and any filtered frequencies
+            to ``fduration`` and any filtered frequencies
             tapered.
     """  # noqa: E501
 
@@ -469,7 +469,7 @@ def whiten(
     Whiten a batch of timeseries using the specified
     background one-sided power spectral densities (PSDs),
     modified to have the desired time domain response length
-    `fduration` and possibly to highpass/lowpass filter.
+    ``fduration`` and possibly to highpass/lowpass filter.
 
     Args:
         X:
@@ -480,11 +480,11 @@ def whiten(
             the inverse of the square root of this PSD, ensuring
             that data from the same distribution will have
             approximately uniform power after whitening.
-            If 2D, each batch element in `X` will be whitened
+            If 2D, each batch element in ``X`` will be whitened
             using the same PSDs. If 3D, each batch element will
             be whitened by the PSDs contained along the 0th
-            dimenion of `psd`, and so the first two dimensions
-            of `X` and `psd` should match.
+            dimenion of ``psd``, and so the first two dimensions
+            of ``X`` and ``psd`` should match.
         fduration:
             Desired length in seconds of the time domain
             response of a whitening filter built using
@@ -496,20 +496,20 @@ def whiten(
             the whitened timeseries to account for filter
             settle-in time.
         sample_rate:
-            Rate at which the data in `X` has been sampled
+            Rate at which the data in ``X`` has been sampled
         highpass:
             The frequency in Hz at which to highpass filter
             the data, setting the frequency response in the
-            whitening filter to 0. If left as `None`, no
+            whitening filter to 0. If left as ``None``, no
             highpass filtering will be applied.
         lowpass:
             The frequency in Hz at which to lowpass filter
             the data, setting the frequency response in the
-            whitening filter to 0. If left as `None`, no
+            whitening filter to 0. If left as ``None``, no
             lowpass filtering will be applied.
     Returns:
         Batch of whitened multichannel timeseries with
-            `fduration / 2` seconds trimmed from each side.
+            ``fduration / 2`` seconds trimmed from each side.
     """
 
     # figure out how much data we'll need to slice

ml4gw/transforms/iirfilter.py

@@ -9,7 +9,7 @@ class IIRFilter(torch.nn.Module):
     r"""
     IIR digital and analog filter design given order and critical points.
     Design an Nth-order digital or analog filter and apply it to a signal.
-    Uses SciPy's `iirfilter` function to create the filter coefficients.
+    Uses SciPy's ``iirfilter`` function to create the filter coefficients.
     https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.iirfilter.html
 
     The forward call of this module accepts a batch tensor of shape
@@ -24,8 +24,8 @@ class IIRFilter(torch.nn.Module):
             default, fs is 2 half-cycles/sample, so these are normalized
             from 0 to 1, where 1 is the Nyquist frequency. (Wn is thus in
             half-cycles / sample). For analog filters, Wn is an angular
-            frequency (e.g., rad/s). When Wn is a length-2 sequence,`Wn[0]`
-            must be less than `Wn[1]`.
+            frequency (e.g., rad/s). When Wn is a length-2 sequence,``Wn[0]``
+            must be less than ``Wn[1]``.
         rp:
             For Chebyshev and elliptic filters, provides the maximum ripple in
             the passband. (dB)

ml4gw/transforms/pearson.py

@@ -8,20 +8,19 @@ from ..utils.slicing import unfold_windows
 
 class ShiftedPearsonCorrelation(torch.nn.Module):
     """
-    Compute the [Pearson correlation]
-    (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)
+    Compute the `Pearson correlation <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_
     for two equal-length timeseries over a pre-defined number of time
     shifts in each direction. Useful for when you want a
     correlation, but not over every possible shift (i.e.
     a convolution).
 
-    The number of dimensions of the second timeseries `y`
+    The number of dimensions of the second timeseries ``y``
     passed at call time should always be less than or equal
-    to the number of dimensions of the first timeseries `x`,
+    to the number of dimensions of the first timeseries ``x``,
     and each dimension should match the corresponding one of
-    `x` in  reverse order (i.e. if `x` has shape `(B, C, T)`
-    then `y` should either have shape `(T,)`, `(C, T)`, or
-    `(B, C, T)`).
+    ``x`` in  reverse order (i.e. if ``x`` has shape ``(B, C, T)``
+    then ``y`` should either have shape ``(T,)``, ``(C, T)``, or
+    ``(B, C, T)``).
 
     Note that no windowing to either timeseries is applied
     at call time. Users should do any requisite windowing
@@ -36,7 +35,7 @@ class ShiftedPearsonCorrelation(torch.nn.Module):
             The maximum number of 1-step time shifts in
             each direction over which to compute the
             Pearson coefficient. Output shape will then
-            be `(2 * max_shifts + 1, B, C)`.
+            be ``(2 * max_shifts + 1, B, C)``.
     """
 
     def __init__(self, max_shift: int) -> None:

ml4gw/transforms/qtransform.py

@@ -22,7 +22,7 @@ class QTile(torch.nn.Module):
     """
     Compute the row of Q-tiles for a single Q value and a single
     frequency for a batch of multi-channel frequency series data.
-    Should really be called `QRow`, but I want to match GWpy.
+    Should really be called ``QRow``, but I want to match GWpy.
     Input data should have three dimensions or fewer.
     If fewer, dimensions will be added until the input is
     three-dimensional.
@@ -112,17 +112,17 @@ class QTile(torch.nn.Module):
             fseries:
                 Frequency series of data. Should correspond to data with
                 the duration and sample rate used to initialize this object.
-                Expected input shape is `(B, C, F)`, where F is the number
+                Expected input shape is ``(B, C, F)``, where F is the number
                 of samples, C is the number of channels, and B is the number
                 of batches. If less than three-dimensional, axes will be
                 added.
             norm:
                 The method of normalization. Options are "median", "mean", or
-                `None`.
+                ``None``.
 
         Returns:
             The row of Q-tiles for the given Q and frequency. Output is
-            three-dimensional: `(B, C, T)`
+            three-dimensional: ``(B, C, T)``
         """
         if len(fseries.shape) > 3:
             raise ValueError("Input data has more than 3 dimensions")
@@ -164,7 +164,7 @@ class SingleQTransform(torch.nn.Module):
             Sample rate of the data in Hz
         spectrogram_shape:
             The shape of the interpolated spectrogram, specified as
-            `(num_f_bins, num_t_bins)`. Because the
+            ``(num_f_bins, num_t_bins)``. Because the
             frequency spacing of the Q-tiles is in log-space, the frequency
             interpolation is log-spaced as well.
         q:
@@ -176,14 +176,14 @@ class SingleQTransform(torch.nn.Module):
         mismatch:
             The maximum fractional mismatch between neighboring tiles
         interpolation_method:
-            The method by which to interpolate each `QTile` to the specified
+            The method by which to interpolate each ``QTile`` to the specified
             number of time and frequency bins. The acceptable values are
             "bilinear", "bicubic", and "spline". The "bilinear" and "bicubic"
             options will use PyTorch's built-in interpolation modes, while
             "spline" will use the custom Torch-based implementation in
-            `ml4gw`, as PyTorch does not have spline-based intertpolation.
+            ``ml4gw``, as PyTorch does not have spline-based intertpolation.
             The "spline" mode is most similar to the results of GWpy's
-            Q-transform, which uses `scipy` to do spline interpolation.
+            Q-transform, which uses ``scipy`` to do spline interpolation.
             However, it is also the slowest and most memory intensive due to
             the matrix equation solving steps. Therefore, the default method
             is "bicubic" as it produces the most similar results while
@@ -291,7 +291,7 @@ class SingleQTransform(torch.nn.Module):
     def get_freqs(self) -> Float[Tensor, " nfreq"]:
         """
         Calculate the frequencies that will be used in this transform.
-        For each frequency, a `QTile` is created.
+        For each frequency, a ``QTile`` is created.
         """
         minf, maxf = self.frange
         fcum_mismatch = (
@@ -320,7 +320,7 @@ class SingleQTransform(torch.nn.Module):
         be slow, so this isn't used yet.
 
         Optionally, a pair of frequency values can be specified for
-        `fsearch_range` to restrict the frequencies in which the maximum
+        ``fsearch_range`` to restrict the frequencies in which the maximum
         energy value is sought.
         """
         allowed_dimensions = ["both", "neither", "channel", "batch"]
@@ -360,7 +360,7 @@ class SingleQTransform(torch.nn.Module):
     ) -> None:
         """
         Take the FFT of the input timeseries and calculate the transform
-        for each `QTile`
+        for each ``QTile``
         """
         # Computing the FFT with the same normalization and scaling as GWpy
         X = torch.fft.rfft(X, norm="forward")
@@ -416,9 +416,9 @@ class SingleQTransform(torch.nn.Module):
             X:
                 Time series of data. Should have the duration and sample rate
                 used to initialize this object. Expected input shape is
-                `(B, C, T)`, where T is the number of samples, C is the number
-                of channels, and B is the number of batches. If less than
-                three-dimensional, axes will be added during Q-tile
+                ``(B, C, T)``, where T is the number of samples, C is the
+                number of channels, and B is the number of batches. If less
+                than three-dimensional, axes will be added during Q-tile
                 computation.
             norm:
                 The method of normalization used by each QTile
@@ -445,13 +445,13 @@ class QScan(torch.nn.Module):
             Sample rate of the data in Hz
         spectrogram_shape:
             The shape of the interpolated spectrogram, specified as
-            `(num_f_bins, num_t_bins)`. Because the
+            ``(num_f_bins, num_t_bins)``. Because the
             frequency spacing of the Q-tiles is in log-space, the frequency
             interpolation is log-spaced as well.
         qrange:
             The lower and upper values of Q to consider. The
             actual values of Q used for the transforms are
-            determined by the `get_qs` method
+            determined by the ``get_qs`` method
         frange:
             The lower and upper frequency limit to consider for
             the transform. If unspecified, default values will
@@ -535,9 +535,9 @@ class QScan(torch.nn.Module):
             X:
                 Time series of data. Should have the duration and sample rate
                 used to initialize this object. Expected input shape is
-                `(B, C, T)`, where T is the number of samples, C is the number
-                of channels, and B is the number of batches. If less than
-                three-dimensional, axes will be added during Q-tile
+                ``(B, C, T)``, where T is the number of samples, C is the
+                number of channels, and B is the number of batches. If less
+                than three-dimensional, axes will be added during Q-tile
                 computation.
             fsearch_range:
                 The lower and upper frequency values within which to search

ml4gw/transforms/scaler.py

@@ -13,14 +13,14 @@ class ChannelWiseScaler(FittableTransform):
     Scales timeseries channels by the mean and standard
     deviation of the channels of the timeseries used to
     fit the module. To reverse the scaling, provide the
-    `reverse=True` keyword argument at call time.
+    ``reverse=True`` keyword argument at call time.
     By default, the scaling parameters are set to zero mean
     and unit variance, amounting to an identity transform.
 
     Args:
         num_channels:
             The number of channels of the target timeseries.
-            If left as `None`, the timeseries will be assumed
+            If left as ``None``, the timeseries will be assumed
             to be 1D (single channel).
     """
 
@@ -42,8 +42,8 @@ class ChannelWiseScaler(FittableTransform):
         """Fit the scaling parameters to a timeseries
 
         Computes the channel-wise mean and standard deviation
-        of the timeseries `X` and sets these values to the
-        `mean` and `std` parameters of the scaler.
+        of the timeseries ``X`` and sets these values to the
+        ``mean`` and ``std`` parameters of the scaler.
         """
 
         if X.ndim == 1:

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

@@ -13,16 +13,16 @@ class SplineInterpolate(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)`.
+    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
+    ``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
@@ -55,7 +55,7 @@ class SplineInterpolate(torch.nn.Module):
         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
+            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
@@ -256,11 +256,6 @@ 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
-
         # Adding batch/channel dimension handling
         # ByT @ Z @ BxW
         ByT_Z_Bx = torch.einsum("ij,bcik,kl->bcjl", self.By, Z, self.Bx)
@@ -280,8 +275,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):
@@ -339,7 +332,7 @@ class SplineInterpolate(torch.nn.Module):
             Z:
                 Tensor of data to be interpolated. Must be between 1 and 4
                 dimensions. The shape of the tensor must agree with the
-                input coordinates given on initialization. If `y_in` was
+                input coordinates given on initialization. If ``y_in`` was
                 not specified during initialization, it is assumed that
                 Z does not have a height dimension.
             x_out:
@@ -352,7 +345,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.
         """

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: