lt-tensor 0.0.1a13__py3-none-any.whl → 0.0.1a14__py3-none-any.whl

lt_tensor/misc_utils.py

@@ -240,7 +240,7 @@ class LogTensor:
     stored_items: List[
         Dict[str, Union[str, Number, Tensor, List[Union[Tensor, Number, str]]]]
     ] = []
-    max_stored_items: int = 32
+    max_stored_items: int = 8
 
     def _setup_message(self, title: str, t: Union[Tensor, str, int]):
         try:

lt_tensor/model_zoo/istft/generator.py

@@ -1,52 +1,7 @@
-__all__ = ["iSTFTGenerator", "ResBlocks"]
-import gc
-import math
-import itertools
+__all__ = ["iSTFTGenerator"]
 from lt_utils.common import *
 from lt_tensor.torch_commons import *
-from lt_tensor.model_base import Model
-from lt_tensor.misc_utils import log_tensor
-from lt_tensor.model_zoo.residual import ResBlock1D, ConvNets, get_weight_norm
-from lt_utils.misc_utils import log_traceback
-from lt_tensor.processors import AudioProcessor
-from lt_utils.type_utils import is_dir, is_pathlike
-from lt_tensor.misc_utils import set_seed, clear_cache
-from lt_tensor.model_zoo.discriminator import MultiPeriodDiscriminator, MultiScaleDiscriminator
-import torch.nn.functional as F
-from lt_tensor.config_templates import updateDict, ModelConfig
-
-
-class ResBlocks(ConvNets):
-    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)
+from lt_tensor.model_zoo.residual import ConvNets, ResBlocks
 
 
 class iSTFTGenerator(ConvNets):
@@ -91,19 +46,6 @@ class iSTFTGenerator(ConvNets):
         self.conv_post.apply(self.init_weights)
         self.reflection_pad = nn.ReflectionPad1d((1, 0))
 
-        self.phase = nn.Sequential(
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(self.post_n_fft, self.post_n_fft, kernel_size=3, padding=1),
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(self.post_n_fft, self.post_n_fft, kernel_size=3, padding=1),
-        )
-        self.spec = nn.Sequential(
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(self.post_n_fft, self.post_n_fft, kernel_size=3, padding=1),
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(self.post_n_fft, self.post_n_fft, kernel_size=3, padding=1),
-        )
-
     def _make_blocks(
         self,
         state: Tuple[int, int, int],
@@ -142,9 +84,7 @@ class iSTFTGenerator(ConvNets):
             x = block["up"](x)
             x = block["residual"](x)
 
-        x = self.reflection_pad(x)
-        x = self.conv_post(x)
-        spec = torch.exp(self.spec(x[:, : self.post_n_fft, :]))
-        phase = torch.sin(self.phase(x[:, self.post_n_fft :, :]))
-
+        x = self.conv_post(self.activation(self.reflection_pad(x)))
+        spec = torch.exp(x[:, : self.post_n_fft, :])
+        phase = torch.sin(x[:, self.post_n_fft :, :])
         return spec, phase

lt_tensor/model_zoo/istft/trainer.py

@@ -1,20 +1,20 @@
-__all__ = ["AudioSettings", "AudioDecoder"]
+__all__ = ["AudioSettings", "AudioDecoderTrainer", "AudioGeneratorOnlyTrainer"]
 import gc
-import math
 import itertools
 from lt_utils.common import *
 import torch.nn.functional as F
 from lt_tensor.torch_commons import *
 from lt_tensor.model_base import Model
-from lt_tensor.misc_utils import log_tensor
 from lt_utils.misc_utils import log_traceback
 from lt_tensor.processors import AudioProcessor
 from lt_tensor.misc_utils import set_seed, clear_cache
-from lt_utils.type_utils import is_dir, is_pathlike, is_file
-from lt_tensor.config_templates import updateDict, ModelConfig
+from lt_utils.type_utils import is_dir, is_pathlike
+from lt_tensor.config_templates import ModelConfig
 from lt_tensor.model_zoo.istft.generator import iSTFTGenerator
-from lt_tensor.model_zoo.residual import ResBlock1D, ConvNets, get_weight_norm
-from lt_tensor.model_zoo.discriminator import MultiPeriodDiscriminator, MultiScaleDiscriminator
+from lt_tensor.model_zoo.discriminator import (
+    MultiPeriodDiscriminator,
+    MultiScaleDiscriminator,
+)
 
 
 def feature_loss(fmap_r, fmap_g):
@@ -29,7 +29,6 @@ def generator_adv_loss(disc_outputs):
     loss = 0
     for dg in disc_outputs:
         l = torch.mean((1 - dg) ** 2)
-
         loss += l
     return loss
 
@@ -44,29 +43,6 @@ def discriminator_loss(disc_real_outputs, disc_generated_outputs):
     return loss
 
 
-"""def feature_loss(fmap_r, fmap_g):
-    loss = 0
-    for dr, dg in zip(fmap_r, fmap_g):
-        for rl, gl in zip(dr, dg):
-            loss += torch.mean(torch.abs(rl - gl))
-    return loss * 2
-
-
-def generator_adv_loss(fake_preds):
-    loss = 0.0
-    for f in fake_preds:
-        loss += torch.mean((f - 1.0) ** 2)
-    return loss
-
-
-def discriminator_loss(real_preds, fake_preds):
-    loss = 0.0
-    for r, f in zip(real_preds, fake_preds):
-        loss += torch.mean((r - 1.0) ** 2) + torch.mean(f**2)
-    return loss
-"""
-
-
 class AudioSettings(ModelConfig):
     def __init__(
         self,
@@ -107,12 +83,12 @@ class AudioSettings(ModelConfig):
         self.scheduler_template = scheduler_template
 
 
-class AudioDecoder(Model):
+class AudioDecoderTrainer(Model):
     def __init__(
         self,
         audio_processor: AudioProcessor,
         settings: Optional[AudioSettings] = None,
-        generator: Optional[Union[Model, "iSTFTGenerator"]] = None,  # non initalized!
+        generator: Optional[Union[Model, "iSTFTGenerator"]] = None,  # non initialized!
     ):
         super().__init__()
         if settings is None:
@@ -324,7 +300,7 @@ class AudioDecoder(Model):
         else:
             disc_out = self._discriminator_step(**disc_kwargs)
 
-        generato_kwargs = dict(
+        generator_kwargs = dict(
             mels=mels,
             real_audio=real_audio,
             fake_audio=fake_audio,
@@ -339,8 +315,8 @@ class AudioDecoder(Model):
 
         if is_generator_frozen:
             with torch.no_grad():
-                return self._generator_step(**generato_kwargs)
-        return self._generator_step(**generato_kwargs)
+                return self._generator_step(**generator_kwargs)
+        return self._generator_step(**generator_kwargs)
 
     def _discriminator_step(
         self,
@@ -349,7 +325,8 @@ class AudioDecoder(Model):
         am_i_frozen: bool = False,
     ):
         # ========== Discriminator Forward Pass ==========
-
+        if not am_i_frozen:
+            self.d_optim.zero_grad()
         # MPD
         real_mpd_preds, _ = self.mpd(real_audio)
         fake_mpd_preds, _ = self.mpd(fake_audio)
@@ -362,7 +339,6 @@ class AudioDecoder(Model):
         loss_d = loss_d_mpd + loss_d_msd
 
         if not am_i_frozen:
-            self.d_optim.zero_grad()
             loss_d.backward()
             self.d_optim.step()
 
@@ -384,6 +360,8 @@ class AudioDecoder(Model):
         am_i_frozen: bool = False,
     ):
         # ========== Generator Loss ==========
+        if not am_i_frozen:
+            self.g_optim.zero_grad()
         real_mpd_feats = self.mpd(real_audio)[1]
         real_msd_feats = self.msd(real_audio)[1]
 
@@ -403,11 +381,12 @@ class AudioDecoder(Model):
 
         loss_adv = (loss_adv_mpd + loss_adv_msd) * adv_scale
 
-        loss_g = loss_adv + loss_fm + loss_stft  # + loss_mel
+        loss_g = loss_adv + loss_fm + loss_stft + loss_mel
         if not am_i_frozen:
-            self.g_optim.zero_grad()
             loss_g.backward()
             self.g_optim.step()
+
+        lr_g, lr_d = self.get_lr()
         return {
             "loss_g": loss_g.item(),
             "loss_d": loss_d,
@@ -415,8 +394,8 @@ class AudioDecoder(Model):
             "loss_fm": loss_fm.item(),
             "loss_stft": loss_stft.item(),
             "loss_mel": loss_mel.item(),
-            "lr_g": self.g_optim.param_groups[0]["lr"],
-            "lr_d": self.d_optim.param_groups[0]["lr"],
+            "lr_g": lr_g,
+            "lr_d": lr_d,
         }
 
     def step_scheduler(
@@ -442,34 +421,198 @@ class AudioDecoder(Model):
             self.g_scheduler = self.settings.scheduler_template(self.g_optim)
 
 
-class ResBlocks(ConvNets):
+class AudioGeneratorOnlyTrainer(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),
+        audio_processor: AudioProcessor,
+        settings: Optional[AudioSettings] = None,
+        generator: Optional[Union[Model, "iSTFTGenerator"]] = None,  # non initialized!
     ):
         super().__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.rb = nn.ModuleList()
-        self.activation = activation
+        if settings is None:
+            self.settings = AudioSettings()
+        elif isinstance(settings, dict):
+            self.settings = AudioSettings(**settings)
+        elif isinstance(settings, AudioSettings):
+            self.settings = settings
+        else:
+            raise ValueError(
+                "Cannot initialize the waveDecoder with the given settings. "
+                "Use either a dictionary, or the class WaveSettings to setup the settings. "
+                "Alternatively, leave it None to use the default values."
+            )
+        if self.settings.seed is not None:
+            set_seed(self.settings.seed)
+        if generator is None:
+            generator = iSTFTGenerator
+        self.generator: iSTFTGenerator = generator(
+            in_channels=self.settings.in_channels,
+            upsample_rates=self.settings.upsample_rates,
+            upsample_kernel_sizes=self.settings.upsample_kernel_sizes,
+            upsample_initial_channel=self.settings.upsample_initial_channel,
+            resblock_kernel_sizes=self.settings.resblock_kernel_sizes,
+            resblock_dilation_sizes=self.settings.resblock_dilation_sizes,
+            n_fft=self.settings.n_fft,
+            activation=self.settings.activation,
+        )
+        self.generator.eval()
+        self.gen_training = False
+        self.audio_processor = audio_processor
+
+    def setup_training_mode(self, *args, **kwargs):
+        self.finish_training_setup()
+        self.update_schedulers_and_optimizer()
+        self.gen_training = True
+        return True
+
+    def update_schedulers_and_optimizer(self):
+        self.g_optim = optim.AdamW(
+            self.generator.parameters(),
+            lr=self.settings.lr,
+            betas=self.settings.adamw_betas,
+        )
+        self.g_scheduler = self.settings.scheduler_template(self.g_optim)
+
+    def set_lr(self, new_lr: float = 1e-4):
+        if self.g_optim is not None:
+            for groups in self.g_optim.param_groups:
+                groups["lr"] = new_lr
+        return self.get_lr()
+
+    def get_lr(self) -> Tuple[float, float]:
+        if self.g_optim is not None:
+            return self.g_optim.param_groups[0]["lr"]
+        return float("nan")
+
+    def save_weights(self, path, replace=True):
+        is_pathlike(path, check_if_empty=True, validate=True)
+        if str(path).endswith(".pt"):
+            path = Path(path).parent
+        else:
+            path = Path(path)
+        self.generator.save_weights(Path(path, "generator.pt"), replace)
+
+    def load_weights(
+        self,
+        path,
+        raise_if_not_exists=False,
+        strict=True,
+        assign=False,
+        weights_only=False,
+        mmap=None,
+        **torch_loader_kwargs
+    ):
+        is_pathlike(path, check_if_empty=True, validate=True)
+        if str(path).endswith(".pt"):
+            path = Path(path)
+        else:
+            path = Path(path, "generator.pt")
+
+        self.generator.load_weights(
+            path,
+            raise_if_not_exists,
+            strict,
+            assign,
+            weights_only,
+            mmap,
+            **torch_loader_kwargs,
+        )
+
+    def finish_training_setup(self):
+        gc.collect()
+        clear_cache()
+        self.eval()
+        self.gen_training = False
+
+    def forward(self, mel_spec: Tensor) -> Tuple[Tensor, Tensor]:
+        """Returns the generated spec and phase"""
+        return self.generator.forward(mel_spec)
+
+    def inference(
+        self,
+        mel_spec: Tensor,
+        return_dict: bool = False,
+    ) -> Union[Dict[str, Tensor], Tensor]:
+        spec, phase = super().inference(mel_spec)
+        wave = self.audio_processor.inverse_transform(
+            spec,
+            phase,
+            self.settings.n_fft,
+            hop_length=4,
+            win_length=self.settings.n_fft,
+        )
+        if not return_dict:
+            return wave[:, : wave.shape[-1] - 256]
+        return {
+            "wave": wave[:, : wave.shape[-1] - 256],
+            "spec": spec,
+            "phase": phase,
+        }
+
+    def set_device(self, device: str):
+        self.to(device=device)
+        self.generator.to(device=device)
+        self.audio_processor.to(device=device)
+        self.msd.to(device=device)
+        self.mpd.to(device=device)
+
+    def train_step(
+        self,
+        mels: Tensor,
+        real_audio: Tensor,
+        stft_scale: float = 1.0,
+        mel_scale: float = 1.0,
+        ext_loss: Optional[Callable[[Tensor, Tensor], Tensor]] = None,
+    ):
+        if not self.gen_training:
+            self.setup_training_mode()
+
+        self.g_optim.zero_grad()
+        spec, phase = self.generator.train_step(mels)
 
-        for k, j in zip(resblock_kernel_sizes, resblock_dilation_sizes):
-            self.rb.append(ResBlock1D(channels, k, j, activation))
+        real_audio = real_audio.squeeze(1)
+        with torch.no_grad():
+            fake_audio = self.audio_processor.inverse_transform(
+                spec,
+                phase,
+                self.settings.n_fft,
+                hop_length=4,
+                win_length=self.settings.n_fft,
+            )[:, : real_audio.shape[-1]]
+        loss_stft = self.audio_processor.stft_loss(fake_audio, real_audio) * stft_scale
+        loss_mel = (
+            F.huber_loss(self.audio_processor.compute_mel(fake_audio), mels) * mel_scale
+        )
+        loss_g.backward()
+        loss_g = loss_stft + loss_mel
+        loss_ext = 0
+
+        if ext_loss is not None:
+            l_ext = ext_loss(fake_audio, real_audio)
+            loss_g = loss_g + l_ext
+            loss_ext = l_ext.item()
 
-        self.rb.apply(self.init_weights)
+        self.g_optim.step()
+        return {
+            "loss": loss_g.item(),
+            "loss_stft": loss_stft.item(),
+            "loss_mel": loss_mel.item(),
+            "loss_ext": loss_ext,
+            "lr": self.get_lr(),
+        }
+
+    def step_scheduler(self):
 
-    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)
+        if self.g_scheduler is not None:
+            self.g_scheduler.step()
+
+    def reset_schedulers(self, lr: Optional[float] = None):
+        """
+        In case you have adopted another strategy, with this function,
+        it is possible restart the scheduler and set the lr to another value.
+        """
+        if lr is not None:
+            self.set_lr(lr)
+        if self.g_optim is not None:
+            self.g_scheduler = None
+            self.g_scheduler = self.settings.scheduler_template(self.g_optim)

lt_tensor/model_zoo/residual.py

@@ -5,13 +5,14 @@ __all__ = [
     "ResBlock2D",
     "ResBlock1DShuffled",
     "AdaResBlock1D",
+    "ResBlocks",
 ]
 import math
 from lt_utils.common import *
+import torch.nn.functional as F
 from lt_tensor.torch_commons import *
 from lt_tensor.model_base import Model
 from lt_tensor.misc_utils import log_tensor
-import torch.nn.functional as F
 from lt_tensor.model_zoo.fusion import AdaFusion1D, AdaIN1D
 
 
@@ -44,6 +45,40 @@ class ConvNets(Model):
             m.weight.data.normal_(mean, std)
 
 
+class ResBlocks(ConvNets):
+    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 x
+
+
+
 class ResBlock1D(ConvNets):
     def __init__(
         self,

lt_tensor/processors/audio.py

@@ -106,20 +106,13 @@ class AudioProcessor(Model):
         return tensor.detach().to(DEFAULT_DEVICE).numpy(force=True)
 
     def compute_rms(
-        self, audio: Union[Tensor, np.ndarray], mel: Optional[Tensor] = None
+        self,
+        audio: Union[Tensor, np.ndarray],
+        mel: Optional[Tensor] = None,
     ):
         default_dtype = audio.dtype
         default_device = audio.device
-        assert audio.ndim in [1, 2], (
-            f"Audio should have 1D for unbatched and 2D for batched"
-            ", received instead a: {audio.ndim}D"
-        )
-        if mel is not None:
-            assert mel.ndim in [2, 3], (
-                "Mel spectogram should have 2D dim for non-batched or 3D dim for both non-batched or batched"
-                f". Received instead {mel.ndim}D."
-            )
-        if audio.ndim == 2:
+        if audio.ndim > 1:
             B = audio.shape[0]
         else:
             B = 1
@@ -163,11 +156,7 @@ class AudioProcessor(Model):
     ):
         default_dtype = audio.dtype
         default_device = audio.device
-        assert audio.ndim in [1, 2], (
-            f"Audio should have 1D for unbatched and 2D for batched"
-            ", received instead a: {audio.ndim}D"
-        )
-        if audio.ndim == 2:
+        if audio.ndim > 1:
             B = audio.shape[0]
         else:
             B = 1

{lt_tensor-0.0.1a13.dist-info → lt_tensor-0.0.1a14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a13
+Version: 0.0.1a14
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336
@@ -17,7 +17,7 @@ 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.2a1
+Requires-Dist: lt-utils==0.0.2a2
 Requires-Dist: librosa==0.11.*
 Requires-Dist: einops
 Requires-Dist: plotly

{lt_tensor-0.0.1a13.dist-info → lt_tensor-0.0.1a14.dist-info}/RECORD

@@ -3,7 +3,7 @@ lt_tensor/config_templates.py,sha256=FRN4-i1amoqMh_wyp4gNsw61ABWTIhGC62Uc3l3SNss
 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=UNba6UEsAv1oZ60IAaKBNGbhXK2WPxRI9E4QcjP-_w0,28755
+lt_tensor/misc_utils.py,sha256=S57M5XuGsIuaOKnEGZJsY3B2dTmggpdhsqQr51CQsYo,28754
 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
@@ -17,16 +17,16 @@ lt_tensor/model_zoo/discriminator.py,sha256=dS5UmJZV5MxIFiaBlIXfgGLDdUT3y0Vuv9lD
 lt_tensor/model_zoo/features.py,sha256=CTFMidzza31pqQjwPfp_g0BNVfuQ8Dlo5JnxpYpKgag,13144
 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=knVLxzrLUjNQ6vdBESTZOk3r86ldi5PHetoBuJmymcw,6388
+lt_tensor/model_zoo/residual.py,sha256=3tc2fJaz6SxtKYAsxndahhwIxlN6oLk5tcdIXtUKaQc,7357
 lt_tensor/model_zoo/transformer.py,sha256=HUFoFFh7EQJErxdd9XIxhssdjvNVx2tNGDJOTUfwG2A,4301
 lt_tensor/model_zoo/istft/__init__.py,sha256=SV96w9WUWfHMee8Vjgn2MP0igKft7_mLTju9rFVYGHY,102
-lt_tensor/model_zoo/istft/generator.py,sha256=lotGkMu67fctzwa5FSwX_xtHILOuV95uP-djCz2N3C8,5261
+lt_tensor/model_zoo/istft/generator.py,sha256=wWHUfLFIItN-tB3pWkc1r9aTWpHYBFg7UfvLN4_cD78,3179
 lt_tensor/model_zoo/istft/sg.py,sha256=EaEi3otw_uY5QfqDBNIWBWTJSg3KnwzzR4FBr0u09C0,4838
-lt_tensor/model_zoo/istft/trainer.py,sha256=EPuGtvfgR8vCrVc72p5OwVy73nNVlx510VxnH3NeErY,16080
+lt_tensor/model_zoo/istft/trainer.py,sha256=KZXsAptOJeLYlr6t-DPX1qxgN526-2EBKoQQlcsHp8Y,21054
 lt_tensor/processors/__init__.py,sha256=4b9MxAJolXiJfSm20ZEspQTDm1tgLazwlPWA_jB1yLM,63
-lt_tensor/processors/audio.py,sha256=uBvMls4u_B1M-pk3xAiOIRnwM2l_3LcdfESNkE0Ch30,15314
-lt_tensor-0.0.1a13.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
-lt_tensor-0.0.1a13.dist-info/METADATA,sha256=yzNtg91vOGZCoXi6XWpn1kWk7LgVD2mIWQXL-7tw_Uc,1033
-lt_tensor-0.0.1a13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a13.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a13.dist-info/RECORD,,
+lt_tensor/processors/audio.py,sha256=SMqNSl4Den-x1awTCQ8-TcR-0jPiv5lDaUpU93SRRaw,14749
+lt_tensor-0.0.1a14.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
+lt_tensor-0.0.1a14.dist-info/METADATA,sha256=mxwJTAo51GfGEEW87lT-Tp1AHtoRvuKCmcPxAyqJxLQ,1033
+lt_tensor-0.0.1a14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a14.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a14.dist-info/RECORD,,