lt-tensor 0.0.1a34__py3-none-any.whl → 0.0.1a35__py3-none-any.whl

lt_tensor/model_zoo/convs.py

@@ -40,42 +40,22 @@ class ConvNets(Model):
 
     def remove_norms(self, name: str = "weight"):
         for module in self.modules():
-            if "Conv" in module.__class__.__name__:
-                remove_norm(module, name)
+            try:
+                if "Conv" in module.__class__.__name__:
+                    remove_norm(module, name)
+            except:
+                pass
 
     @staticmethod
-    def init_weights(
-        m: nn.Module,
-        norm: Optional[Literal["spectral", "weight"]] = None,
-        mean=0.0,
-        std=0.02,
-        name: str = "weight",
-        n_power_iterations: int = 1,
-        eps: float = 1e-9,
-        dim_sn: Optional[int] = None,
-        dim_wn: int = 0,
-    ):
+    def init_weights(m: nn.Module, mean=0.0, std=0.02):
         if "Conv" in m.__class__.__name__:
-            if norm is not None:
-                try:
-                    if norm == "spectral":
-                        m.apply(
-                            lambda m: spectral_norm(
-                                m,
-                                n_power_iterations=n_power_iterations,
-                                eps=eps,
-                                name=name,
-                                dim=dim_sn,
-                            )
-                        )
-                    else:
-                        m.apply(lambda m: weight_norm(m, name=name, dim=dim_wn))
-                except ValueError:
-                    pass
             m.weight.data.normal_(mean, std)
 
 
 class Conv1dEXT(ConvNets):
+
+    # TODO: Use this module to replace all that are using normalizations, mostly those in `audio_models`
+
     def __init__(
         self,
         in_channels: int,
@@ -90,7 +70,8 @@ class Conv1dEXT(ConvNets):
         device: Optional[Any] = None,
         dtype: Optional[Any] = None,
         apply_norm: Optional[Literal["weight", "spectral"]] = None,
-        activation: nn.Module = nn.Identity(),
+        activation_in: nn.Module = nn.Identity(),
+        activation_out: nn.Module = nn.Identity(),
         *args,
         **kwargs,
     ):
@@ -112,13 +93,21 @@ class Conv1dEXT(ConvNets):
         )
         if apply_norm is None:
             self.cnn = nn.Conv1d(**cnn_kwargs)
+            self.has_wn = False
         else:
+            self.has_wn = True
             if apply_norm == "spectral":
                 self.cnn = spectral_norm(nn.Conv1d(**cnn_kwargs))
             else:
                 self.cnn = weight_norm(nn.Conv1d(**cnn_kwargs))
-        self.activation = activation
+        self.actv_in = activation_in
+        self.actv_out = activation_out
         self.cnn.apply(self.init_weights)
 
     def forward(self, input: Tensor):
-        return self.cnn(self.activation(input))
+        return self.actv_out(self.cnn(self.actv_in(input)))
+
+    def remove_norms(self, name="weight"):
+        if self.has_wn:
+            remove_norm(self.cnn, name)
+            self.has_wn = False

lt_tensor/model_zoo/losses/discriminators.py

@@ -7,8 +7,6 @@ from lt_tensor.model_base import Model
 from lt_tensor.model_zoo.convs import ConvNets
 from torch.nn import functional as F
 from torchaudio import transforms as T
-from lt_tensor.processors import AudioProcessor, AudioProcessorConfig
-
 
 MULTI_DISC_OUT_TYPE: TypeAlias = Tuple[
     List[Tensor],
@@ -19,9 +17,11 @@ MULTI_DISC_OUT_TYPE: TypeAlias = Tuple[
 
 
 class MultiDiscriminatorWrapper(Model):
-    def __init__(self, list_discriminator: List["_MultiDiscriminatorT"]):
+    def __init__(
+        self, list_discriminator: Union[List["_MultiDiscriminatorT"], nn.ModuleList]
+    ):
         """Setup example:
-        model_d = MultiDiscriminatorStep(
+        model_d = MultiDiscriminatorWrapper(
             [
                 MultiEnvelopeDiscriminator(),
                 MultiBandDiscriminator(),
@@ -31,7 +31,12 @@ class MultiDiscriminatorWrapper(Model):
         )
         """
         super().__init__()
-        self.disc: Sequence[_MultiDiscriminatorT] = nn.ModuleList(list_discriminator)
+
+        self.disc: Sequence[_MultiDiscriminatorT] = (
+            nn.ModuleList(list_discriminator)
+            if isinstance(list_discriminator, (list, tuple, set))
+            else list_discriminator
+        )
         self.total = len(self.disc)
 
     def forward(
@@ -96,7 +101,6 @@ class _MultiDiscriminatorT(ConvNets):
     def forward(self, y: Tensor, y_hat: Tensor) -> MULTI_DISC_OUT_TYPE:
         pass
 
-    # for type hinting
     def __call__(self, *args, **kwds) -> MULTI_DISC_OUT_TYPE:
         return super().__call__(*args, **kwds)
 
@@ -159,7 +163,7 @@ class DiscriminatorP(ConvNets):
     def __init__(
         self,
         period: List[int],
-        discriminator_channel_mult: Number = 1,
+        discriminator_channel_multi: Number = 1,
         kernel_size: int = 5,
         stride: int = 3,
         use_spectral_norm: bool = False,
@@ -167,7 +171,7 @@ class DiscriminatorP(ConvNets):
         super().__init__()
         self.period = period
         norm_f = weight_norm if not use_spectral_norm else spectral_norm
-        dsc = lambda x: int(x * discriminator_channel_mult)
+        dsc = lambda x: int(x * discriminator_channel_multi)
         self.convs = nn.ModuleList(
             [
                 norm_f(
@@ -242,19 +246,18 @@ class DiscriminatorP(ConvNets):
 class MultiPeriodDiscriminator(_MultiDiscriminatorT):
     def __init__(
         self,
-        discriminator_channel_mult: Number = 1,
+        discriminator_channel_multi: Number = 1,
         mpd_reshapes: list[int] = [2, 3, 5, 7, 11],
         use_spectral_norm: bool = False,
     ):
         super().__init__()
         self.mpd_reshapes = mpd_reshapes
-        print(f"mpd_reshapes: {self.mpd_reshapes}")
         self.discriminators = nn.ModuleList(
             [
                 DiscriminatorP(
                     rs,
                     use_spectral_norm=use_spectral_norm,
-                    discriminator_channel_mult=discriminator_channel_mult,
+                    discriminator_channel_multi=discriminator_channel_multi,
                 )
                 for rs in self.mpd_reshapes
             ]
@@ -276,6 +279,79 @@ class MultiPeriodDiscriminator(_MultiDiscriminatorT):
         return y_d_rs, y_d_gs, fmap_rs, fmap_gs
 
 
+class DiscriminatorS(ConvNets):
+    def __init__(
+        self,
+        use_spectral_norm=False,
+        discriminator_channel_multi: Number = 1,
+    ):
+        super().__init__()
+        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+        dsc = lambda x: int(x * discriminator_channel_multi)
+        self.convs = nn.ModuleList(
+            [
+                norm_f(nn.Conv1d(1, dsc(128), 15, 1, padding=7)),
+                norm_f(nn.Conv1d(dsc(128), dsc(128), 41, 2, groups=4, padding=20)),
+                norm_f(nn.Conv1d(dsc(128), dsc(256), 41, 2, groups=16, padding=20)),
+                norm_f(nn.Conv1d(dsc(256), dsc(512), 41, 4, groups=16, padding=20)),
+                norm_f(nn.Conv1d(dsc(512), dsc(1024), 41, 4, groups=16, padding=20)),
+                norm_f(nn.Conv1d(dsc(1024), dsc(1024), 41, 1, groups=16, padding=20)),
+                norm_f(nn.Conv1d(dsc(1024), dsc(1024), 5, 1, padding=2)),
+            ]
+        )
+        self.conv_post = norm_f(nn.Conv1d(dsc(1024), 1, 3, 1, padding=1))
+        self.activation = nn.LeakyReLU(0.1)
+
+    def forward(self, x):
+        fmap = []
+        for l in self.convs:
+            x = l(x)
+            x = self.activation(x)
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        return x.flatten(1, -1), fmap
+
+
+class MultiScaleDiscriminator(ConvNets):
+    def __init__(
+        self,
+        discriminator_channel_multi: Number = 1,
+    ):
+        super().__init__()
+        self.discriminators = nn.ModuleList(
+            [
+                DiscriminatorS(
+                    use_spectral_norm=True,
+                    discriminator_channel_multi=discriminator_channel_multi,
+                ),
+                DiscriminatorS(discriminator_channel_multi=discriminator_channel_multi),
+                DiscriminatorS(discriminator_channel_multi=discriminator_channel_multi),
+            ]
+        )
+        self.meanpools = nn.ModuleList(
+            [nn.AvgPool1d(4, 2, padding=2), nn.AvgPool1d(4, 2, padding=2)]
+        )
+
+    def forward(self, y, y_hat):
+        y_d_rs = []
+        y_d_gs = []
+        fmap_rs = []
+        fmap_gs = []
+        for i, d in enumerate(self.discriminators):
+            if i > 0:
+                y = self.meanpools[i - 1](y)
+                y_hat = self.meanpools[i - 1](y_hat)
+            y_d_r, fmap_r = d(y)
+            y_d_g, fmap_g = d(y_hat)
+            y_d_rs.append(y_d_r)
+            fmap_rs.append(fmap_r)
+            y_d_gs.append(y_d_g)
+            fmap_gs.append(fmap_g)
+
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
 class EnvelopeExtractor(Model):
     """Extracts the amplitude envelope of the audio signal."""
 
@@ -297,21 +373,35 @@ class EnvelopeExtractor(Model):
 
 
 class DiscriminatorEnvelope(ConvNets):
-    def __init__(self, use_spectral_norm=False):
+    def __init__(
+        self,
+        use_spectral_norm=False,
+        discriminator_channel_multi: Number = 1,
+        kernel_size: int = 101,
+    ):
         super().__init__()
         norm_f = weight_norm if not use_spectral_norm else spectral_norm
-        self.extractor = EnvelopeExtractor(kernel_size=101)
+        self.extractor = EnvelopeExtractor(kernel_size=kernel_size)
+        dsc = lambda x: int(x * discriminator_channel_multi)
         self.convs = nn.ModuleList(
             [
-                norm_f(nn.Conv1d(1, 64, 15, stride=1, padding=7)),
-                norm_f(nn.Conv1d(64, 128, 41, stride=2, groups=4, padding=20)),
-                norm_f(nn.Conv1d(128, 256, 41, stride=2, groups=16, padding=20)),
-                norm_f(nn.Conv1d(256, 512, 41, stride=4, groups=16, padding=20)),
-                norm_f(nn.Conv1d(512, 512, 41, stride=4, groups=16, padding=20)),
-                norm_f(nn.Conv1d(512, 512, 5, stride=1, padding=2)),
+                norm_f(nn.Conv1d(1, dsc(64), 15, stride=1, padding=7)),
+                norm_f(
+                    nn.Conv1d(dsc(64), dsc(128), 41, stride=2, groups=4, padding=20)
+                ),
+                norm_f(
+                    nn.Conv1d(dsc(128), dsc(256), 41, stride=2, groups=16, padding=20)
+                ),
+                norm_f(
+                    nn.Conv1d(dsc(256), dsc(512), 41, stride=4, groups=16, padding=20)
+                ),
+                norm_f(
+                    nn.Conv1d(dsc(512), dsc(512), 41, stride=4, groups=16, padding=20)
+                ),
+                norm_f(nn.Conv1d(dsc(512), dsc(512), 5, stride=1, padding=2)),
             ]
         )
-        self.conv_post = norm_f(nn.Conv1d(512, 1, 3, stride=1, padding=1))
+        self.conv_post = norm_f(nn.Conv1d(dsc(512), 1, 3, stride=1, padding=1))
         self.activation = nn.LeakyReLU(0.1)
 
     def forward(self, x):
@@ -327,11 +417,17 @@ class DiscriminatorEnvelope(ConvNets):
 
 
 class MultiEnvelopeDiscriminator(_MultiDiscriminatorT):
-    def __init__(self, use_spectral_norm: bool = False):
+    def __init__(
+        self,
+        use_spectral_norm: bool = False,
+        discriminator_channel_multi: Number = 1,
+    ):
         super().__init__()
         self.discriminators = nn.ModuleList(
             [
-                DiscriminatorEnvelope(use_spectral_norm),  # raw envelope
+                DiscriminatorEnvelope(
+                    use_spectral_norm, discriminator_channel_multi
+                ),  # raw envelope
                 DiscriminatorEnvelope(use_spectral_norm),  # downsampled once
                 DiscriminatorEnvelope(use_spectral_norm),  # downsampled twice
             ]
@@ -431,7 +527,7 @@ class DiscriminatorB(ConvNets):
         for band, stack in zip(x_bands, self.band_convs):
             for i, layer in enumerate(stack):
                 band = layer(band)
-                band = torch.nn.functional.leaky_relu(band, 0.1)
+                band = F.leaky_relu(band, 0.1)
                 if i > 0:
                     fmap.append(band)
             x.append(band)
@@ -452,11 +548,21 @@ class MultiBandDiscriminator(_MultiDiscriminatorT):
     def __init__(
         self,
         mbd_fft_sizes: list[int] = [2048, 1024, 512],
+        channels: int = 32,
+        hop_factor: float = 0.25,
+        bands: Tuple[Tuple[float, float], ...] = (
+            (0.0, 0.1),
+            (0.1, 0.25),
+            (0.25, 0.5),
+            (0.5, 0.75),
+            (0.75, 1.0),
+        ),
     ):
         super().__init__()
         self.fft_sizes = mbd_fft_sizes
+        kwargs_disc = dict(channels=channels, hop_factor=hop_factor, bands=bands)
         self.discriminators = nn.ModuleList(
-            [DiscriminatorB(window_length=w) for w in self.fft_sizes]
+            [DiscriminatorB(window_length=w, **kwargs_disc) for w in self.fft_sizes]
         )
 
     def forward(self, y: Tensor, y_hat: Tensor) -> MULTI_DISC_OUT_TYPE:
@@ -483,7 +589,7 @@ class DiscriminatorR(ConvNets):
         self,
         resolution: List[int],
         use_spectral_norm: bool = False,
-        discriminator_channel_mult: int = 1,
+        discriminator_channel_multi: Number = 1,
     ):
         super().__init__()
 
@@ -501,13 +607,13 @@ class DiscriminatorR(ConvNets):
             [
                 norm_f(
                     nn.Conv2d(
-                        1, int(32 * discriminator_channel_mult), (3, 9), padding=(1, 4)
+                        1, int(32 * discriminator_channel_multi), (3, 9), padding=(1, 4)
                     )
                 ),
                 norm_f(
                     nn.Conv2d(
-                        int(32 * discriminator_channel_mult),
-                        int(32 * discriminator_channel_mult),
+                        int(32 * discriminator_channel_multi),
+                        int(32 * discriminator_channel_multi),
                         (3, 9),
                         stride=(1, 2),
                         padding=(1, 4),
@@ -515,8 +621,8 @@ class DiscriminatorR(ConvNets):
                 ),
                 norm_f(
                     nn.Conv2d(
-                        int(32 * discriminator_channel_mult),
-                        int(32 * discriminator_channel_mult),
+                        int(32 * discriminator_channel_multi),
+                        int(32 * discriminator_channel_multi),
                         (3, 9),
                         stride=(1, 2),
                         padding=(1, 4),
@@ -524,8 +630,8 @@ class DiscriminatorR(ConvNets):
                 ),
                 norm_f(
                     nn.Conv2d(
-                        int(32 * discriminator_channel_mult),
-                        int(32 * discriminator_channel_mult),
+                        int(32 * discriminator_channel_multi),
+                        int(32 * discriminator_channel_multi),
                         (3, 9),
                         stride=(1, 2),
                         padding=(1, 4),
@@ -533,8 +639,8 @@ class DiscriminatorR(ConvNets):
                 ),
                 norm_f(
                     nn.Conv2d(
-                        int(32 * discriminator_channel_mult),
-                        int(32 * discriminator_channel_mult),
+                        int(32 * discriminator_channel_multi),
+                        int(32 * discriminator_channel_multi),
                         (3, 3),
                         padding=(1, 1),
                     )
@@ -542,7 +648,7 @@ class DiscriminatorR(ConvNets):
             ]
         )
         self.conv_post = norm_f(
-            nn.Conv2d(int(32 * discriminator_channel_mult), 1, (3, 3), padding=(1, 1))
+            nn.Conv2d(int(32 * discriminator_channel_multi), 1, (3, 3), padding=(1, 1))
         )
 
     def forward(self, x: Tensor) -> Tuple[Tensor, List[Tensor]]:
@@ -586,7 +692,7 @@ class MultiResolutionDiscriminator(_MultiDiscriminatorT):
     def __init__(
         self,
         use_spectral_norm: bool = False,
-        discriminator_channel_mult: int = 1,
+        discriminator_channel_multi: Number = 1,
         resolutions: List[List[int]] = [
             [1024, 120, 600],
             [2048, 240, 1200],
@@ -601,7 +707,7 @@ class MultiResolutionDiscriminator(_MultiDiscriminatorT):
         self.discriminators = nn.ModuleList(
             [
                 DiscriminatorR(
-                    resolution, use_spectral_norm, discriminator_channel_mult
+                    resolution, use_spectral_norm, discriminator_channel_multi
                 )
                 for resolution in self.resolutions
             ]

{lt_tensor-0.0.1a34.dist-info → lt_tensor-0.0.1a35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a34
+Version: 0.0.1a35
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336

lt_tensor-0.0.1a35.dist-info/RECORD

@@ -0,0 +1,40 @@
+lt_tensor/__init__.py,sha256=4NqhrI_O5q4YQMBpyoLtNUUbBnnbWkO92GE1hxHcrd8,441
+lt_tensor/config_templates.py,sha256=F9UvL8paAjkSvio890kp8WznpYeI50pYnm9iqQroBxk,2797
+lt_tensor/losses.py,sha256=Heco_WyoC1HkNkcJEircOAzS9umusATHiNAG-FKGyzc,8918
+lt_tensor/lr_schedulers.py,sha256=6_vcfaPHrozfH3wvmNEdKSFYl6iTIijYoHL8vuG-45U,7651
+lt_tensor/math_ops.py,sha256=ahX6Z1Mt3X-FhmwSZYZea5mB1B0S8GDuvKPfAm5e_FQ,2646
+lt_tensor/misc_utils.py,sha256=stL6q3M7S2N4FBICFYbgYpdPDrJRlwmr24-iCXMRifM,28933
+lt_tensor/model_base.py,sha256=5T4dbAh4MXbQmPRpihGtMYwTY8sJTQOhY6An3VboM58,18086
+lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
+lt_tensor/noise_tools.py,sha256=wFeAsHhLhSlEc5XU5LbFKaXoHeVxrWjiMeljjGdIKyM,11363
+lt_tensor/torch_commons.py,sha256=8l0bxmrAzwvyqjivCIVISXlbvKarlg4DdE0BOGSnMuQ,812
+lt_tensor/transform.py,sha256=dZm8T_ov0blHMQu6nGiehsdG1VSB7bZBUVmTkT-PBdc,13257
+lt_tensor/model_zoo/__init__.py,sha256=yPUVchgVhU2nAJ2ocA4HFfG7IMEiBu8qOi8I1KWTTkU,404
+lt_tensor/model_zoo/basic.py,sha256=pI8HyiHK-cmWcEEaVY_EduUJOjZW6HOtXvJd8Rbhq30,15452
+lt_tensor/model_zoo/convs.py,sha256=Tws0jrPfs9m7OLmJ30W0AfkAvZgppW7lNi4xt0e-qRU,3518
+lt_tensor/model_zoo/features.py,sha256=DO8dlE0kmPKTNC1Xkv9wKegOOYkQa_rkxM4hhcNwJWA,15655
+lt_tensor/model_zoo/fusion.py,sha256=usC1bcjQRNivDc8xzkIS5T1glm78OLcs2V_tPqfp-eI,5422
+lt_tensor/model_zoo/pos_encoder.py,sha256=3d1EYLinCU9UAy-WuEWeYMGhMqaGknCiQ5qEmhw_UYM,4487
+lt_tensor/model_zoo/residual.py,sha256=tMXgif9Ggep9bk75K93yueeU5vk5S25AGCRFwOQOyB8,6452
+lt_tensor/model_zoo/transformer.py,sha256=HUFoFFh7EQJErxdd9XIxhssdjvNVx2tNGDJOTUfwG2A,4301
+lt_tensor/model_zoo/activations/__init__.py,sha256=f_IsuC-SaFsX6w4OtBWa5bbS4TqR90X-cvLxGUgYfjk,67
+lt_tensor/model_zoo/activations/alias_free/__init__.py,sha256=dgLjatRm9nusoPVOl1pvCef5rZsaRfS3BJUs05SPYzw,64
+lt_tensor/model_zoo/activations/alias_free/act.py,sha256=1wxmab2kMD88L6wsQgf3t25dBwR7_he2eM1DlV0FQak,1424
+lt_tensor/model_zoo/activations/alias_free/filter.py,sha256=5TvXESv31toD5sePBe_OUJJfMXv6Ohwmx2YawjQL-pk,6004
+lt_tensor/model_zoo/activations/alias_free/resample.py,sha256=3iM4fNr9fLNXXMyXvzW-MwkSjOZOrMZLfS80UHs6zk0,3386
+lt_tensor/model_zoo/activations/snake/__init__.py,sha256=AtOAbJuMinxmKkppITGMzRbcbPQaALnl9mCtl1c3x0Q,4356
+lt_tensor/model_zoo/audio_models/__init__.py,sha256=WwiP9MekJreMOfKPWLl24VkRJIpLk6hhL8ch0aKgOss,103
+lt_tensor/model_zoo/audio_models/resblocks.py,sha256=u-foHxaFDUICjxSkpyHXljQYQG9zMxVYaOGqLR_nJ-k,7978
+lt_tensor/model_zoo/audio_models/bigvgan/__init__.py,sha256=Dpt_3JXUToldxQrZx4a1gfI-awsLIVipAXqWm4lzBzM,8495
+lt_tensor/model_zoo/audio_models/diffwave/__init__.py,sha256=PDuDYN1omD1RoAXcmxH3tEgfAuM3ZHAWzimD6ElMqEQ,9073
+lt_tensor/model_zoo/audio_models/hifigan/__init__.py,sha256=3HVfEreQ4NqYIC9AWEkmL4ePcIbR1kTyH0cBG8u_Jik,6387
+lt_tensor/model_zoo/audio_models/istft/__init__.py,sha256=blICjLX_z_IFmR3_TCz_dJiSayLYGza9eG6fd9aKyvE,7448
+lt_tensor/model_zoo/losses/__init__.py,sha256=B9RAUxBiOZwooztnij1oLeRwZ7_MjnN3mPoum7saD6s,59
+lt_tensor/model_zoo/losses/discriminators.py,sha256=HBO7jwCsUGsYfSz-JZPZccuYLnto6jfZs3Ve5j51JQE,24247
+lt_tensor/processors/__init__.py,sha256=Pvxhh0KR65zLCgUd53_k5Z0y5JWWcO0ZBXFK9rv0o5w,109
+lt_tensor/processors/audio.py,sha256=HNr1GS-6M2q0Rda4cErf5y2Jlc9f4jD58FvpX2ua9d4,18369
+lt_tensor-0.0.1a35.dist-info/licenses/LICENSE,sha256=TbiyJWLgNqqgqhfCnrGwFIxy7EqGNrIZZcKhHrefcuU,11354
+lt_tensor-0.0.1a35.dist-info/METADATA,sha256=0FrtLNnbU49bKOlyshasXPZOZ90Sok03XkXbtxP4VMI,1062
+lt_tensor-0.0.1a35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a35.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a35.dist-info/RECORD,,

lt_tensor/model_zoo/activations/alias_free_torch/__init__.py

@@ -1 +0,0 @@
-from . import *

lt_tensor-0.0.1a34.dist-info/RECORD

@@ -1,37 +0,0 @@
-lt_tensor/__init__.py,sha256=WAGPuMPq5c4DGAJ57x1Ykgzg3vMlLq9BiWk5EdJcUsU,441
-lt_tensor/config_templates.py,sha256=F9UvL8paAjkSvio890kp8WznpYeI50pYnm9iqQroBxk,2797
-lt_tensor/losses.py,sha256=fHVMqOFo3ekjORYy89R_aRjmtT6lo27Z1egzOYjQ1W8,8646
-lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
-lt_tensor/math_ops.py,sha256=ahX6Z1Mt3X-FhmwSZYZea5mB1B0S8GDuvKPfAm5e_FQ,2646
-lt_tensor/misc_utils.py,sha256=N2r3UmxC4RM2BZBQhpjDZ_BKLrzsyIlKzopTzJbnjFU,28962
-lt_tensor/model_base.py,sha256=5T4dbAh4MXbQmPRpihGtMYwTY8sJTQOhY6An3VboM58,18086
-lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
-lt_tensor/noise_tools.py,sha256=wFeAsHhLhSlEc5XU5LbFKaXoHeVxrWjiMeljjGdIKyM,11363
-lt_tensor/torch_commons.py,sha256=8l0bxmrAzwvyqjivCIVISXlbvKarlg4DdE0BOGSnMuQ,812
-lt_tensor/transform.py,sha256=dZm8T_ov0blHMQu6nGiehsdG1VSB7bZBUVmTkT-PBdc,13257
-lt_tensor/model_zoo/__init__.py,sha256=yPUVchgVhU2nAJ2ocA4HFfG7IMEiBu8qOi8I1KWTTkU,404
-lt_tensor/model_zoo/basic.py,sha256=pI8HyiHK-cmWcEEaVY_EduUJOjZW6HOtXvJd8Rbhq30,15452
-lt_tensor/model_zoo/convs.py,sha256=YQRxek75Qpsha8nfc7wLhmJS9XxPeCa4WxuftLg6IcE,3927
-lt_tensor/model_zoo/features.py,sha256=DO8dlE0kmPKTNC1Xkv9wKegOOYkQa_rkxM4hhcNwJWA,15655
-lt_tensor/model_zoo/fusion.py,sha256=usC1bcjQRNivDc8xzkIS5T1glm78OLcs2V_tPqfp-eI,5422
-lt_tensor/model_zoo/pos_encoder.py,sha256=3d1EYLinCU9UAy-WuEWeYMGhMqaGknCiQ5qEmhw_UYM,4487
-lt_tensor/model_zoo/residual.py,sha256=tMXgif9Ggep9bk75K93yueeU5vk5S25AGCRFwOQOyB8,6452
-lt_tensor/model_zoo/transformer.py,sha256=HUFoFFh7EQJErxdd9XIxhssdjvNVx2tNGDJOTUfwG2A,4301
-lt_tensor/model_zoo/activations/alias_free_torch/__init__.py,sha256=ovguP4wzQEDNguczwiZnhMm4dRRVcvnzmHrfQtlRCNQ,15
-lt_tensor/model_zoo/activations/alias_free_torch/act.py,sha256=h79C93GzbSrCq4ui6iO7DjJLuJ7QK_ag_TU-WAcj0NI,1405
-lt_tensor/model_zoo/activations/alias_free_torch/filter.py,sha256=5TvXESv31toD5sePBe_OUJJfMXv6Ohwmx2YawjQL-pk,6004
-lt_tensor/model_zoo/activations/alias_free_torch/resample.py,sha256=3iM4fNr9fLNXXMyXvzW-MwkSjOZOrMZLfS80UHs6zk0,3386
-lt_tensor/model_zoo/activations/snake/__init__.py,sha256=Adb_xe-7YdYsNxvlSSO9zkae-cu7ElxkBKE3trDtOus,4517
-lt_tensor/model_zoo/audio_models/__init__.py,sha256=MoG9YjxLyvscq_6njK1ljGBletK9iedBXt66bplzW-s,83
-lt_tensor/model_zoo/audio_models/diffwave/__init__.py,sha256=PDuDYN1omD1RoAXcmxH3tEgfAuM3ZHAWzimD6ElMqEQ,9073
-lt_tensor/model_zoo/audio_models/hifigan/__init__.py,sha256=7GJqKLw7-juXpfp5IFzjASLut0uouDhjZ1CQknf3H68,16533
-lt_tensor/model_zoo/audio_models/istft/__init__.py,sha256=ltIuD9t1gmS3bTmCqZIwJHKrhC6DYya3OaXlskWX9kw,17606
-lt_tensor/model_zoo/losses/__init__.py,sha256=B9RAUxBiOZwooztnij1oLeRwZ7_MjnN3mPoum7saD6s,59
-lt_tensor/model_zoo/losses/discriminators.py,sha256=ZpyByFgc7L7uV_XRBsV9vkdVItbJO3z--Y6LlvTvtwY,20765
-lt_tensor/processors/__init__.py,sha256=Pvxhh0KR65zLCgUd53_k5Z0y5JWWcO0ZBXFK9rv0o5w,109
-lt_tensor/processors/audio.py,sha256=HNr1GS-6M2q0Rda4cErf5y2Jlc9f4jD58FvpX2ua9d4,18369
-lt_tensor-0.0.1a34.dist-info/licenses/LICENSE,sha256=TbiyJWLgNqqgqhfCnrGwFIxy7EqGNrIZZcKhHrefcuU,11354
-lt_tensor-0.0.1a34.dist-info/METADATA,sha256=WkTafcY5nYZbrZ7WzUc3JXnmg9NtUAXrchx42dCok9I,1062
-lt_tensor-0.0.1a34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a34.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a34.dist-info/RECORD,,