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

ml4gw/nn/resnet/resnet_2d.py

@@ -105,10 +105,10 @@ class BasicBlock(nn.Module):
 class Bottleneck(nn.Module):
     """
     Bottleneck blocks implement one extra convolution
-    compared to basic blocks. In this layers, the `planes`
+    compared to basic blocks. In this layers, the ``planes``
     parameter is generally meant to _downsize_ the number
     of feature maps first, which then get expanded out to
-    `planes * Bottleneck.expansion` feature maps at the
+    ``planes * Bottleneck.expansion`` feature maps at the
     output of the layer.
     """
 
@@ -188,9 +188,9 @@ class ResNet2D(nn.Module):
             A list representing the number of residual
             blocks to include in each "layer" of the
             network. Total layers (e.g. 50 in ResNet50)
-            is `2 + sum(layers) * factor`, where factor
-            is `2` for vanilla `ResNet` and `3` for
-            `BottleneckResNet`.
+            is ``2 + sum(layers) * factor``, where factor
+            is ``2`` for vanilla ``ResNet`` and ``3`` for
+            ``BottleneckResNet``.
         kernel_size:
             The size of the convolutional kernel to
             use in all residual layers. _NOT_ the size
@@ -207,22 +207,22 @@ class ResNet2D(nn.Module):
             connections between feature maps at subsequent
             layers rather than global. Generally won't
             need this to be >1, and wil raise an error if
-            >1 when using vanilla `ResNet`.
+            >1 when using vanilla ``ResNet``.
         width_per_group:
             Base width of each of the feature map groups,
             which is scaled up by the typical expansion
             factor at each layer of the network. Meaningless
-            for vanilla `ResNet`.
+            for vanilla ``ResNet``.
         stride_type:
             Whether to achieve downsampling on the time axis
             by strided or dilated convolutions for each layer.
-            If left as `None`, strided convolutions will be
-            used at each layer. Otherwise, `stride_type` should
-            be one element shorter than `layers` and indicate either
-            `stride` or `dilation` for each layer after the first.
+            If left as ``None``, strided convolutions will be
+            used at each layer. Otherwise, ``stride_type`` should
+            be one element shorter than ``layers`` and indicate either
+            ``stride`` or ``dilation`` for each layer after the first.
         norm_groups:
             The number of groups to use in GroupNorm layers
-            throughout the model. If left as `-1`, the number
+            throughout the model. If left as ``-1``, the number
             of groups will be equal to the number of channels,
             making this equilavent to LayerNorm
     """

ml4gw/nn/streaming/online_average.py

@@ -11,7 +11,7 @@ class OnlineAverager(torch.nn.Module):
     """
     Module for performing stateful online averaging of
     batches of overlapping timeseries. At present, the
-    first `num_updates` predictions produced by this
+    first ``num_updates`` predictions produced by this
     model will underestimate the true average.
 
     Args:

ml4gw/nn/streaming/snapshotter.py

@@ -12,24 +12,24 @@ class Snapshotter(torch.nn.Module):
     Model for converting streaming state updates into
     a batch of overlapping snaphots of a multichannel
     timeseries. Can support multiple timeseries in a
-    single state update via the `channels_per_snapshot`
+    single state update via the ``channels_per_snapshot``
     kwarg.
 
     Specifically, maps tensors of shape
-    `(num_channels, batch_size * stride_size)` to a tensor
-    of shape `(batch_size, num_channels, snapshot_size)`.
-    If `channels_per_snapshot` is specified, it will return
-    `len(channels_per_snapshot)` tensors of this shape,
+    ``(num_channels, batch_size * stride_size)`` to a tensor
+    of shape ``(batch_size, num_channels, snapshot_size)``.
+    If ``channels_per_snapshot`` is specified, it will return
+    ``len(channels_per_snapshot)`` tensors of this shape,
     with the channel dimension replaced by the corresponding
-    value of `channels_per_snapshot`. The last tensor returned
+    value of ``channels_per_snapshot``. The last tensor returned
     at call time will be the current state that can be passed
-    to the next `forward` call.
+    to the next ``forward`` call.
 
     Args:
         num_channels:
             Number of channels in the timeseries. If
-            `channels_per_snapshot` is not `None`,
-            this should be equal to `sum(channels_per_snapshot)`.
+            ``channels_per_snapshot`` is not ``None``,
+            this should be equal to ``sum(channels_per_snapshot)``.
         snapshot_size:
             The size of the output snapshot windows in
             number of samples
@@ -39,17 +39,17 @@ class Snapshotter(torch.nn.Module):
         batch_size:
             The number of snapshots to produce at each
             update. The last dimension of the input
-            tensor should have size `batch_size * stride_size`.
+            tensor should have size ``batch_size * stride_size``.
         channels_per_snapshot:
             How to split up the channels in the timeseries
-            for different tensors. If left as `None`, all
+            for different tensors. If left as ``None``, all
             the channels will be returned in a single tensor.
             Otherwise, the channels will be split up into
-            `len(channels_per_snapshot)` tensors, with each
+            ``len(channels_per_snapshot)`` tensors, with each
             tensor's channel dimension being equal to the
-            corresponding value in `channels_per_snapshot`.
+            corresponding value in ``channels_per_snapshot``.
             Therefore, if specified, these values should
-            add up to `num_channels`.
+            add up to ``num_channels``.
     """
 
     def __init__(

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/__init__.py

@@ -5,6 +5,6 @@ from .scaler import ChannelWiseScaler
 from .snr_rescaler import SnrRescaler
 from .spectral import SpectralDensity
 from .spectrogram import MultiResolutionSpectrogram
-from .spline_interpolation import SplineInterpolate
+from .spline_interpolation import SplineInterpolate1D, SplineInterpolate2D
 from .waveforms import WaveformProjector, WaveformSampler
 from .whitening import FixedWhiten, Whiten

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

@@ -8,7 +8,7 @@ from jaxtyping import Float, Int
 from torch import Tensor
 
 from ..types import FrequencySeries1to3d, TimeSeries1to3d, TimeSeries3d
-from .spline_interpolation import SplineInterpolate
+from .spline_interpolation import SplineInterpolate1D
 
 """
 All based on https://github.com/gwpy/gwpy/blob/v3.0.8/gwpy/signal/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
@@ -260,18 +260,15 @@ class SingleQTransform(torch.nn.Module):
         )
         self.qtile_interpolators = torch.nn.ModuleList(
             [
-                SplineInterpolate(
+                SplineInterpolate1D(
                     kx=3,
                     x_in=torch.arange(0, self.duration, self.duration / tiles),
-                    y_in=torch.arange(len(idx)),
                     x_out=t_out,
-                    y_out=torch.arange(len(idx)),
                 )
-                for tiles, idx in zip(unique_ntiles, self.stack_idx)
+                for tiles in unique_ntiles
             ]
         )
 
-        t_in = t_out
         f_in = self.freqs
         f_out = torch.logspace(
             math.log10(self.frange[0]),
@@ -279,19 +276,16 @@ class SingleQTransform(torch.nn.Module):
             self.spectrogram_shape[0],
         )
 
-        self.interpolator = SplineInterpolate(
+        self.interpolator = SplineInterpolate1D(
             kx=3,
-            ky=3,
-            x_in=t_in,
-            y_in=f_in,
-            x_out=t_out,
-            y_out=f_out,
+            x_in=f_in,
+            x_out=f_out,
         )
 
     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 +314,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 +354,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")
@@ -379,14 +373,15 @@ class SingleQTransform(torch.nn.Module):
             ]
             time_interped = torch.cat(
                 [
-                    interpolator(qtile)
-                    for qtile, interpolator in zip(
+                    qtile_interpolator(qtile)
+                    for qtile, qtile_interpolator in zip(
                         qtiles, self.qtile_interpolators
                     )
                 ],
                 dim=-2,
             )
-            return self.interpolator(time_interped)
+            # Transpose because the final dimension gets interpolated
+            return self.interpolator(time_interped.mT).mT
         num_f_bins, num_t_bins = self.spectrogram_shape
         resampled = [
             F.interpolate(
@@ -416,9 +411,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 +440,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 +530,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: