ml4gw 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ml4gw/waveforms/phenom_p.py

@@ -1,9 +1,12 @@
 from typing import Dict, Tuple
 
 import torch
-from torchtyping import TensorType
+from jaxtyping import Float
+from torch import Tensor
+
+from ml4gw.constants import MPC_SEC, MTSUN_SI, PI
+from ml4gw.types import BatchTensor, FrequencySeries1d
 
-from ..constants import MPC_SEC, MTSUN_SI, PI
 from .phenom_d import IMRPhenomD
 
 
@@ -13,19 +16,19 @@ class IMRPhenomPv2(IMRPhenomD):
 
     def forward(
         self,
-        fs: TensorType,
-        chirp_mass: TensorType,
-        mass_ratio: TensorType,
-        s1x: TensorType,
-        s1y: TensorType,
-        s1z: TensorType,
-        s2x: TensorType,
-        s2y: TensorType,
-        s2z: TensorType,
-        dist_mpc: TensorType,
-        tc: TensorType,
-        phiRef: TensorType,
-        incl: TensorType,
+        fs: FrequencySeries1d,
+        chirp_mass: BatchTensor,
+        mass_ratio: BatchTensor,
+        s1x: BatchTensor,
+        s1y: BatchTensor,
+        s1z: BatchTensor,
+        s2x: BatchTensor,
+        s2y: BatchTensor,
+        s2z: BatchTensor,
+        dist_mpc: BatchTensor,
+        tc: BatchTensor,
+        phiRef: BatchTensor,
+        incl: BatchTensor,
         f_ref: float,
     ):
         """
@@ -184,18 +187,18 @@ class IMRPhenomPv2(IMRPhenomD):
 
     def PhenomPCoreTwistUp(
         self,
-        fHz: TensorType,
-        hPhenom: TensorType,
-        eta: TensorType,
-        chi1_l: TensorType,
-        chi2_l: TensorType,
-        chip: TensorType,
-        M: TensorType,
-        angcoeffs: Dict[str, TensorType],
-        Y2m: TensorType,
-        alphaoffset: TensorType,
-        epsilonoffset: TensorType,
-    ) -> Tuple[TensorType, TensorType]:
+        fHz: FrequencySeries1d,
+        hPhenom: BatchTensor,
+        eta: BatchTensor,
+        chi1_l: BatchTensor,
+        chi2_l: BatchTensor,
+        chip: BatchTensor,
+        M: BatchTensor,
+        angcoeffs: Dict[str, BatchTensor],
+        Y2m: BatchTensor,
+        alphaoffset: BatchTensor,
+        epsilonoffset: BatchTensor,
+    ) -> Tuple[BatchTensor, BatchTensor]:
         assert angcoeffs is not None
         assert Y2m is not None
         f = fHz * MTSUN_SI * M.unsqueeze(1)  # Frequency in geometric units
@@ -354,8 +357,11 @@ class IMRPhenomPv2(IMRPhenomD):
     # Utility functions
 
     def interpolate(
-        self, x: TensorType, xp: TensorType, fp: TensorType
-    ) -> TensorType:
+        self,
+        x: Float[Tensor, " new_series"],
+        xp: Float[Tensor, " series"],
+        fp: Float[Tensor, " series"],
+    ) -> Float[Tensor, " new_series"]:
         """One-dimensional linear interpolation for monotonically
         increasing sample points.
 
@@ -385,7 +391,7 @@ class IMRPhenomPv2(IMRPhenomD):
 
         return interpolated.reshape(original_shape)
 
-    def ROTATEZ(self, angle: TensorType, x, y, z):
+    def ROTATEZ(self, angle: BatchTensor, x, y, z):
         tmp_x = x * torch.cos(angle) - y * torch.sin(angle)
         tmp_y = x * torch.sin(angle) + y * torch.cos(angle)
         return tmp_x, tmp_y, z
@@ -395,7 +401,11 @@ class IMRPhenomPv2(IMRPhenomD):
         tmp_z = -x * torch.sin(angle) + z * torch.cos(angle)
         return tmp_x, y, tmp_z
 
-    def L2PNR(self, v: TensorType, eta: TensorType) -> TensorType:
+    def L2PNR(
+        self,
+        v: BatchTensor,
+        eta: BatchTensor,
+    ) -> BatchTensor:
         eta2 = eta**2
         x = v**2
         x2 = x**2
@@ -412,25 +422,25 @@ class IMRPhenomPv2(IMRPhenomD):
 
     def convert_spins(
         self,
-        m1: TensorType,
-        m2: TensorType,
+        m1: BatchTensor,
+        m2: BatchTensor,
         f_ref: float,
-        phiRef: TensorType,
-        incl: TensorType,
-        s1x: TensorType,
-        s1y: TensorType,
-        s1z: TensorType,
-        s2x: TensorType,
-        s2y: TensorType,
-        s2z: TensorType,
+        phiRef: BatchTensor,
+        incl: BatchTensor,
+        s1x: BatchTensor,
+        s1y: BatchTensor,
+        s1z: BatchTensor,
+        s2x: BatchTensor,
+        s2y: BatchTensor,
+        s2z: BatchTensor,
     ) -> Tuple[
-        TensorType,
-        TensorType,
-        TensorType,
-        TensorType,
-        TensorType,
-        TensorType,
-        TensorType,
+        BatchTensor,
+        BatchTensor,
+        BatchTensor,
+        BatchTensor,
+        BatchTensor,
+        BatchTensor,
+        BatchTensor,
     ]:
         M = m1 + m2
         m1_2 = m1 * m1
@@ -591,8 +601,12 @@ class IMRPhenomPv2(IMRPhenomD):
                 )
 
     def WignerdCoefficients(
-        self, v: TensorType, SL: TensorType, eta: TensorType, Sp: TensorType
-    ) -> Tuple[TensorType, TensorType]:
+        self,
+        v: BatchTensor,
+        SL: BatchTensor,
+        eta: BatchTensor,
+        Sp: BatchTensor,
+    ) -> Tuple[BatchTensor, BatchTensor]:
         # We define the shorthand s := Sp / (L + SL)
         L = self.L2PNR(v, eta)
         s = (Sp / (L + SL)).mT
@@ -604,8 +618,11 @@ class IMRPhenomPv2(IMRPhenomD):
         return cos_beta_half, sin_beta_half
 
     def ComputeNNLOanglecoeffs(
-        self, q: TensorType, chil: TensorType, chip: TensorType
-    ) -> Dict[str, TensorType]:
+        self,
+        q: BatchTensor,
+        chil: BatchTensor,
+        chip: BatchTensor,
+    ) -> Dict[str, BatchTensor]:
         m2 = q / (1.0 + q)
         m1 = 1.0 / (1.0 + q)
         dm = m1 - m2
@@ -730,12 +747,12 @@ class IMRPhenomPv2(IMRPhenomD):
 
     def FinalSpin_inplane(
         self,
-        m1: TensorType,
-        m2: TensorType,
-        chi1_l: TensorType,
-        chi2_l: TensorType,
-        chip: TensorType,
-    ) -> TensorType:
+        m1: BatchTensor,
+        m2: BatchTensor,
+        chi1_l: BatchTensor,
+        chi2_l: BatchTensor,
+        chip: BatchTensor,
+    ) -> BatchTensor:
         M = m1 + m2
         eta = m1 * m2 / (M * M)
         eta2 = eta * eta
@@ -751,7 +768,7 @@ class IMRPhenomPv2(IMRPhenomD):
 
     def phP_get_fRD_fdamp(
         self, m1, m2, chi1_l, chi2_l, chip
-    ) -> Tuple[TensorType, TensorType]:
+    ) -> Tuple[BatchTensor, BatchTensor]:
         # m1 > m2 should hold here
         finspin = self.FinalSpin_inplane(m1, m2, chi1_l, chi2_l, chip)
         m1_s = m1 * MTSUN_SI
@@ -770,7 +787,7 @@ class IMRPhenomPv2(IMRPhenomD):
         ) / (1.0 - Erad)
         return fRD / M_s, fdamp / M_s
 
-    def get_Amp0(self, fM_s: TensorType, eta: TensorType) -> TensorType:
+    def get_Amp0(self, fM_s: BatchTensor, eta: BatchTensor) -> BatchTensor:
         Amp0 = (
             (2.0 / 3.0 * eta.unsqueeze(1)) ** (1.0 / 2.0)
             * (fM_s) ** (-7.0 / 6.0)

ml4gw/waveforms/ringdown.py

@@ -1,9 +1,8 @@
 import numpy as np
 import torch
 
-from ml4gw.types import ScalarTensor
-
-from ..constants import PI, C, G, m_per_Mpc
+from ml4gw.constants import PI, C, G, m_per_Mpc
+from ml4gw.types import BatchTensor
 
 
 class Ringdown(torch.nn.Module):
@@ -27,12 +26,12 @@ class Ringdown(torch.nn.Module):
 
     def forward(
         self,
-        frequency: ScalarTensor,
-        quality: ScalarTensor,
-        epsilon: ScalarTensor,
-        phase: ScalarTensor,
-        inclination: ScalarTensor,
-        distance: ScalarTensor,
+        frequency: BatchTensor,
+        quality: BatchTensor,
+        epsilon: BatchTensor,
+        phase: BatchTensor,
+        inclination: BatchTensor,
+        distance: BatchTensor,
     ):
         """
         Generate ringdown waveform based on the damped sinusoid equation.

ml4gw/waveforms/sine_gaussian.py

@@ -1,7 +1,7 @@
 import torch
 from torch import Tensor
 
-from ml4gw.types import ScalarTensor
+from ml4gw.types import BatchTensor
 
 
 def semi_major_minor_from_e(e: Tensor):
@@ -32,11 +32,11 @@ class SineGaussian(torch.nn.Module):
 
     def forward(
         self,
-        quality: ScalarTensor,
-        frequency: ScalarTensor,
-        hrss: ScalarTensor,
-        phase: ScalarTensor,
-        eccentricity: ScalarTensor,
+        quality: BatchTensor,
+        frequency: BatchTensor,
+        hrss: BatchTensor,
+        phase: BatchTensor,
+        eccentricity: BatchTensor,
     ):
         """
         Generate lalinference implementation of a sine-Gaussian waveform.

ml4gw/waveforms/taylorf2.py

@@ -1,8 +1,9 @@
 import torch
-from torchtyping import TensorType
+from jaxtyping import Float
 
-from ..constants import MPC_SEC, MTSUN_SI, PI
-from ..constants import EulerGamma as GAMMA
+from ml4gw.constants import MPC_SEC, MTSUN_SI, PI
+from ml4gw.constants import EulerGamma as GAMMA
+from ml4gw.types import BatchTensor, FrequencySeries1d
 
 
 class TaylorF2(torch.nn.Module):
@@ -11,14 +12,14 @@ class TaylorF2(torch.nn.Module):
 
     def forward(
         self,
-        f: TensorType,
-        chirp_mass: TensorType,
-        mass_ratio: TensorType,
-        chi1: TensorType,
-        chi2: TensorType,
-        distance: TensorType,
-        phic: TensorType,
-        inclination: TensorType,
+        f: FrequencySeries1d,
+        chirp_mass: BatchTensor,
+        mass_ratio: BatchTensor,
+        chi1: BatchTensor,
+        chi2: BatchTensor,
+        distance: BatchTensor,
+        phic: BatchTensor,
+        inclination: BatchTensor,
         f_ref: float,
     ):
         """
@@ -75,15 +76,15 @@ class TaylorF2(torch.nn.Module):
 
     def taylorf2_htilde(
         self,
-        f: TensorType,
-        mass1: TensorType,
-        mass2: TensorType,
-        chi1: TensorType,
-        chi2: TensorType,
-        distance: TensorType,
-        phic: TensorType,
+        f: FrequencySeries1d,
+        mass1: BatchTensor,
+        mass2: BatchTensor,
+        chi1: BatchTensor,
+        chi2: BatchTensor,
+        distance: BatchTensor,
+        phic: BatchTensor,
         f_ref: float,
-    ):
+    ) -> Float[FrequencySeries1d, " batch"]:
         mass1_s = mass1 * MTSUN_SI
         mass2_s = mass2 * MTSUN_SI
         M_s = mass1_s + mass2_s
@@ -103,8 +104,13 @@ class TaylorF2(torch.nn.Module):
         return h0
 
     def taylorf2_amplitude(
-        self, Mf: TensorType, mass1, mass2, eta, distance
-    ) -> TensorType:
+        self,
+        Mf: BatchTensor,
+        mass1: BatchTensor,
+        mass2: BatchTensor,
+        eta: BatchTensor,
+        distance: BatchTensor,
+    ) -> Float[FrequencySeries1d, " batch"]:
         mass1_s = mass1 * MTSUN_SI
         mass2_s = mass2 * MTSUN_SI
         v = (PI * Mf) ** (1.0 / 3.0)
@@ -126,12 +132,12 @@ class TaylorF2(torch.nn.Module):
 
     def taylorf2_phase(
         self,
-        Mf: TensorType,
-        mass1: TensorType,
-        mass2: TensorType,
-        chi1: TensorType,
-        chi2: TensorType,
-    ) -> TensorType:
+        Mf: BatchTensor,
+        mass1: BatchTensor,
+        mass2: BatchTensor,
+        chi1: BatchTensor,
+        chi2: BatchTensor,
+    ) -> Float[FrequencySeries1d, " batch"]:
         """
         Calculate the inspiral phase for the TaylorF2.
         """

{ml4gw-0.5.0.dist-info → ml4gw-0.5.1.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.1
 Name: ml4gw
-Version: 0.5.0
+Version: 0.5.1
 Summary: Tools for training torch models on gravitational wave data
 Author: Alec Gunny
 Author-email: alec.gunny@ligo.org
-Requires-Python: >=3.8,<3.12
+Requires-Python: >=3.8,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: jaxtyping (>=0.2,<0.3)
 Requires-Dist: numpy (<2.0.0)
 Requires-Dist: torch (>=2.0,<3.0)
 Requires-Dist: torchaudio (>=2.0,<3.0)
-Requires-Dist: torchtyping (>=0.1,<0.2)
 Description-Content-Type: text/markdown
 
 # ML4GW

ml4gw-0.5.1.dist-info/RECORD

@@ -0,0 +1,47 @@
+ml4gw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ml4gw/augmentations.py,sha256=pZH9tjEpXV0AIqvHHDkpUE-BorG02beOz2pmSipw2EY,1232
+ml4gw/constants.py,sha256=W9beA9RDRdIug1I2H7VLPEPv_DFsQWWoYRmzxv7FWgM,891
+ml4gw/dataloading/__init__.py,sha256=EHBBqU7y2-Np5iQ_xyufxamUEM1pPEquqFo7oaJnaJE,149
+ml4gw/dataloading/chunked_dataset.py,sha256=FpDc4gFxt-PMyXs5qSWLuTGXMTuS1B-hH8gUOCOGxZk,5260
+ml4gw/dataloading/hdf5_dataset.py,sha256=UB1Eog8l7m4M78Owst7oYQZICb0DRJer9WVLVn4hl_I,6645
+ml4gw/dataloading/in_memory_dataset.py,sha256=kleMA9ABUKA6J0tCdz78tbX9lM6uxVSLhqgHbSa1iWY,9550
+ml4gw/distributions.py,sha256=tUuaOiX5enjKLYWD7uiN8rdRVQcrIKps64xBkTl8fMs,4991
+ml4gw/gw.py,sha256=To_hQz9tUp02ADllGLxFCPsNcfbb-kbvfgGpooxcOII,17693
+ml4gw/nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ml4gw/nn/autoencoder/__init__.py,sha256=ZaT1XhJTHpMuPQqu5E__Jezeh9uwtjcXlT7IZ18byq4,161
+ml4gw/nn/autoencoder/base.py,sha256=4d5Ej30IUzZh3XbldzWlCpp3p0_91YUvKeRID8ZEZGA,3225
+ml4gw/nn/autoencoder/convolutional.py,sha256=2BXDuPWYC-151RO_FL0ogdrqSVTfo4YNrY80lPwrmFA,5419
+ml4gw/nn/autoencoder/skip_connection.py,sha256=fpXxxIIl0CXY4mAfUZQuvI542pEBSwpg90TNG2rbZY8,1411
+ml4gw/nn/autoencoder/utils.py,sha256=m_ivYGNwdrhA7cFxJVD4gqM8AHiWIGmlQI3pFNRklXQ,355
+ml4gw/nn/norm.py,sha256=JIOMXQbUtoWlrhncGsqW6f1-DiGDx9zQH2O3CvQml3U,3594
+ml4gw/nn/resnet/__init__.py,sha256=vBI0IftVP_EYAeDlqomtkGqUYE-RE_S4WNioUhniw9s,64
+ml4gw/nn/resnet/resnet_1d.py,sha256=IQ-EIIzAXd-NWuLwt7JTXLWg5bO3FGJpuFAZwZ78jaI,13218
+ml4gw/nn/resnet/resnet_2d.py,sha256=aK4I0FOZk62JxnYFz0t1O0s5s7J7yRNYSM1flRypvVc,13301
+ml4gw/nn/streaming/__init__.py,sha256=zgjGR2L8t0txXLnil9ceZT0tM8Y2FC8yPxqIKYH0o1A,80
+ml4gw/nn/streaming/online_average.py,sha256=aI8hkT7I3thXkda9tsXxYrzump9swelSXPdSTwPlJWY,4719
+ml4gw/nn/streaming/snapshotter.py,sha256=B9qtbHxnPszAHQ5WQppWJLRuMnnYIxGk7MRUlgja7Is,4476
+ml4gw/spectral.py,sha256=Mt3-yz4a83z0X7M1sVp00_vB947w-9OjU0iNdEkbQcU,19145
+ml4gw/transforms/__init__.py,sha256=24pdP_hIg1wfrtZxxRBPhcEXsCbvVKtNKp7JL8SEogE,362
+ml4gw/transforms/pearson.py,sha256=Ep3mMsY15AF55taRaWNjpHRTvtr1StShUDfqk0dN-qo,3235
+ml4gw/transforms/qtransform.py,sha256=umBSpykfmPftjfyMqbniiP2mTh62q4hoYPA55qneJ4o,17702
+ml4gw/transforms/scaler.py,sha256=fLZo-m6_yFY3UDoLEaS_YgCnYggxlcKstXcM7749TiU,2433
+ml4gw/transforms/snr_rescaler.py,sha256=3XXCTaXc2dzzpXRZx7iqRwImvYtRSJLM5fHdBGfpoUs,2351
+ml4gw/transforms/spectral.py,sha256=gTHUeC0gGYbzgBZHb_FxC_4zdhl5H-XCiLg1hrvKB70,4393
+ml4gw/transforms/spectrogram.py,sha256=HS3Rf5iB7JjhlSESRDdFGUwCtIBdvUaJUDulkB4Lmos,6162
+ml4gw/transforms/transform.py,sha256=BuzTbPFxp18OEGP9Tu9jBGtvqy3len1cqvqg5X37DiY,2512
+ml4gw/transforms/waveforms.py,sha256=LkYCvxPqYhHa2yYZTvPE6j0E4HFy16b5ndCRQb7WfcA,3196
+ml4gw/transforms/whitening.py,sha256=Aw_ogq93CYCATiHWBqSZ-qsUtaHAMA3k009ZRtQTtHA,9596
+ml4gw/types.py,sha256=CcctqDcNajR7khGT6BD-WYsfRKpiP0udoSAB0k1qcFw,863
+ml4gw/utils/interferometer.py,sha256=lRS0N3SwUTknhYXX57VACJ99jK1P9M19oUWN_i_nQN0,1814
+ml4gw/utils/slicing.py,sha256=ilRz_5sJzwmd5VyBlrj81tvyC3uCnXYjd0TO2fzFMr8,13563
+ml4gw/waveforms/__init__.py,sha256=dnxfRGX_B3zQPB3_3srLyjZXRxTn4miZqYIRe7PYyrU,170
+ml4gw/waveforms/generator.py,sha256=dO6RQ96EC87p2q0tEkxA62XkkJc1xARFO1SKcGvyDhM,1272
+ml4gw/waveforms/phenom_d.py,sha256=vA60SjOvWSIcsU83-KEw2hnU3ATo4eW8A2mMmuMXo7Y,46941
+ml4gw/waveforms/phenom_d_data.py,sha256=WA1FBxUp9fo1IQaV_OLJ_5g5gI166mY1FtG9n25he9U,53447
+ml4gw/waveforms/phenom_p.py,sha256=VybpPlc2_yMGywnPz5B79QAygAj-WAeHZTPiZHets28,26951
+ml4gw/waveforms/ringdown.py,sha256=m8IBQTxKBBGFqBtWGEO4KG3DEYR8TTnNyGVdVLaMKa8,3316
+ml4gw/waveforms/sine_gaussian.py,sha256=-MtrI7ydwBTk4K0O4tdkC8-w5OifQszdnWN9__I4XzY,3569
+ml4gw/waveforms/taylorf2.py,sha256=ySYLGTT_c3k4NzPDsQ9v822kzvU6TwYpELJEWlCDGQE,10428
+ml4gw-0.5.1.dist-info/METADATA,sha256=P2uoQtMX_K5SSwAzTY5tyNvWYszxaDADTS54iDOQYKw,5785
+ml4gw-0.5.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ml4gw-0.5.1.dist-info/RECORD,,

ml4gw-0.5.0.dist-info/RECORD

@@ -1,47 +0,0 @@
-ml4gw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ml4gw/augmentations.py,sha256=UEwNxdjzIQUqUgtAdrstptTZ73ay5sLc3imQY1DVUqs,1027
-ml4gw/constants.py,sha256=W9beA9RDRdIug1I2H7VLPEPv_DFsQWWoYRmzxv7FWgM,891
-ml4gw/dataloading/__init__.py,sha256=EHBBqU7y2-Np5iQ_xyufxamUEM1pPEquqFo7oaJnaJE,149
-ml4gw/dataloading/chunked_dataset.py,sha256=jy-y5xhMJqRZIA_pjrc4QHhqpAcpM9aJi2omT24riXY,5195
-ml4gw/dataloading/hdf5_dataset.py,sha256=D6cWBtF5_nox89SO4M9so2GDhkfkhdkc0EUpPhyvEyE,6643
-ml4gw/dataloading/in_memory_dataset.py,sha256=8bHOB7GreoLWcb_IYEQd2-BXfaYCO1EonD6MHFVPAzA,9429
-ml4gw/distributions.py,sha256=sTaiRkHEuNVP0l5qt3J3BlH1Xvow2RZWdua7LKIrddY,4922
-ml4gw/gw.py,sha256=RlG8Vj9GCcv0wpKWz9XlbRattls1A-FCCN1RiIhSE_w,17914
-ml4gw/nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ml4gw/nn/autoencoder/__init__.py,sha256=ZaT1XhJTHpMuPQqu5E__Jezeh9uwtjcXlT7IZ18byq4,161
-ml4gw/nn/autoencoder/base.py,sha256=PLr26Cn5DHmgDYX1qj4idfrLehHVeiJqer065ea8_QM,3098
-ml4gw/nn/autoencoder/convolutional.py,sha256=JTMpTJVdFju9HPPAh9UDdXG1MsFbADrqUIKM8_xg74E,5316
-ml4gw/nn/autoencoder/skip_connection.py,sha256=bOKBLzMqZDh9w8s9G5U93LCESjTSFUHzQGo0hLDOeSk,1304
-ml4gw/nn/autoencoder/utils.py,sha256=whTnWPvdKuVDlxg52azJeM1d9YjiYFWoqIOzJVDGups,326
-ml4gw/nn/norm.py,sha256=IQIiXDnKxzK-3BcA4UgHxLDmy_N89BTj-FENj9y4u7E,3447
-ml4gw/nn/resnet/__init__.py,sha256=vBI0IftVP_EYAeDlqomtkGqUYE-RE_S4WNioUhniw9s,64
-ml4gw/nn/resnet/resnet_1d.py,sha256=IQ-EIIzAXd-NWuLwt7JTXLWg5bO3FGJpuFAZwZ78jaI,13218
-ml4gw/nn/resnet/resnet_2d.py,sha256=aK4I0FOZk62JxnYFz0t1O0s5s7J7yRNYSM1flRypvVc,13301
-ml4gw/nn/streaming/__init__.py,sha256=zgjGR2L8t0txXLnil9ceZT0tM8Y2FC8yPxqIKYH0o1A,80
-ml4gw/nn/streaming/online_average.py,sha256=T-wWw7eEufbUVPRNnLAXIq0cedAyJWEE9tdZ6CTi3cs,4561
-ml4gw/nn/streaming/snapshotter.py,sha256=-l_YsWby7ZnEzGIAlLAV2mtR0daLMtLCxovtt4OI3Z0,4432
-ml4gw/spectral.py,sha256=5GfKAV_1vw5yyzTD2u_myjT5jIlAyAHDX6TXj9ynL_o,19021
-ml4gw/transforms/__init__.py,sha256=24pdP_hIg1wfrtZxxRBPhcEXsCbvVKtNKp7JL8SEogE,362
-ml4gw/transforms/pearson.py,sha256=bJ77lO4wBY6y1R1aESN_bcUEMbc55hWCIaCBdbIj4CY,3133
-ml4gw/transforms/qtransform.py,sha256=hvCzdGROLoW1nJYR_ZZWDnafJpX4kD1os3CZ2jQJ7IU,17328
-ml4gw/transforms/scaler.py,sha256=5VGov0M80NZostRzccViC3HNftx4ZVu0kOKTDmiLrR4,2327
-ml4gw/transforms/snr_rescaler.py,sha256=ocYr6UjpHW7t5TvruV7fyY8KuuDfGOJyvxEulmiFA6o,2275
-ml4gw/transforms/spectral.py,sha256=WgRkS-QVbZEKa8Dwgst5I6NM6kVhbsY5c7ZmYqpcecE,4178
-ml4gw/transforms/spectrogram.py,sha256=R3O8eUB6NHdBFx89v8e_WdJIvXl4qwVeGWZnPyLhHHQ,6024
-ml4gw/transforms/transform.py,sha256=jEr9OFj4u7Wjeh_rpRq90jMpK_TfzcIelbBmt30DxQU,2408
-ml4gw/transforms/waveforms.py,sha256=iyEDSRqK_1zZrxxJenJFbwGUWqbE-alVTXhvjaGl1ww,3060
-ml4gw/transforms/whitening.py,sha256=TmvFCCeTOcSEWo5Pt_JQRJ23X5byiJ91q5jHgBRy0rc,9428
-ml4gw/types.py,sha256=XbxunX8zRF95Fp1mZ9jEbixb63bwDQMoayRMMxT9Lzo,429
-ml4gw/utils/interferometer.py,sha256=Ei9fJoNxjtFNZcMZIs5MG2yj2n-wrlSlWwi-ELRv7Nc,1806
-ml4gw/utils/slicing.py,sha256=Cbwcpk_0hsfN4zczFVM2YbDRjeirA7jFvApM4Jy0U8s,13535
-ml4gw/waveforms/__init__.py,sha256=dnxfRGX_B3zQPB3_3srLyjZXRxTn4miZqYIRe7PYyrU,170
-ml4gw/waveforms/generator.py,sha256=HYTAbih5y-i4v5iV4twTo2DPSADUrrsuz2m9WDqJoH4,1067
-ml4gw/waveforms/phenom_d.py,sha256=6wV_NYH8iNQcJ_uuB2cB00m8_2wfkVz3Hu7NTY4hBQg,46823
-ml4gw/waveforms/phenom_d_data.py,sha256=WA1FBxUp9fo1IQaV_OLJ_5g5gI166mY1FtG9n25he9U,53447
-ml4gw/waveforms/phenom_p.py,sha256=qZXhDexcSedCP8UwEk1Jw2YoBy9Uxp0zWg1ltXu-guk,26615
-ml4gw/waveforms/ringdown.py,sha256=1-KAzfe2EOv0y9MY-DOB8Qv--9wS8fYIa6xTLcKI4i4,3320
-ml4gw/waveforms/sine_gaussian.py,sha256=LlSgPwd-_HPrkpVhdqZbMReepAn4BQgsMP4Ei33IWAA,3575
-ml4gw/waveforms/taylorf2.py,sha256=-5q52p0Ie5oZJhhfJwdKXR9RNeTLW1QJxsRKMGi1w-c,10160
-ml4gw-0.5.0.dist-info/METADATA,sha256=psK8lqAVUUCfJV6uI4XX9EFrXa2-h8Eyt-KWcO6gDmI,5736
-ml4gw-0.5.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ml4gw-0.5.0.dist-info/RECORD,,