lt-tensor 0.0.1a33__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(
@@ -82,23 +87,6 @@ class MultiDiscriminatorWrapper(Model):
         return disc_loss, disc_real_losses, disc_gen_losses
 
 
-def normalize_unit_norm(x: torch.Tensor, eps: float = 1e-5):
-    norm = torch.norm(x, dim=-1, keepdim=True)
-    return x / (norm + eps)
-
-
-def normalize_minmax(x: torch.Tensor, eps: float = 1e-5):
-    min_val = x.amin(dim=-1, keepdim=True)
-    max_val = x.amax(dim=-1, keepdim=True)
-    return (x - min_val) / (max_val - min_val + eps)
-
-
-def normalize_zscore(x: torch.Tensor, eps: float = 1e-5):
-    mean = x.mean(dim=-1, keepdim=True)
-    std = x.std(dim=-1, keepdim=True)
-    return (x - mean) / (std + eps)
-
-
 def get_padding(kernel_size, dilation=1):
     return int((kernel_size * dilation - dilation) / 2)
 
@@ -113,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)
 
@@ -176,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,
@@ -184,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(
@@ -259,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
             ]
@@ -293,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."""
 
@@ -314,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):
@@ -344,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
             ]
@@ -448,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)
@@ -469,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:
@@ -500,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__()
 
@@ -518,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),
@@ -532,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),
@@ -541,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),
@@ -550,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),
                     )
@@ -559,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]]:
@@ -603,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],
@@ -618,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
             ]
@@ -637,179 +726,3 @@ class MultiResolutionDiscriminator(_MultiDiscriminatorT):
             y_d_gs.append(y_d_g)
             fmap_gs.append(fmap_g)
         return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiMelScaleLoss(Model):
-    # TODO: Make the normalization an argument to be chosen by the dev
-    def __init__(
-        self,
-        sample_rate: int,
-        n_mels: List[int] = [5, 10, 20, 40, 80, 160, 320],
-        window_lengths: List[int] = [32, 64, 128, 256, 512, 1024, 2048],
-        n_ffts: List[int] = [32, 64, 128, 256, 512, 1024, 2048],
-        hops: List[int] = [8, 16, 32, 64, 128, 256, 512],
-        weight: float = 1.0,
-        lambda_mel: float = 1.0,
-        f_min: float = [0, 0, 0, 0, 0, 0, 0],
-        f_max: Optional[float] = [None, None, None, None, None, None, None],
-        loss_fn: Callable = nn.L1Loss(),
-        center: bool = True,
-        power: float = 1.0,
-        normalized: bool = False,
-        pad_mode: str = "reflect",
-        onesided: Optional[bool] = None,
-        std: int = 4,
-        mean: int = -4,
-        auto_interpolate: bool = True,
-        use_istft_norm: bool = True,
-        use_pitch_loss: bool = False,
-        use_rms_loss: bool = False,
-        lambda_pitch: float = 0.5,
-        lambda_rms: float = 0.5,
-    ):
-        super().__init__()
-        assert (
-            len(n_mels)
-            == len(window_lengths)
-            == len(n_ffts)
-            == len(hops)
-            == len(f_min)
-            == len(f_max)
-        )
-        self.loss_fn = loss_fn
-        self.lambda_mel = lambda_mel
-        self.weight = weight
-        self.use_istft_norm = use_istft_norm
-        self.auto_interpolate = auto_interpolate if not self.use_istft_norm else False
-        self.use_pitch_loss = use_pitch_loss
-        self.use_rms_loss = use_rms_loss
-        self.lambda_pitch = lambda_pitch
-        self.lambda_rms = lambda_rms
-
-        self._setup_mels(
-            sample_rate,
-            n_mels,
-            window_lengths,
-            n_ffts,
-            hops,
-            f_min,
-            f_max,
-            center,
-            power,
-            normalized,
-            pad_mode,
-            onesided,
-            std,
-            mean,
-        )
-
-    def _setup_mels(
-        self,
-        sample_rate: int,
-        n_mels: List[int],
-        window_lengths: List[int],
-        n_ffts: List[int],
-        hops: List[int],
-        f_min: List[float],
-        f_max: List[Optional[float]],
-        center: bool,
-        power: float,
-        normalized: bool,
-        pad_mode: str = "reflect",
-        onesided: Optional[bool] = None,
-        std: int = 4,
-        mean: int = -4,
-    ):
-        assert (
-            len(n_mels)
-            == len(window_lengths)
-            == len(n_ffts)
-            == len(hops)
-            == len(f_min)
-            == len(f_max)
-        )
-        _mel_kwargs = dict(
-            sample_rate=sample_rate,
-            center=center,
-            onesided=onesided,
-            normalized=normalized,
-            power=power,
-            pad_mode=pad_mode,
-            std=std,
-            mean=mean,
-        )
-        self.mel_spectrograms: List[AudioProcessor] = nn.ModuleList(
-            [
-                AudioProcessor(
-                    AudioProcessorConfig(
-                        **_mel_kwargs,
-                        n_mels=mel,
-                        n_fft=n_fft,
-                        win_length=win,
-                        hop_length=hop,
-                        f_min=fmin,
-                        f_max=fmax,
-                    )
-                )
-                for mel, win, n_fft, hop, fmin, fmax in zip(
-                    n_mels, window_lengths, n_ffts, hops, f_min, f_max
-                )
-            ]
-        )
-
-    def _process_tensor(
-        self,
-        input_wave: torch.Tensor,
-        target_wave: torch.Tensor,
-    ):
-        if input_wave.shape[-1] != target_wave.shape[-1]:
-            if input_wave.ndim < 3:
-                # To be compatible with interpolatin
-                if input_wave.ndim == 2:
-                    input_wave = input_wave.unsqueeze(1)
-                else:
-                    input_wave = input_wave.unsqueeze(0).unsqueeze(0)
-            input_wave = F.interpolate(input_wave, target_wave.shape[-1], mode="linear")
-        return input_wave
-
-    def forward(
-        self, input_wave: torch.Tensor, target_wave: torch.Tensor
-    ) -> torch.Tensor:
-        assert (
-            self.use_istft_norm
-            or self.auto_interpolate
-            or input_wave.shape[-1] == target_wave.shape[-1]
-        )
-        if self.auto_interpolate:
-            input_wave = self._process_tensor(input_wave, target_wave)
-
-        losses = 0.0
-        for M in self.mel_spectrograms:
-            # Apply normalization if requested
-            if self.use_istft_norm:
-                input_proc = M.istft_norm(input_wave, length=target_wave.shape[-1])
-                target_proc = M.istft_norm(target_wave, length=target_wave.shape[-1])
-            else:
-                input_proc, target_proc = input_wave, target_wave
-
-            x_mels = M(input_proc)
-            y_mels = M(target_proc)
-
-            loss = self.loss_fn(x_mels.squeeze(), y_mels.squeeze())
-            losses += loss * self.lambda_mel
-
-            # pitch/f0 loss
-            if self.use_pitch_loss:
-                x_pitch = normalize_unit_norm(M.compute_pitch(input_proc))
-                y_pitch = normalize_unit_norm(M.compute_pitch(target_proc))
-                f0_loss = self.loss_fn(x_pitch, y_pitch)
-                losses += f0_loss * self.lambda_pitch
-
-            # energy/rms loss
-            if self.use_rms_loss:
-                x_rms = normalize_unit_norm(M.compute_rms(input_proc, x_mels))
-                y_rms = normalize_unit_norm(M.compute_rms(target_proc, y_mels))
-                rms_loss = self.loss_fn(x_rms, y_rms)
-                losses += rms_loss * self.lambda_rms
-
-        return losses * self.weight

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a33
+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 *