lt-tensor 0.0.1a10__py3-none-any.whl → 0.0.1a12__py3-none-any.whl

lt_tensor/model_zoo/rsd.py

@@ -1,15 +1,14 @@
 __all__ = [
     "spectral_norm_select",
-    "ResBlock1D_BT",
+    "get_weight_norm",
     "ResBlock1D",
     "ResBlock2D",
-    "ResBlocks",
 ]
 from lt_utils.common import *
-from ..torch_commons import *
-from ..model_base import Model
+from lt_tensor.torch_commons import *
+from lt_tensor.model_base import Model
+from lt_tensor.misc_utils import log_tensor
 import math
-from ..misc_utils import log_tensor
 
 
 def spectral_norm_select(module: nn.Module, enabled: bool):
@@ -18,87 +17,22 @@ def spectral_norm_select(module: nn.Module, enabled: bool):
     return module
 
 
-class ResBlock1D_BT(Model):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        kernel_size: int = 3,
-        dilation: Union[Sequence[int], int] = (1, 3, 5),
-        activation: nn.Module = nn.LeakyReLU(0.1),
-        num_groups: int = 1,
-        batched: bool = True,
-    ):
-        super().__init__()
-        self.conv = nn.ModuleList()
-        if isinstance(dilation, int):
-            dilation = [dilation]
-
-        if batched:
-            layernorm_fn = lambda x: nn.GroupNorm(num_groups=num_groups, num_channels=x)
-        else:
-            layernorm_fn = lambda x: nn.LayerNorm(normalized_shape=x)
-        for i, dil in enumerate(dilation):
-
-            self.conv.append(
-                nn.ModuleDict(
-                    dict(
-                        net=nn.Sequential(
-                            self._get_conv_layer(
-                                in_channels, in_channels, kernel_size, dil
-                            ),
-                            activation,
-                            self._get_conv_layer(
-                                in_channels, in_channels, kernel_size, 1, True
-                            ),
-                            activation,
-                        ),
-                        l_norm=layernorm_fn(in_channels),
-                    )
-                )
-            )
-        self.final = nn.Sequential(
-            self._get_conv_layer(in_channels, out_channels, kernel_size, 1, True),
-            activation,
-        )
-        self.conv.apply(self.init_weights)
+def get_weight_norm(norm_type: Optional[Literal["weight", "spectral"]] = None):
+    if not norm_type:
+        return lambda x: x
+    if norm_type == "weight":
+        return lambda x: weight_norm(x)
+    return lambda x: spectral_norm(x)
 
-    def _get_conv_layer(
-        self,
-        channels_in: int,
-        channels_out: int,
-        kernel_size: int,
-        dilation: int,
-        pad_gate: bool = False,
-    ):
-        return weight_norm(
-            nn.Conv1d(
-                in_channels=channels_in,
-                out_channels=channels_out,
-                kernel_size=kernel_size,
-                stride=1,
-                dilation=dilation,
-                padding=(
-                    int((kernel_size * dilation - dilation) / 2)
-                    if not pad_gate
-                    else int((kernel_size * 1 - 1) / 2)
-                ),
-            )
-        )
 
-    def forward(self, x: Tensor):
-        for i, layer in enumerate(self.conv):
-            xt = layer["net"](x)
-            x = xt + x
-            x = layer["l_norm"](x)
-        return self.final(x)
+class ConvNets(Model):
 
     def remove_weight_norm(self):
         for module in self.modules():
             try:
                 remove_weight_norm(module)
             except ValueError:
-                pass  # Not normed, skip
+                pass
 
     @staticmethod
     def init_weights(m, mean=0.0, std=0.01):
@@ -107,7 +41,7 @@ class ResBlock1D_BT(Model):
             m.weight.data.normal_(mean, std)
 
 
-class ResBlock1D(Model):
+class ResBlock1D(ConvNets):
     def __init__(
         self,
         channels,
@@ -144,65 +78,6 @@ class ResBlock1D(Model):
             x = cnn(x) + x
         return x
 
-    def remove_weight_norm(self):
-        for module in self.modules():
-            try:
-                remove_weight_norm(module)
-            except ValueError:
-                pass  # Not normed, skip
-
-    @staticmethod
-    def init_weights(m, mean=0.0, std=0.01):
-        classname = m.__class__.__name__
-        if "Conv" in classname:
-            m.weight.data.normal_(mean, std)
-
-
-class ResBlocks(Model):
-    def __init__(
-        self,
-        channels: int,
-        resblock_kernel_sizes: List[Union[int, List[int]]] = [3, 7, 11],
-        resblock_dilation_sizes: List[Union[int, List[int]]] = [
-            [1, 3, 5],
-            [1, 3, 5],
-            [1, 3, 5],
-        ],
-        activation: nn.Module = nn.LeakyReLU(0.1),
-    ):
-        super().__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.rb = nn.ModuleList()
-        self.activation = activation
-
-        for k, j in zip(resblock_kernel_sizes, resblock_dilation_sizes):
-            self.rb.append(ResBlock1D(channels, k, j, activation))
-
-        self.rb.apply(self.init_weights)
-
-    def forward(self, x: torch.Tensor):
-        xs = None
-        for i, block in enumerate(self.rb):
-            if i == 0:
-                xs = block(x)
-            else:
-                xs += block(x)
-        x = xs / self.num_kernels
-        return self.activation(x)
-
-    def remove_weight_norm(self):
-        for module in self.modules():
-            try:
-                remove_weight_norm(module)
-            except ValueError:
-                pass  # Not normed, skip
-
-    @staticmethod
-    def init_weights(m, mean=0.0, std=0.01):
-        classname = m.__class__.__name__
-        if "Conv" in classname:
-            m.weight.data.normal_(mean, std)
-
 
 class ResBlock2D(Model):
     def __init__(
@@ -210,25 +85,20 @@ class ResBlock2D(Model):
         in_channels,
         out_channels,
         downsample=False,
-        spec_norm: bool = False,
     ):
         super().__init__()
         stride = 2 if downsample else 1
 
         self.block = nn.Sequential(
-            spectral_norm_select(
-                nn.Conv2d(in_channels, out_channels, 3, stride, 1), spec_norm
-            ),
+            nn.Conv2d(in_channels, out_channels, 3, stride, 1),
             nn.LeakyReLU(0.2),
-            spectral_norm_select(
-                nn.Conv2d(out_channels, out_channels, 3, 1, 1), spec_norm
-            ),
+            nn.Conv2d(out_channels, out_channels, 3, 1, 1),
         )
 
         self.skip = nn.Identity()
         if downsample or in_channels != out_channels:
             self.skip = spectral_norm_select(
-                nn.Conv2d(in_channels, out_channels, 1, stride), spec_norm
+                nn.Conv2d(in_channels, out_channels, 1, stride)
             )
         # on less to be handled every cicle
         self.sqrt_2 = math.sqrt(2)

lt_tensor/model_zoo/tfrms.py

@@ -7,12 +7,12 @@ __all__ = [
 ]
 
 import math
-from ..torch_commons import *
-from ..model_base import Model
+from lt_tensor.torch_commons import *
+from lt_tensor.model_base import Model
 from lt_utils.misc_utils import default
 from typing import Optional
-from .pos import *
-from .bsc import FeedForward
+from lt_tensor.model_zoo.pos import *
+from lt_tensor.model_zoo.bsc import FeedForward
 
 
 def init_weights(module):

lt_tensor/noise_tools.py

@@ -14,10 +14,10 @@ __all__ = [
 
 from lt_utils.common import *
 import torch.nn.functional as F
-from .torch_commons import *
+from lt_tensor.torch_commons import *
 import math
 import random
-from .misc_utils import set_seed
+from lt_tensor.misc_utils import set_seed
 
 
 def add_gaussian_noise(x: Tensor, noise_level=0.025):
@@ -271,9 +271,8 @@ class NoiseSchedulerB(nn.Module):
     def forward(
         self, x_0: Tensor, t: int, noise: Optional[Union[Tensor, float]] = None
     ) -> Tensor:
-        apply_noise()
         assert (
-            0 >= t < self.timesteps
+             0 <= t < self.timesteps
         ), f"Time step t={t} is out of bounds for scheduler with {self.timesteps} steps."
 
         if noise is None:

lt_tensor/processors/audio.py

@@ -26,15 +26,12 @@ class AudioProcessor(Model):
         mel_scale: Literal["htk", "slaney"] = "htk",
         std: int = 4,
         mean: int = -4,
-        inverse_transform_config: Union[
-            Dict[str, Union[Number, Tensor, bool]], InverseTransformConfig
-        ] = dict(n_fft=16, hop_length=4, win_length=16, center=True),
         n_iter: int = 32,
-        *__,
-        **_,
+        window: Optional[Tensor] = None,
+        normalized: bool =False,
+        onesided: Optional[bool] = None,
     ):
         super().__init__()
-        assert isinstance(inverse_transform_config, (InverseTransformConfig, dict))
         self.mean = mean
         self.std = std
         self.n_mels = n_mels
@@ -46,7 +43,8 @@ class AudioProcessor(Model):
         self.hop_length = hop_length or n_fft // 4
         self.win_length = win_length or n_fft
         self.sample_rate = sample_rate
-        self.mel_spec = torchaudio.transforms.MelSpectrogram(
+        self.center = center
+        self._mel_spec = torchaudio.transforms.MelSpectrogram(
             sample_rate=sample_rate,
             n_mels=n_mels,
             n_fft=n_fft,
@@ -71,14 +69,87 @@ class AudioProcessor(Model):
             win_length=win_length,
             hop_length=hop_length,
         )
-        if isinstance(inverse_transform_config, dict):
-            inverse_transform_config = InverseTransformConfig(
-                **inverse_transform_config
+        self.normalized = normalized
+        self.onesided = onesided
+
+        self.register_buffer(
+            "window",
+            (torch.hann_window(self.win_length) if window is None else window),
+        )
+        # self._inv_transform = InverseTransform(**inverse_transform_config.to_dict())
+
+    def inverse_transform(
+        self,
+        spec: Tensor,
+        phase: Tensor,
+        n_fft: Optional[int] = None,
+        hop_length: Optional[int] = None,
+        win_length: Optional[int] = None,
+        length: Optional[int] = None,
+        *,
+        _recall: bool = False,
+    ):
+        try:
+            return torch.istft(
+                spec * torch.exp(phase * 1j),
+                n_fft=n_fft or self.n_fft,
+                hop_length=hop_length or self.hop_length,
+                win_length=win_length or self.win_length,
+                window=torch.hann_window(win_length or self.win_length, device=spec.device),
+                center=self.center,
+                normalized=self.normalized,
+                onesided=self.onesided,
+                length=length,
+                return_complex=False,
             )
-        self._inv_transform = InverseTransform(**inverse_transform_config.to_dict())
+        except RuntimeError as e:
+            if not _recall and spec.device != self.window.device:
+                self.window = self.window.to(spec.device)
+                return self.inverse_transform(spec, phase, n_fft, hop_length, win_length, length, _recall=True)
+            raise e
 
-    def inverse_transform(self, spec: Tensor, phase: Tensor, *_, **kwargs):
-        return self._inv_transform(spec, phase, **kwargs)
+    def rebuild_spectrogram(
+        self,
+        wave: Tensor,
+        length: Optional[int] = None,
+        *,
+        _recall: bool = False,
+    ):
+        try:
+            spectrogram = torch.stft(
+                input=wave,
+                n_fft=self.n_fft,
+                hop_length=self.hop_length,
+                win_length=self.win_length,
+                window=self.window,
+                center=self.center,
+                pad_mode="reflect",
+                normalized=self.normalized,
+                onesided=self.onesided,
+                return_complex=True,  # needed for the istft
+            )
+            return torch.istft(
+                spectrogram
+                * torch.full(
+                    spectrogram.size(),
+                    fill_value=1,
+                    device=spectrogram.device,
+                ),
+                n_fft=self.n_fft,
+                hop_length=self.hop_length,
+                win_length=self.win_length,
+                window=self.window,
+                length=length,
+                center=self.center,
+                normalized=self.normalized,
+                onesided=self.onesided,
+                return_complex=False,
+            )
+        except RuntimeError as e:
+            if not _recall and wave.device != self.window.device:
+                self.window = self.window.to(wave.device)
+                return self.rebuild_spectrogram(wave, length, _recall=True)
+            raise e
 
     def compute_mel(
         self,
@@ -87,14 +158,14 @@ class AudioProcessor(Model):
         add_base: bool = True,
     ) -> Tensor:
         """Returns: [B, M, ML]"""
-        mel_tensor = self.mel_spec(wave.to(self.device))  # [M, ML]
+        mel_tensor = self._mel_spec(wave.to(self.device))  # [M, ML]
         if not add_base:
             return (mel_tensor - self.mean) / self.std
         return (
             (torch.log(base + mel_tensor.unsqueeze(0)) - self.mean) / self.std
         ).squeeze()
 
-    def reverse_mel(self, mel: Tensor, n_iter: Optional[int] = None):
+    def inverse_mel_spectogram(self, mel: Tensor, n_iter: Optional[int] = None):
         if isinstance(n_iter, int) and n_iter != self.n_iter:
             self.giffin_lim = torchaudio.transforms.GriffinLim(
                 n_fft=self.n_fft,
@@ -251,6 +322,6 @@ class AudioProcessor(Model):
         elif ap_task == "inv_transform":
             return self.inverse_transform(*inputs, **inputs_kwargs)
         elif ap_task == "revert_mel":
-            return self.reverse_mel(*inputs, **inputs_kwargs)
+            return self.inverse_mel_spectogram(*inputs, **inputs_kwargs)
         else:
             raise ValueError(f"Invalid task '{ap_task}'")

lt_tensor/transform.py

@@ -20,14 +20,14 @@ __all__ = [
     "stft_istft_rebuild",
 ]
 
-from .torch_commons import *
+from lt_tensor.torch_commons import *
 import torchaudio
 import math
-from .misc_utils import log_tensor
+from lt_tensor.misc_utils import log_tensor
 from lt_utils.common import *
 from lt_utils.misc_utils import cache_wrapper, default
 import torch.nn.functional as F
-from .model_base import Model
+from lt_tensor.model_base import Model
 import warnings
 
 
@@ -332,8 +332,8 @@ class InverseTransformConfig:
     def __init__(
         self,
         n_fft: int = 1024,
-        hop_length: Optional[int] = None,
         win_length: Optional[int] = None,
+        hop_length: Optional[int] = None,
         length: Optional[int] = None,
         window: Optional[Tensor] = None,
         onesided: Optional[bool] = None,
@@ -342,8 +342,8 @@ class InverseTransformConfig:
         center: bool = True,
     ):
         self.n_fft = n_fft
-        self.hop_length = hop_length
         self.win_length = win_length
+        self.hop_length = hop_length
         self.length = length
         self.onesided = onesided
         self.return_complex = return_complex
@@ -359,8 +359,8 @@ class InverseTransform(Model):
     def __init__(
         self,
         n_fft: int = 1024,
-        hop_length: Optional[int] = None,
         win_length: Optional[int] = None,
+        hop_length: Optional[int] = None,
         length: Optional[int] = None,
         window: Optional[Tensor] = None,
         onesided: Optional[bool] = None,
@@ -378,10 +378,10 @@ class InverseTransform(Model):
         ----------
         n_fft : int, optional
             Size of FFT to use during inversion. Default is 1024.
-        hop_length : int, optional
-            Number of audio samples between STFT columns. Defaults to `n_fft`.
         win_length : int, optional
             Size of the window function. Defaults to `n_fft // 4`.
+        hop_length : int, optional
+            Number of audio samples between STFT columns. Defaults to `n_fft`.
         length : int, optional
             Output waveform length. If not provided, length will be inferred.
         window : Tensor, optional
@@ -403,14 +403,8 @@ class InverseTransform(Model):
             Updates ISTFT parameters dynamically (used internally during forward).
         """
         super().__init__()
-        assert window is None or isinstance(window, Tensor)
-        assert any(
-            (
-                (not return_complex and not onesided),
-                (not onesided and return_complex),
-                (not return_complex and onesided),
-            )
-        )
+        assert window is None or isinstance(window, (Tensor, nn.Module))
+        assert not bool(return_complex and onesided)
         self.n_fft = n_fft
         self.length = length
         self.win_length = win_length or n_fft // 4
@@ -419,46 +413,9 @@ class InverseTransform(Model):
         self.return_complex = return_complex
         self.onesided = onesided
         self.normalized = normalized
-        self.window = torch.hann_window(win_length) if window is None else window
-        self.update_settings()
-        
-    def _apply_device_to(self):
-        """Applies to device while used with module `Model`"""
-        self.window = self.window.to(device=self.device)
-
-    def update_settings(
-        self,
-        *,
-        n_fft: Optional[int] = None,
-        hop_length: Optional[int] = None,
-        win_length: Optional[int] = None,
-        length: Optional[int] = None,
-        window: Optional[Tensor] = None,
-        onesided: Optional[bool] = None,
-        return_complex: Optional[bool] = None,
-        center: Optional[bool] = None,
-        normalized: Optional[bool] = None,
-        **_,
-    ):
-
-        self.kwargs = dict(
-            n_fft=default(n_fft, self.n_fft),
-            hop_length=default(hop_length, self.hop_length),
-            win_length=default(win_length, self.win_length),
-            length=default(length, self.length),
-            window=default(window, self.window),
-            onesided=default(onesided, self.onesided),
-            return_complex=default(return_complex, self.return_complex),
-            center=default(center, self.center),
-            normalized=default(normalized, self.normalized),
-        )
-        if self.kwargs["onesided"] and self.kwargs["return_complex"]:
-            warnings.warn(
-                "You cannot use return_complex with `onesided` enabled. `return_complex` is set to False."
-            )
-            self.kwargs["return_complex"] = False
+        self.register_buffer('window', torch.hann_window(self.win_length) if window is None else window)
 
-    def forward(self, spec: Tensor, phase: Tensor, **kwargs):
+    def forward(self, spec: Tensor, phase: Tensor, *, _recall:bool = False):
         """
         Perform the inverse short-time Fourier transform.
 
@@ -468,15 +425,27 @@ class InverseTransform(Model):
             Magnitude spectrogram of shape (batch, freq, time).
         phase : Tensor
             Phase angles tensor, same shape as `spec`, in radians.
-        **kwargs : dict, optional
-            Optional ISTFT override parameters (same as in `update_settings`).
 
         Returns
         -------
         Tensor
             Time-domain waveform reconstructed from `spec` and `phase`.
         """
-        if kwargs:
-            self.update_settings(**kwargs)
-
-        return torch.istft(spec * torch.exp(phase * 1j), **self.kwargs)
+        try:
+            return torch.istft(
+                spec * torch.exp(phase * 1j),
+                n_fft = self.n_fft,
+                hop_length=self.hop_length,
+                win_length=self.win_length,
+                window=self.window,
+                center=self.center,
+                normalized=self.normalized,
+                onesided=self.onesided,
+                length=self.length,
+                return_complex=self.return_complex,
+            )
+        except RuntimeError as e:
+            if not _recall and spec.device != self.window.device:
+                self.window = self.window.to(spec.device)
+                return self.forward(spec, phase, _recall=True)
+            raise e

{lt_tensor-0.0.1a10.dist-info → lt_tensor-0.0.1a12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a10
+Version: 0.0.1a12
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336
@@ -17,8 +17,9 @@ Requires-Dist: numpy>=1.26.4
 Requires-Dist: tokenizers
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: numba>0.60.0
-Requires-Dist: lt-utils==0.0.1
+Requires-Dist: lt-utils>=0.0.2a1
 Requires-Dist: librosa>=0.11.0
+Requires-Dist: plotly
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

lt_tensor-0.0.1a12.dist-info/RECORD

@@ -0,0 +1,32 @@
+lt_tensor/__init__.py,sha256=XxNCGcVL-haJyMpifr-GRaamo32R6jmqe3iOuS4ecfs,469
+lt_tensor/config_templates.py,sha256=FRN4-i1amoqMh_wyp4gNsw61ABWTIhGC62Uc3l3SNss,3515
+lt_tensor/losses.py,sha256=zvkCOnE5XpF3v6ymivRIdqPTsMM5zc94ZMom7YDi3zM,4946
+lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
+lt_tensor/math_ops.py,sha256=TkD4WQG42KsQ9Fg7FXOjf8f-ixtW0apf2XjaooecVx4,2257
+lt_tensor/misc_utils.py,sha256=kdZZrNpFLm5nxAao0j4YYI6rlUet_ZTuIeUJ-1wYvj0,27804
+lt_tensor/model_base.py,sha256=lxzRXfPlR_t_6LfgRw2dct55evrtmwTiDqZGAe3jLro,20026
+lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
+lt_tensor/noise_tools.py,sha256=wFeAsHhLhSlEc5XU5LbFKaXoHeVxrWjiMeljjGdIKyM,11363
+lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
+lt_tensor/transform.py,sha256=FGlpNrIZWn57zeqEKw6zKttOnE3di3bm9zk3zPAoHy8,13442
+lt_tensor/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lt_tensor/datasets/audio.py,sha256=o7qTBUznYwUlJtU5tsUY6uD7PkhqmK6VsFf0eF4k3Ww,4316
+lt_tensor/model_zoo/__init__.py,sha256=ZG2mFsDyR75Y5o2q2O4Vn1txI2DqBy-ZVrtyhu2zYfs,286
+lt_tensor/model_zoo/bsc.py,sha256=UvKHdO4KvDlI2820cFcbTnUka8WSmn0N_qs_U3Gu5JY,7064
+lt_tensor/model_zoo/disc.py,sha256=dS5UmJZV5MxIFiaBlIXfgGLDdUT3y0Vuv9lDGHsjJE8,5849
+lt_tensor/model_zoo/fsn.py,sha256=S1U-70AXpHdYEggaI_WWWZSGlp9qBebYzRaDXHhECFk,2118
+lt_tensor/model_zoo/gns.py,sha256=lNFmNP-It5JIhMDISUknD4HWwZCqX0Q0dIw9DhuUjps,6060
+lt_tensor/model_zoo/istft.py,sha256=AaojkrBR3v9VGwiLSbbObiYXnGuU7hD636Z0wjtNmxY,20234
+lt_tensor/model_zoo/pos.py,sha256=3d1EYLinCU9UAy-WuEWeYMGhMqaGknCiQ5qEmhw_UYM,4487
+lt_tensor/model_zoo/rsd.py,sha256=R2ZyNOzSI6kNKUHMqMURJ7jqNRQMlVzaXr4S1K4fvws,2907
+lt_tensor/model_zoo/tfrms.py,sha256=b2rRfD8ZFquD5wZKcZ_dGJ2enZ3exxdTrQE4GuPYc_o,4291
+lt_tensor/model_zoo/istft/__init__.py,sha256=SV96w9WUWfHMee8Vjgn2MP0igKft7_mLTju9rFVYGHY,102
+lt_tensor/model_zoo/istft/generator.py,sha256=rcA7pRyoflbvC__cbYpDFup3k4YyKFu3Ldi2F0rateM,5247
+lt_tensor/model_zoo/istft/trainer.py,sha256=cc5-YGT_GJ7py3aNnXuSHxAcXcDU6AaMh8hRAfYqvSs,15606
+lt_tensor/processors/__init__.py,sha256=4b9MxAJolXiJfSm20ZEspQTDm1tgLazwlPWA_jB1yLM,63
+lt_tensor/processors/audio.py,sha256=kQEiyVuiMXQ_zmOd_7XDW_xRwBnFnO9GpPU-FKP9B7Y,11204
+lt_tensor-0.0.1a12.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
+lt_tensor-0.0.1a12.dist-info/METADATA,sha256=lFa5SuofIHXBqyT-4wj0m3XPmsYrXe4NEUOJjM0fjZw,990
+lt_tensor-0.0.1a12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a12.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a12.dist-info/RECORD,,

lt_tensor-0.0.1a10.dist-info/RECORD

@@ -1,28 +0,0 @@
-lt_tensor/__init__.py,sha256=uwJ7uiO18VYj8Z1V4KSOQ3ZrnowSgJWKCIiFBrzLMOI,429
-lt_tensor/losses.py,sha256=TinZJP2ypZ7Tdg6d9nnFWFkPyormfgQ0Z9P2ER3sqzE,4341
-lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
-lt_tensor/math_ops.py,sha256=ewIYkvxIy_Lab_9ExjFUgLs-oYLOu8IRRDo7f1pn3i8,2248
-lt_tensor/misc_utils.py,sha256=N9Rf-i6m51Q3YYdmI5tI5Rb3wPz8OAJrTrLlqfCwWrk,24792
-lt_tensor/model_base.py,sha256=8qN7oklALFanOz-eqVzdnB9RD2kN_3ltynSMAPOl-TI,13413
-lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
-lt_tensor/noise_tools.py,sha256=JkWw0-bCMRNNMShwXKKt5KbO3104tvNiBePt-ThPkEo,11366
-lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
-lt_tensor/transform.py,sha256=Bxh87vFRKuZay_g1Alf_ZtEo89CzmV3XUQDINwHB7iA,14505
-lt_tensor/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lt_tensor/datasets/audio.py,sha256=YREyRsCvy-KS5tE0JNMWEdlIJogE1khLqhiq4wOWXVg,3777
-lt_tensor/model_zoo/__init__.py,sha256=jipEk50_DTMQbGg8FnDDukxmh7Bcwvl_QVRS3rkb7aY,283
-lt_tensor/model_zoo/bsc.py,sha256=muxIR7dU-Pvf-HFE-iy3zmRb1sTJlcs1vqdlnbU1Hss,6307
-lt_tensor/model_zoo/disc.py,sha256=SphFVVPZLP96-mZPEvWD_up2aT63rqSPjnps1-j9D6w,5707
-lt_tensor/model_zoo/fsn.py,sha256=5ySsg2OHjvTV_coPAdZQ0f7bz4ugJB8mDYsItmd61qA,2102
-lt_tensor/model_zoo/gns.py,sha256=Tirr_grONp_FFQ_L7K-zV2lvkaC39h8mMl4QDpx9vLQ,6028
-lt_tensor/model_zoo/istft.py,sha256=0Xms2QNPAgz_ib8XTfaWl1SCHgS53oKC6-EkDkl_qe4,4863
-lt_tensor/model_zoo/pos.py,sha256=N28v-rF8CELouYxQ9r45Jbd4ri5DNydwDgg7nzmQ4Ig,4471
-lt_tensor/model_zoo/rsd.py,sha256=5bba50g1Hm5kMexuJ4SwOIJuyQ1qJd8Acrq-Ax6CqE8,6958
-lt_tensor/model_zoo/tfrms.py,sha256=kauh-A13pk08SZ5OspEE5a-gPKD4rZr6tqMKWu3KGhk,4237
-lt_tensor/processors/__init__.py,sha256=4b9MxAJolXiJfSm20ZEspQTDm1tgLazwlPWA_jB1yLM,63
-lt_tensor/processors/audio.py,sha256=2Sta_KytTqGZh-ZeHpcCbqP6O8VT6QQVkx-7szA3Itc,8830
-lt_tensor-0.0.1a10.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
-lt_tensor-0.0.1a10.dist-info/METADATA,sha256=-VDQmGfkd5uW4_8B_TbwH-xvRivsGn3jWEtXTyeCT0s,966
-lt_tensor-0.0.1a10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a10.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a10.dist-info/RECORD,,