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

ml4gw/distributions.py

@@ -137,7 +137,7 @@ 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 ValueError("Index of 0 is the same as Uniform")

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/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
@@ -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,13 +276,10 @@ 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"]:
@@ -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(

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,6 +160,271 @@ class SplineInterpolate(torch.nn.Module):
 
         return b[:, :, -1]
 
+
+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
@@ -285,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(
@@ -317,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(
@@ -330,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
@@ -353,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-0.7.6.dist-info → ml4gw-0.7.7.dist-info}/METADATA

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: ml4gw
-Version: 0.7.6
+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.6.dist-info → ml4gw-0.7.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ml4gw/__init__.py,sha256=81quoggCuIypZjZs3bbf1Ty70KHdva5RGEJxi0oC57E,25
 ml4gw/augmentations.py,sha256=4tSWO-I4Eg2QJWzdcLFg9QcOLlvRjNHvnjLCZS8K-Wc,1270
 ml4gw/constants.py,sha256=RQPXwavlw_cWu3ByltvTejPsi6EWXHDJQ1HaV9iE3Lg,850
-ml4gw/distributions.py,sha256=T6H1r5IMWyO38Uyb-BpmYx0AcokWN_ZJHGo-G_20m6w,12830
+ml4gw/distributions.py,sha256=B3heOf_x-71UJBExkmaiqBfjTHiGDds_bYo62wydddU,12832
 ml4gw/gw.py,sha256=bJ-GCZxanqrhbm373h9muOSZpam7wM-dJBZroy_pVNQ,20291
 ml4gw/spectral.py,sha256=Mx_zRjZ9tD7N-wknv35oA3fk2X0rDJxQdQzRyuCFryw,19982
 ml4gw/types.py,sha256=CcctqDcNajR7khGT6BD-WYsfRKpiP0udoSAB0k1qcFw,863
@@ -22,15 +22,15 @@ ml4gw/nn/resnet/resnet_2d.py,sha256=MAbXtkSrP4aWGtY-QC8ox3-y5jDHJrzRPL5ryQ4RBvM,
 ml4gw/nn/streaming/__init__.py,sha256=zgjGR2L8t0txXLnil9ceZT0tM8Y2FC8yPxqIKYH0o1A,80
 ml4gw/nn/streaming/online_average.py,sha256=YSFUHhwNfQjUJbzQCqaCVApSueswzYB4yel981Omiqw,4718
 ml4gw/nn/streaming/snapshotter.py,sha256=vEQLFi-fEH-o7TO9SmYXy5whxFxXQBDeOQOFhSnofSg,4503
-ml4gw/transforms/__init__.py,sha256=OaTQJD4GFkDkcxt0DIwt2AzeEcv9t21ciKXxQnqDiuI,447
+ml4gw/transforms/__init__.py,sha256=sREcTsJYPOHBk_QEvhlwvLeoR61Th8LVGaBicWngmv4,470
 ml4gw/transforms/iirfilter.py,sha256=HcdsjcSaSi2xe65ojxnaqeSdbYvSQVFIkHKon3nW238,3194
 ml4gw/transforms/pearson.py,sha256=sFyHD6IdskbRS8V1fY0Kt9N8R2_EhnuL6UjFa6fnmTU,3244
-ml4gw/transforms/qtransform.py,sha256=dXE3Genxgg3UdQ5dM-FfcvbX--UGpr0hjX9sO5tpM7k,20754
+ml4gw/transforms/qtransform.py,sha256=2GtPyY5DPhoUMDs68juLIzmxbelfsS4CpI0HyTPe3Oo,20636
 ml4gw/transforms/scaler.py,sha256=BKn4RQ_TNArdwPI_j5nAe7H2jOH_-MrZPsNByE-8Pl8,2518
 ml4gw/transforms/snr_rescaler.py,sha256=lfuwdwMY117gB-emmn0_22gsK_A9xnkHJv2-76HFWc4,2728
 ml4gw/transforms/spectral.py,sha256=ebAuPSdQqha6J3MMzxqJqR31XPKUDrSz3iJaHM3orpk,4449
 ml4gw/transforms/spectrogram.py,sha256=NIyTD8kZRe8rjMUTy1_-wpFyvAswzTfYwD4TJJcPqgs,6369
-ml4gw/transforms/spline_interpolation.py,sha256=iz6CkRzAYFSMjRTLFJAetE5FAI6WmrpfKzMPK4sueNQ,13320
+ml4gw/transforms/spline_interpolation.py,sha256=_D_P2jNIOL8-XiSSjsGClxuVwthO-CxcoqNwvrBWQpk,18668
 ml4gw/transforms/transform.py,sha256=lpHQbM4PhdijvNBsZigPX-mS04aiVVq5q3HMfxvpFg0,2506
 ml4gw/transforms/waveforms.py,sha256=koWOuHuUpQWmTT1yawSWa_MOuLfDBuugy91KIyuklOo,3189
 ml4gw/transforms/whitening.py,sha256=UyFustRhu3zv0ynJBvvxekWA-YOMwEIOYDNpoD5r_qQ,10400
@@ -49,7 +49,8 @@ ml4gw/waveforms/cbc/phenom_d_data.py,sha256=WA1FBxUp9fo1IQaV_OLJ_5g5gI166mY1FtG9
 ml4gw/waveforms/cbc/phenom_p.py,sha256=tOUBoYfr0ub6OGRjDQbquGoW8AnThiGjJvbHhyGnAnk,27680
 ml4gw/waveforms/cbc/taylorf2.py,sha256=emWbl3vjsCzBOooHOVO7pPlPcj05r4up6InlMkO5m_E,10422
 ml4gw/waveforms/cbc/utils.py,sha256=LT1ky10_6ZrbwTcxIrWP1O75GUEuU5q2ZE2yYDhadQE,3037
-ml4gw-0.7.6.dist-info/METADATA,sha256=dI3qI2Kk4p-XP_hPs7QWPfgjzRGQMcIva-ST6mBdA0A,3380
-ml4gw-0.7.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ml4gw-0.7.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ml4gw-0.7.6.dist-info/RECORD,,
+ml4gw-0.7.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ml4gw-0.7.7.dist-info/METADATA,sha256=C3IsV7-AGBWfid4FvE1xuGL0HFX_wzRii0Wzb4aSOiM,3402
+ml4gw-0.7.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ml4gw-0.7.7.dist-info/top_level.txt,sha256=JnWLyPXJ3_WUcjr6fRV0ZTXj8FR0x4vBzjkg-1bl2tw,6
+ml4gw-0.7.7.dist-info/RECORD,,

{ml4gw-0.7.6.dist-info → ml4gw-0.7.7.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

ml4gw-0.7.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+ml4gw