ml4gw 0.7.5__tar.gz → 0.7.7__tar.gz

{ml4gw-0.7.5 → ml4gw-0.7.7}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: ml4gw
-Version: 0.7.5
+Version: 0.7.7
 Summary: Tools for training torch models on gravitational wave data
 Author-email: Ethan Marx <emarx@mit.edu>, Will Benoit <benoi090@umn.edu>, Deep Chatterjee <deep1018@mit.edu>, Alec Gunny <alec.gunny@ligo.org>
-License-File: LICENSE
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -11,12 +10,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: jaxtyping<0.3,>=0.2
+Requires-Dist: torch~=2.0
+Requires-Dist: torchaudio~=2.0
 Requires-Dist: numpy<2.0.0
 Requires-Dist: scipy<1.15,>=1.9.0
-Requires-Dist: torchaudio~=2.0
-Requires-Dist: torch~=2.0
-Description-Content-Type: text/markdown
+Dynamic: license-file
 
 # ML4GW
 ![PyPI - Version](https://img.shields.io/pypi/v/ml4gw)

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/augmentations.py

@@ -6,8 +6,8 @@ from torch import Tensor
 class SignalInverter(torch.nn.Module):
     """
     Takes a tensor of timeseries of arbitrary dimension
-    and randomly inverts (i.e. h(t) -> -h(t))
-    each timeseries with probability `prob`.
+    and randomly inverts i.e. :math:`h(t) \\rightarrow -h(t)`
+    each timeseries with probability ``prob``.
 
     Args:
         prob:
@@ -29,8 +29,8 @@ class SignalInverter(torch.nn.Module):
 class SignalReverser(torch.nn.Module):
     """
     Takes a tensor of timeseries of arbitrary dimension
-    and randomly reverses (i.e. h(t) -> h(-t))
-    each timeseries with probability `prob`.
+    and randomly reverses i.e., :math:`h(t) \\rightarrow h(-t)`.
+    each timeseries with probability ``prob``.
 
     Args:
         prob:

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/dataloading/chunked_dataset.py

@@ -15,9 +15,9 @@ class ChunkedTimeSeriesDataset(torch.utils.data.IterableDataset):
         chunk_it:
             Iterator which will produce chunks of timeseries
             data to sample windows from. Should have shape
-            `(N, C, T)`, where `N` is the number of chunks
-            to sample from, `C` is the number of channels,
-            and `T` is the number of samples along the
+            ``(N, C, T)``, where ``N`` is the number of chunks
+            to sample from, ``C`` is the number of channels,
+            and ``T`` is the number of samples along the
             time dimension for each chunk.
         kernel_size:
             Size of windows to be sampled from each chunk.

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/dataloading/hdf5_dataset.py

@@ -17,8 +17,7 @@ class Hdf5TimeSeriesDataset(torch.utils.data.IterableDataset):
     Iterable dataset that samples and loads windows of
     timeseries data uniformly from a set of HDF5 files.
     It is _strongly_ recommended that these files have been
-    written using [chunked storage]
-    (https://docs.h5py.org/en/stable/high/dataset.html#chunked-storage).
+    written using `chunked storage <https://docs.h5py.org/en/stable/high/dataset.html#chunked-storage>`_.
     This has shown to produce increases in read-time speeds
     of over an order of magnitude.
 
@@ -37,27 +36,25 @@ class Hdf5TimeSeriesDataset(torch.utils.data.IterableDataset):
             Number of windows to sample at each iteration.
         batches_per_epoch:
             Number of batches to generate during each call
-            to `__iter__`.
+            to ``__iter__``.
         coincident:
             Whether windows for each channel in a given batch
             element should be sampled coincidentally, i.e.
             corresponding to the same time indices from the
             same files, or should be sampled independently.
             For the latter case, users can either specify
-            `False`, which will sample filenames independently
-            for each channel, or `"files"`, which will sample
+            ``False``, which will sample filenames independently
+            for each channel, or ``"files"``, which will sample
             windows independently within a given file for each
             channel. The latter setting limits the amount of
             entropy in the effective dataset, but can provide
             over 2x improvement in total throughput.
         num_files_per_batch:
             The number of unique files from which to sample
-            batch elements each epoch. If left as `None`,
+            batch elements each epoch. If left as ``None``,
             will use all available files. Useful when reading
             from many files is bottlenecking dataloading.
-
-
-    """
+    """  # noqa E501
 
     def __init__(
         self,
@@ -117,7 +114,7 @@ class Hdf5TimeSeriesDataset(torch.utils.data.IterableDataset):
         return self.batches_per_epoch
 
     def sample_fnames(self, size) -> np.ndarray:
-        # first, randomly select `self.num_files_per_batch`
+        # first, randomly select ``self.num_files_per_batch``
         # file indices based on their probabilities
         fname_indices = np.arange(len(self.fnames))
         fname_indices = np.random.choice(

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/dataloading/in_memory_dataset.py

@@ -20,56 +20,56 @@ class InMemoryDataset(torch.utils.data.IterableDataset):
     Args:
         X:
             Timeseries data to be iterated through. Should have
-            shape `(num_channels, length * sample_rate)`. Windows
+            shape ``(num_channels, length * sample_rate)``. Windows
             will be sampled from the time (1st) dimension for all
             channels along the channel (0th) dimension.
         kernel_size:
-            The length of the windows to sample from `X` in units
+            The length of the windows to sample from ``X`` in units
             of samples.
         y:
             Target timeseries to be iterated through. If specified,
             should be a single channel and have shape
-            `(length * sample_rate,)`. If left as `None`, only windows
-            sampled from `X` will be returned during iteration.
+            ``(length * sample_rate,)``. If left as ``None``, only windows
+            sampled from ``X`` will be returned during iteration.
             Otherwise, windows sampled from both arrays will be
             returned. Note that if sampling is performed non-coincidentally,
             there's no sensible way to align windows sampled from this
-            array with the windows sampled from `X`, so this combination
+            array with the windows sampled from ``X``, so this combination
             of arguments is not permitted.
         batch_size:
             Maximum number of windows to return at each iteration. Will
             be the length of the 0th dimension of the returned array(s).
-            If `batches_per_epoch` is specified, this will be the length
-            of _every_ array returned during iteration. Otherwise, it's
+            If ``batches_per_epoch`` is specified, this will be the length
+            of **every** array returned during iteration. Otherwise, it's
             possible that the last array will be shorter due to the number
             of windows in the timeseries being a non-integer multiple of
-            `batch_size`.
+            ``batch_size``.
         stride:
             The resolution at which windows will be sampled from the
             specified timeseries, in units of samples. E.g. if
-            `stride=2`, the first sample of each window can only be
-            from an index of `X` which is a multiple of 2. Obviously,
+            ``stride=2``, the first sample of each window can only be
+            from an index of ``X`` which is a multiple of 2. Obviously,
             this reduces the number of windows which can be iterated
-            through by a factor of `stride`.
+            through by a factor of ``stride``.
         batches_per_epoch:
             Number of batches of window to produce during iteration
-            before raising a `StopIteration`. Must be specified if
+            before raising a ``StopIteration``. Must be specified if
             performing non-coincident sampling. Otherwise, if left
-            as `None`, windows will be sampled until the entire
+            as ``None``, windows will be sampled until the entire
             timeseries has been exhausted. Note that
-            `batch_size * batches_per_epoch` must be be small
+            ``batch_size * batches_per_epoch`` must be be small
             enough to be able to be fulfilled by the number of
-            windows in the timeseries, otherise a `ValueError`
+            windows in the timeseries, otherise a ``ValueError``
             will be raised.
         coincident:
-            Whether to sample windows from the channels of `X`
+            Whether to sample windows from the channels of ``X``
             using the same indices or independently. Can't be
-            `True` if `batches_per_epoch` is `None` or `y` is
-            _not_ `None`.
+            ``True`` if ``batches_per_epoch`` is ``None`` or ``y`` is
+            **not** ``None``.
         shuffle:
             Whether to sample windows from timeseries randomly
-            or in order along the time axis. If `coincident=False`
-            and `shuffle=False`, channels will be iterated through
+            or in order along the time axis. If ``coincident=False``
+            and ``shuffle=False``, channels will be iterated through
             with the index along the last channel moving fastest.
         device:
             Which device to host the timeseries arrays on
@@ -91,7 +91,7 @@ class InMemoryDataset(torch.utils.data.IterableDataset):
 
         # make sure if we specified a target array that all other
         # other necessary conditions are met (it has the same
-        # length as `X` and we're sampling coincidentally)
+        # length as ``X`` and we're sampling coincidentally)
         if y is not None and y.shape[-1] != X.shape[-1]:
             raise ValueError(
                 "Target timeseries must have same length as input"

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/distributions.py

@@ -1,7 +1,7 @@
 """
 Module containing callables classes for generating samples
 from specified distributions. Each callable should map from
-an integer `N` to a 1D torch `Tensor` containing `N` samples
+an integer ``N`` to a 1D torch ``Tensor`` containing ``N`` samples
 from the corresponding distribution.
 """
 
@@ -22,8 +22,9 @@ _PLANCK18_OMEGA_M = 0.30966  # Matter density parameter
 class Cosine(dist.Distribution):
     """
     Cosine distribution based on
-    ``torch.distributions.TransformedDistribution``.
-    """
+    ``torch.distributions.TransformedDistribution``
+    (see `documentation <https://docs.pytorch.org/docs/stable/distributions.html#transformeddistribution>`_).
+    """  # noqa E501
 
     arg_constraints = {}
 
@@ -117,18 +118,17 @@ class LogNormal(dist.LogNormal):
 class PowerLaw(dist.TransformedDistribution):
     """
     Sample from a power law distribution,
-    .. math::
-        p(x) \approx x^{\alpha}.
+
+    .. math:: p(x) \\approx x^{\\alpha}.
 
     Index alpha cannot be 0, since it is equivalent to a Uniform distribution.
     This could be used, for example, as a universal distribution of
     signal-to-noise ratios (SNRs) from uniformly volume distributed
     sources
-    .. math::
 
-       p(\rho) = 3*\rho_0^3 / \rho^4
+    .. math:: p(\\rho) = 3\;\\rho_0^3 / \\rho^4
 
-    where :math:`\rho_0` is a representative minimum SNR
+    where :math:`\\rho_0` is a representative minimum SNR
     considered for detection. See, for example,
     `Schutz (2011) <https://arxiv.org/abs/1102.5421>`_.
     Or, for example, ``index=2`` for uniform in Euclidean volume.
@@ -137,10 +137,10 @@ class PowerLaw(dist.TransformedDistribution):
     support = dist.constraints.nonnegative
 
     def __init__(
-        self, minimum: float, maximum: float, index: int, validate_args=None
+        self, minimum: float, maximum: float, index: float, validate_args=None
     ):
         if index == 0:
-            raise RuntimeError("Index of 0 is the same as Uniform")
+            raise ValueError("Index of 0 is the same as Uniform")
         elif index == -1:
             base_min = torch.as_tensor(minimum).log()
             base_max = torch.as_tensor(maximum).log()
@@ -185,14 +185,14 @@ class UniformComovingVolume(dist.Distribution):
     Sample either redshift, comoving distance, or luminosity distance
     such that they are uniform in comoving volume, assuming a flat
     lambda-CDM cosmology. Default H0 and Omega_M values match
-    astropy.cosmology.Planck18
+    `Planck18 parameters in Astropy <https://docs.astropy.org/en/latest/api/astropy.cosmology.realizations.Planck18.html>`_.
 
     Args:
         minimum: Minimum distance in the specified distance type
         maximum: Maximum distance in the specified distance type
         distance_type:
-            Type of distance to sample from. Can be 'redshift',
-            'comoving_distance', or 'luminosity_distance'
+            Type of distance to sample from. Can be ``redshift``,
+            ``comoving_distance``, or ``luminosity_distance``
         h0: Hubble constant in km/s/Mpc
         omega_m: Matter density parameter
         z_max: Maximum redshift for the grid
@@ -347,18 +347,20 @@ class UniformComovingVolume(dist.Distribution):
 
 class RateEvolution(UniformComovingVolume):
     """
-    Wrapper around `UniformComovingVolume` to allow for
+    Wrapper around :meth:`~ml4gw.distributions.UniformComovingVolume` to allow for
     arbitrary rate evolution functions. E.g., if
-    `rate_function = 1 / (1 + z)`, then the distribution
+    ``rate_function = lambda z: 1 / (1 + z)``, then the distribution
     will sample values such that they occur uniform in
     source frame time.
 
     Args:
         rate_function: Callable that takes redshift as input
             and returns the rate evolution factor.
-        *args, **kwargs: Arguments passed to `UniformComovingVolume`
-            constructor.
-    """
+        *args: Arguments passed to
+            :meth:`~ml4gw.distributions.UniformComovingVolume` constructor.
+        **kwargs: Keyword arguments passed to
+            :meth:`~ml4gw.distributions.UniformComovingVolume` constructor.
+    """  # noqa E501
 
     def __init__(
         self,

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/gw.py

@@ -2,13 +2,11 @@
 Tools for manipulating raw gravitational waveforms
 and projecting them onto interferometer responses.
 Much of the projection code is an extension of the
-implementation made available in bilby:
-
-https://arxiv.org/abs/1811.02042
-
-Specifically the code here:
-https://github.com/lscsoft/bilby/blob/master/bilby/gw/detector/interferometer.py
-"""
+implementation made available in
+`bilby <https://arxiv.org/abs/1811.02042>`_.
+Specifically code from
+`this module <https://github.com/lscsoft/bilby/blob/master/bilby/gw/detector/interferometer.py>`_.
+"""  # noqa E501
 
 from typing import List, Tuple, Union
 
@@ -134,6 +132,9 @@ def compute_antenna_responses(
     # shape: batch x num_polarizations x 3 x 3
     polarization = torch.stack(polarizations, axis=1)
 
+    # Ensure dtype consistency before einsum
+    detector_tensors = detector_tensors.to(polarization.dtype)
+
     # compute the weight of each interferometer's response
     # to each polarization: batch x polarizations x ifos
     return torch.einsum("...jk,ijk->...i", polarization, detector_tensors)
@@ -194,7 +195,7 @@ def compute_observed_strain(
     **polarizations: Float[Tensor, "batch time"],
 ) -> WaveformTensor:
     """
-    Compute the strain timeseries $h(t)$ observed by a network
+    Compute the strain timeseries :math:`h(t)` observed by a network
     of interferometers from the given polarization timeseries
     corresponding to gravitational waveforms from sources with
     the indicated sky parameters.
@@ -222,13 +223,13 @@ def compute_observed_strain(
             between the waveform observed at the geocenter and
             the one observed at the detector site. To avoid
             adding any delay between the two, reset your coordinates
-            such that the desired interferometer is at `(0., 0., 0.)`.
+            such that the desired interferometer is at ``(0., 0., 0.)``.
         sample_rate:
             Rate at which the polarization timeseries have been sampled
         polarziations:
             Timeseries for each waveform polarization which
             contributes to the interferometer response. Allowed
-            polarizations are `cross`, `plus`, and `breathing`.
+            polarizations are ``cross``, ``plus``, and ``breathing``.
     Returns:
         Tensor representing the observed strain at each
         interferometer for each waveform.
@@ -236,13 +237,15 @@ def compute_observed_strain(
 
     # TODO: just use theta as the input parameter?
     # note that ** syntax is ordered, so we're safe
-    # to be lazy and use `list` for the keys and values
+    # to be lazy and use ``list`` for the keys and values
     theta = torch.pi / 2 - dec
     antenna_responses = compute_antenna_responses(
         theta, psi, phi, detector_tensors, list(polarizations)
     )
 
     polarizations = torch.stack(list(polarizations.values()), axis=1)
+    # Ensure dtype consistency before einsum
+    antenna_responses = antenna_responses.to(polarizations.dtype)
     waveforms = torch.einsum(
         "...pi,...pt->...it", antenna_responses, polarizations
     )
@@ -286,26 +289,28 @@ def compute_ifo_snr(
     highpass: Union[float, Float[Tensor, " frequency"], None] = None,
     lowpass: Union[float, Float[Tensor, " frequency"], None] = None,
 ) -> Float[Tensor, "batch num_ifos"]:
-    r"""Compute the SNRs of a batch of interferometer responses
+    """Compute the SNRs of a batch of interferometer responses
 
     Compute the signal to noise ratio (SNR) of individual
     interferometer responses to gravitational waveforms with
     respect to a background PSD for each interferometer. The
-    SNR of the $i$th waveform at the $j$th interferometer
+    SNR of the :math:`i` th waveform at the :math:`j` th interferometer
     is computed as:
 
-    $$\rho_{ij} =
-        4 \int_{f_{\text{min}}}^{f_{\text{max}}}
-        \frac{\tilde{h_{ij}}(f)\tilde{h_{ij}}^*(f)}
-        {S_n^{(j)}(f)}df$$
+    .. math::
 
-    Where $f_{\text{min}}$ is a minimum frequency denoted
-    by `highpass`, `f_{\text{max}}` is the maximum frequency
-    denoted by `lowpass`, which defaults to the Nyquist frequency
-    dictated by `sample_rate`; `\tilde{h_{ij}}` and `\tilde{h_{ij}}*`
-    indicate the fourier transform of the $i$th waveform at
-    the $j$th inteferometer and its complex conjugate, respectively;
-    and $S_n^{(j)}$ is the backround PSD at the $j$th interferometer.
+        \\rho_{ij} =
+        4 \\int_{f_{\\text{min}}}^{f_{\\text{max}}}
+        \\frac{\\tilde{h_{ij}}(f)\\tilde{h_{ij}}^*(f)}
+        {S_n^{(j)}(f)}df
+
+    Where :math:`f_{\\text{min}}` is a minimum frequency denoted
+    by ``highpass``, :math:`f_{\\text{max}}` is the maximum frequency
+    denoted by ``lowpass``, which defaults to the Nyquist frequency
+    dictated by ``sample_rate``; :math:`\\tilde{h}_{ij}` and :math:`\\tilde{h}_{ij}^*`
+    indicate the fourier transform of the :math:`i` th waveform at
+    the :math:`j` th inteferometer and its complex conjugate, respectively;
+    and :math:`S_n^{(j)}` is the backround PSD at the :math:`j` th interferometer.
 
     Args:
         responses:
@@ -314,12 +319,12 @@ def compute_ifo_snr(
         psd:
             The one-sided power spectral density of the background
             noise at each interferometer to which a response
-            in `responses` has been calculated. If 2D, each row of
-            `psd` will be assumed to be the background PSD for each
-            channel of _every_ batch element in `responses`. If 3D,
+            in ``responses`` has been calculated. If 2D, each row of
+            ``psd`` will be assumed to be the background PSD for each
+            channel of _every_ batch element in ``responses``. If 3D,
             this should contain a background PSD for each channel
-            of each element in `responses`, and therefore the first
-            two dimensions of `psd` and `responses` should match.
+            of each element in ``responses``, and therefore the first
+            two dimensions of ``psd`` and ``responses`` should match.
         sample_rate:
             The frequency at which the waveform responses timeseries
             have been sampled. Upon fourier transforming, should
@@ -329,18 +334,18 @@ def compute_ifo_snr(
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out low frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies up to `lowpass`
+            left as ``None``, all frequencies up to ``lowpass``
             will contribute to the SNR calculation.
         lowpass:
             The maximum frequency below which to compute the SNR.
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out high frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies from `highpass` up to
+            left as ``None``, all frequencies from ``highpass`` up to
             the Nyquist freqyency will contribute to the SNR calculation.
     Returns:
         Batch of SNRs computed for each interferometer
-    """
+    """  # noqa E501
 
     # TODO: should we do windowing here?
     # compute frequency power, upsampling precision so that
@@ -388,10 +393,10 @@ def compute_ifo_snr(
     # that the user specify the sample rate by taking the
     # fft as-is (without dividing by sample rate) and then
     # taking the mean here (or taking the sum and dividing
-    # by the sum of `highpass` if it's a mask). If we want
+    # by the sum of ``highpass`` if it's a mask). If we want
     # to allow the user to pass a float for highpass, we'll
     # need the sample rate to compute the mask, but if we
-    # replace this with a `mask` argument instead we're in
+    # replace this with a ``mask`` argument instead we're in
     # the clear
     df = sample_rate / responses.shape[-1]
     integrated = integrand.sum(axis=-1) * df
@@ -408,15 +413,17 @@ def compute_network_snr(
     highpass: Union[float, Float[Tensor, " frequency"], None] = None,
     lowpass: Union[float, Float[Tensor, " frequency"], None] = None,
 ) -> BatchTensor:
-    r"""
+    """
     Compute the total SNR from a gravitational waveform
     from a network of interferometers. The total SNR for
-    the $i$th waveform is computed as
+    the :math:`i` th waveform is computed as
+
+    .. math::
 
-    $$\rho_i = \sqrt{\sum_{j}^{N}\rho_{ij}^2}$$
+        \\rho_i = \\sqrt{\\sum_{j}^{N}\\rho_{ij}^2}
 
-    where \rho_{ij} is the SNR for the $i$th waveform at
-    the $j$th interferometer in the network and $N$ is
+    where :math:`\\rho_{ij}` is the SNR for the :math:`i` th waveform at
+    the :math:`j` th interferometer in the network and :math:`N` is
     the total number of interferometers.
 
     Args:
@@ -426,12 +433,12 @@ def compute_network_snr(
         backgrounds:
             The one-sided power spectral density of the background
             noise at each interferometer to which a response
-            in `responses` has been calculated. If 2D, each row of
-            `psd` will be assumed to be the background PSD for each
-            channel of _every_ batch element in `responses`. If 3D,
+            in ``responses`` has been calculated. If 2D, each row of
+            ``psd`` will be assumed to be the background PSD for each
+            channel of **every** batch element in ``responses``. If 3D,
             this should contain a background PSD for each channel
-            of each element in `responses`, and therefore the first
-            two dimensions of `psd` and `responses` should match.
+            of each element in ``responses``, and therefore the first
+            two dimensions of ``psd`` and ``responses`` should match.
         sample_rate:
             The frequency at which the waveform responses timeseries
             have been sampled. Upon fourier transforming, should
@@ -441,14 +448,14 @@ def compute_network_snr(
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out low frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies up to `sample_rate / 2`
+            left as ``None``, all frequencies up to ``sample_rate / 2``
             will contribute to the SNR calculation.
         lowpass:
             The maximum frequency below which to compute the SNR.
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out high frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies from `highpass` up to
+            left as ``None``, all frequencies from ``highpass`` up to
             the Nyquist freqyency will contribute to the SNR calculation.
     Returns:
         Batch of SNRs for each waveform across the interferometer network
@@ -478,12 +485,12 @@ def reweight_snrs(
         psd:
             The one-sided power spectral density of the background
             noise at each interferometer to which a response
-            in `responses` has been calculated. If 2D, each row of
-            `psd` will be assumed to be the background PSD for each
-            channel of _every_ batch element in `responses`. If 3D,
+            in ``responses`` has been calculated. If 2D, each row of
+            ``psd`` will be assumed to be the background PSD for each
+            channel of **every** batch element in ``responses``. If 3D,
             this should contain a background PSD for each channel
-            of each element in `responses`, and therefore the first
-            two dimensions of `psd` and `responses` should match.
+            of each element in ``responses``, and therefore the first
+            two dimensions of ``psd`` and ``responses`` should match.
         sample_rate:
             The frequency at which the waveform responses timeseries
             have been sampled. Upon fourier transforming, should
@@ -493,14 +500,14 @@ def reweight_snrs(
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out low frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies up to `sample_rate / 2`
+            left as ``None``, all frequencies up to ``sample_rate / 2``
             will contribute to the SNR calculation.
         lowpass:
             The maximum frequency below which to compute the SNR.
             If a tensor is provided, it will be assumed to be a
             pre-computed mask used to 0-out high frequency components.
             If a float, it will be used to compute such a mask. If
-            left as `None`, all frequencies from `highpass` up to
+            left as ``None``, all frequencies from ``highpass`` up to
             the Nyquist freqyency will contribute to the SNR calculation.
     Returns:
         Rescaled interferometer responses

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/nn/autoencoder/base.py

@@ -12,18 +12,18 @@ class Autoencoder(torch.nn.Module):
     Base autoencoder class that defines some of the
     basic methods and functionality. Autoencoders are
     defined here as a set of sequential blocks that
-    have an `encode` method, which acts on the input
-    data to the autoencoder, and a `decode` method, which
-    acts on the encoded vector generated by the `encode`
-    method. `forward` just runs these steps one after the
+    have an ``encode`` method, which acts on the input
+    data to the autoencoder, and a ``decode`` method, which
+    acts on the encoded vector generated by the ``encode``
+    method. ``forward`` just runs these steps one after the
     other. Although it isn't explicitly enforced, a good
-    rule of thumb is that the ouput of a block's `decode`
+    rule of thumb is that the ouput of a block's ``decode``
     method should have the same shape as the _input_ of its
-    `encode` method.
+    ``encode`` method.
 
-    Accepts a `skip_connection` argument that defines how to
-    combine information from the input of one block's `encode`
-    layer with the output to its `decode`layer. See `skip_connections.py`
+    Accepts a ``skip_connection`` argument that defines how to
+    combine information from the input of one block's ``encode``
+    layer with the output to its ``decode`` layer. See ``skip_connections.py``
     for more info about what these classes are expected to contain
     and how they operate.
     """

{ml4gw-0.7.5 → ml4gw-0.7.7}/ml4gw/nn/autoencoder/convolutional.py

@@ -83,11 +83,11 @@ class ConvolutionalAutoencoder(Autoencoder):
     match the shape of the input to its corresponding
     encoder layer, except for the last decoder which
     can have an arbitrary number of channels specified
-    by `decode_channels`.
+    by ``decode_channels``.
 
-    All layers also share the same `activation` except
+    All layers also share the same ``activation`` except
     for the last decoder layer, which can have an
-    arbitrary `output_activation`.
+    arbitrary ``output_activation``.
     """
 
     def __init__(
@@ -115,7 +115,7 @@ class ConvolutionalAutoencoder(Autoencoder):
             # All intermediate layers should decode to
             # the same number of channels. The last decoder
             # should decode to whatever number of channels
-            # was specified, even if it's `None` (in which
+            # was specified, even if it's ``None`` (in which
             # case it will just be in_channels anyway)
             decode = in_channels if i else decode_channels