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

lt_tensor/misc_utils.py

@@ -18,8 +18,11 @@ __all__ = [
     "Packing",
     "Padding",
     "Masking",
+    "LogTensor",
+    "get_losses",
 ]
 
+import re
 import gc
 import sys
 import random
@@ -28,9 +31,20 @@ from lt_utils.type_utils import is_str
 from .torch_commons import *
 from lt_utils.misc_utils import cache_wrapper
 from lt_utils.common import *
+from lt_utils.misc_utils import ff_list
 import torch.nn.functional as F
 
 
+def try_torch(fn: str, *args, **kwargs):
+    try:
+        return getattr(F, fn)(*args, **kwargs)
+    except Exception as e:
+        try:
+            return getattr(torch, fn)(*args, **kwargs)
+        except Exception as e:
+            return str(e)
+
+
 def log_tensor(
     item: Union[Tensor, np.ndarray],
     title: Optional[str] = None,
@@ -70,6 +84,210 @@ def log_tensor(
     sys.stdout.flush()
 
 
+def get_losses(base: Tensor, target: Tensor, return_valid_only: bool = False):
+    losses = {}
+    losses["mse_loss"] = try_torch("mse_loss", base, target)
+    losses["l1_loss"] = try_torch("l1_loss", base, target)
+    losses["huber_loss"] = try_torch("huber_loss", base, target)
+    losses["poisson_nll_loss"] = try_torch("poisson_nll_loss", base, target)
+    losses["smooth_l1_loss"] = try_torch("smooth_l1_loss", base, target)
+    losses["cross_entropy"] = try_torch("cross_entropy", base, target)
+    losses["soft_margin_loss"] = try_torch("soft_margin_loss", base, target)
+    losses["nll_loss"] = try_torch("nll_loss", base, target)
+    losses["gaussian_nll_loss"] = try_torch("gaussian_nll_loss", base, target, var=1.0)
+    losses["gaussian_nll_loss-var_0.25"] = try_torch(
+        "gaussian_nll_loss", base, target, var=0.25
+    )
+    losses["gaussian_nll_loss-var_4.0"] = try_torch(
+        "gaussian_nll_loss", base, target, var=4.0
+    )
+    if not return_valid_only:
+        return losses
+    valid = {}
+    for name, loss in losses.items():
+        if isinstance(loss, str):
+            continue
+        valid[name] = loss
+    return valid
+
+
+class LogTensor:
+    negative_slope = 0.1
+    do_print: bool = True
+    end_with: str = "\n"
+    stored_items: List[
+        Dict[str, Union[str, Number, Tensor, List[Union[Tensor, Number, str]]]]
+    ] = []
+    max_stored_items: int = 32
+
+    def _setup_message(self, title: str, t: Union[Tensor, str, int]):
+        try:
+            if isinstance(t, Tensor):
+                try:
+                    message = f"{title}: {t}"
+                    if t.ndim == 0 and t.shape[0] == 1:
+                        message = f"{title}: {t.item():.5f}"
+                    elif t.ndim == 1 and t.shape[-1] == 1:
+                        message = f"{title}: {t[-1].item():.5f}"
+                    else:
+                        message = f"{title}: {t.item()}"
+                except:
+                    message = f"{title}: {t}"
+            else:
+                t = str(t).replace("\n", " ")
+                t = (
+                    re.sub(r"\s+", " ", t)
+                    .replace("( ", "(")
+                    .replace("[ ", "[")
+                    .replace(" ]", "]")
+                    .replace(" )", ")")
+                )
+                message = f"{title}: {t}"
+        except Exception as e:
+            message = f"{title}: {e}"
+        return message
+
+    def _print(self, message: str):
+        if self.do_print:
+            print(message)
+            sys.stdout.flush()
+
+    def _process(
+        self,
+        name: str,
+        resp: Union[Callable[[Any], Any], Any],
+        do_not_print: bool = False,
+    ):
+        if callable(resp):
+            try:
+                response = resp()
+            except Exception as e:
+                response = str(e)
+                print(e)
+        else:
+            response = resp
+        if not do_not_print and self.do_print:
+            msg = self._setup_message(name, response)
+            self._print(msg)
+        return dict(item=name, value=response)
+
+    def __call__(
+        self,
+        inputs: Union[Tensor, np.ndarray, Sequence[Number]],
+        title: Optional[str] = None,
+        target: Optional[Union[Tensor, np.ndarray, Sequence[Number]]] = None,
+        *,
+        log_tensor: bool = False,
+        log_device: bool = False,
+        log_mean: bool = False,
+        log_std: bool = False,
+        dim_mean: int = -1,
+        dim_std: int = -1,
+        print_extended: bool = False,
+        external_logs: List[Tuple[str, Union[Dict[str, Any], List[Any], Any]]] = [
+            ("softmax", {"dim": 0}),
+            ("relu", None),
+            ("leaky_relu", [0.1]),
+            ("min", 0),
+            ("max", dict(dim=-1)),
+        ],
+        validate_item_type: bool = False,
+        **kwargs,
+    ):
+        invalid_type = not isinstance(inputs, (Tensor, np.ndarray, list, tuple))
+        _main_item_tp = type(inputs)
+        assert (
+            not validate_item_type or not invalid_type
+        ), f"Invalid Type: {_main_item_tp}"
+        if invalid_type:
+            self._print(f"Invalid Type: {_main_item_tp}")
+            return
+
+        inputs = self._setup_tensor(inputs)
+        target = self._setup_tensor(target)
+        if is_str(title):
+            title = re.sub(r"\s+", " ", title.replace("_", " "))
+            has_title = is_str(title)
+            if has_title:
+                self._print("========[ " + title.title() + " ]========")
+        else:
+            title = "Unnamed"
+
+        current_register = {"title": title, "values": []}
+        current_register["shape"] = self._process("shape", inputs.shape)
+        current_register["ndim"] = self._process("ndim", inputs.ndim)
+        current_register["dtype"] = self._process("dtype", inputs.dtype)
+        if log_device:
+            current_register["device"] = self._process("device", inputs.device)
+
+        if log_mean:
+            fn = lambda: inputs.mean(
+                dim=dim_mean,
+            )
+            current_register["mean"] = self._process("mean", fn)
+
+        if log_std:
+            fn = lambda: inputs.std(dim=dim_std)
+            current_register["std"] = self._process("std", fn)
+
+        if external_logs:
+            old_print = self.do_print
+            self.do_print = print_extended
+            self._print("\n---[ External Logs ] ---")
+            for log_fn, log_args in external_logs:
+                if isinstance(log_args, Sequence) and not isinstance(log_args, str):
+                    value = try_torch(log_fn, inputs, *log_args)
+                elif isinstance(log_args, dict):
+                    value = try_torch(log_fn, inputs, **log_args)
+                elif log_args is None:
+                    value = try_torch(log_fn, inputs)
+                else:
+                    value = try_torch(log_fn, inputs, log_args)
+                results = self._process(log_fn, value)
+                current_register[log_fn] = results
+            self.do_print = old_print
+
+        if target is not None:
+            losses = get_losses(inputs, target, False)
+            started_ls = False
+            if self.do_print:
+                for loss, res in losses.items():
+                    if isinstance(res, str):
+                        continue
+                    if not started_ls:
+                        self._print("\n---[ Losses ] ---")
+                        started_ls = True
+                    self._print(f"{loss}: {res:.5f}")
+            current_register["loss"] = losses
+
+        if log_tensor:
+            current_register["values"].append(
+                self._process("Tensor", inputs, not print_extended)
+            )
+
+        self._print(self.end_with)
+        self._store_item_and_update(current_register)
+        return current_register
+
+    def _store_item_and_update(self, current_register: Dict[str, Any]):
+        self.stored_items.append(current_register.copy())
+        self.stored_items = self.stored_items[-self.max_stored_items :]
+
+    def _setup_tensor(self, itm):
+        if isinstance(itm, (list, tuple)):
+            try:
+                itm = torch.tensor(itm)
+            except:
+                itm = torch.tensor(ff_list(itm))
+        elif isinstance(itm, np.ndarray):
+            itm = torch.from_numpy(itm)
+        elif isinstance(itm, Tensor):
+            itm = itm.detach().cpu()
+        else:
+            itm = None
+        return itm
+
+
 def set_seed(seed: int):
     """Set random seed for reproducibility."""
     torch.manual_seed(seed)

lt_tensor/model_zoo/disc.py

@@ -17,7 +17,7 @@ class PeriodDiscriminator(Model):
         self.stride = stride
         self.kernel_size = kernel_size
         self.norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        
+
         self.channels = [32, 128, 512, 1024, 1024]
         self.first_pass = nn.Sequential(
             self.norm_f(
@@ -28,14 +28,18 @@ class PeriodDiscriminator(Model):
             nn.LeakyReLU(0.1),
         )
 
-        
-        self.convs = nn.ModuleList([self._get_next(self.channels[i+1], self.channels[i], i == 3) for i in range(4)])
+        self.convs = nn.ModuleList(
+            [
+                self._get_next(self.channels[i + 1], self.channels[i], i == 3)
+                for i in range(4)
+            ]
+        )
 
         self.post_conv = nn.Conv2d(1024, 1, (stride, 1), 1, padding=(1, 0))
 
-    def _get_next(self, out_dim:int, last_in:int, is_last: bool = False):
+    def _get_next(self, out_dim: int, last_in: int, is_last: bool = False):
         stride = (self.stride, 1) if not is_last else 1
-        
+
         return nn.Sequential(
             self.norm_f(
                 nn.Conv2d(
@@ -152,4 +156,37 @@ class GeneralLossDescriminator(Model):
         pass
 
     def forward(self, x: Tensor, y_hat: Tensor):
-        return
+        return
+
+
+def discriminator_loss(d_outputs_real, d_outputs_fake):
+    loss = 0.0
+    for real_out, fake_out in zip(d_outputs_real, d_outputs_fake):
+        real_score = real_out[0]
+        fake_score = fake_out[0]
+        loss += torch.mean(F.relu(1.0 - real_score)) + torch.mean(
+            F.relu(1.0 + fake_score)
+        )
+    return loss
+
+
+def generator_adv_loss(d_outputs_fake):
+    loss = 0.0
+    for fake_out in d_outputs_fake:
+        fake_score = fake_out[0]
+        loss += -torch.mean(fake_score)
+    return loss
+
+
+def feature_matching_loss(
+    d_outputs_real,
+    d_outputs_fake,
+    loss_fn: Callable[[Tensor, Tensor], Tensor] = F.mse_loss,
+):
+    loss = 0.0
+    for real_out, fake_out in zip(d_outputs_real, d_outputs_fake):
+        real_feats = real_out[1]
+        fake_feats = fake_out[1]
+        for real_f, fake_f in zip(real_feats, fake_feats):
+            loss += loss_fn(fake_f, real_f)
+    return loss

lt_tensor/processors/audio.py

@@ -22,7 +22,6 @@ class AudioProcessor(Model):
         hop_length: Optional[int] = None,
         f_min: float = 0,
         f_max: float | None = None,
-        n_iter: int = 32,
         center: bool = True,
         mel_scale: Literal["htk", "slaney"] = "htk",
         std: int = 4,
@@ -30,6 +29,7 @@ class AudioProcessor(Model):
         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,
         *__,
         **_,
     ):
@@ -81,16 +81,18 @@ class AudioProcessor(Model):
         return self._inv_transform(spec, phase, **kwargs)
 
     def compute_mel(
-        self, wave: Tensor, base: float = 1e-6, add_base: bool = False
+        self,
+        wave: Tensor,
+        base: float = 1e-5,
+        add_base: bool = True,
     ) -> Tensor:
         """Returns: [B, M, ML]"""
-        wave_device = wave.device
         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).to(
-            device=wave_device
-        )
+        return (
+            (torch.log(base + mel_tensor.unsqueeze(0)) - self.mean) / self.std
+        ).squeeze()
 
     def reverse_mel(self, mel: Tensor, n_iter: Optional[int] = None):
         if isinstance(n_iter, int) and n_iter != self.n_iter:
@@ -167,9 +169,70 @@ class AudioProcessor(Model):
                     break
         return results
 
-    def stft_loss(self, signal: Tensor, ground: Tensor, base: float = 1e-5):
-        sig_mel = self(signal, base)
-        gnd_mel = self(ground, base)
+    def slice_mismatch_outputs(
+        self,
+        tensor_1: Tensor,
+        tensor_2: Tensor,
+        smallest_size: Optional[int] = None,
+        left_to_right: bool = True,
+    ):
+        assert tensor_1.ndim == tensor_2.ndim, (
+            "Tensors must have the same dimentions to be sliced! \n"
+            f"Received instead a tensor_1 with {tensor_1.ndim}D and tensor_2 with {tensor_1.ndim}D."
+        )
+        dim = tensor_1.ndim
+        assert dim < 5, (
+            "Excpected to receive tensors with from 1D up to 4D. "
+            f"Received instead a {dim}D tensor."
+        )
+
+        if tensor_1.shape[-1] == tensor_2.shape[-1]:
+            return tensor_1, tensor_2
+
+        if smallest_size is None:
+            smallest_size = min(tensor_1.shape[-1], tensor_2.shape[-1])
+        if dim == 0:
+            tensor_1 = tensor_1.unsqueeze(0)
+            tensor_2 = tensor_2.unsqueeze(0)
+            dim = 1
+
+        if dim == 1:
+            if left_to_right:
+                return tensor_1[:smallest_size], tensor_2[:smallest_size]
+            return tensor_1[-smallest_size:], tensor_2[-smallest_size:]
+        elif dim == 2:
+            if left_to_right:
+                return tensor_1[:, :smallest_size], tensor_2[:, :smallest_size]
+            return tensor_1[:, -smallest_size:], tensor_2[:, -smallest_size:]
+        elif dim == 3:
+            if left_to_right:
+                return tensor_1[:, :, :smallest_size], tensor_2[:, :, :smallest_size]
+            return tensor_1[:, :, -smallest_size:], tensor_2[:, :, -smallest_size:]
+
+        # else:
+        if left_to_right:
+            return (
+                tensor_1[:, :, :, :smallest_size],
+                tensor_2[:, :, :, :smallest_size],
+            )
+        return (
+            tensor_1[:, :, :, -smallest_size:],
+            tensor_2[:, :, :, -smallest_size:],
+        )
+
+    def stft_loss(
+        self,
+        signal: Tensor,
+        ground: Tensor,
+        slice_mismatch: bool = True,
+        base: float = 1e-5,
+    ):
+        if slice_mismatch:
+            smallest = min(signal.shape[-1], ground.shape[-1])
+            signal = signal[:, -smallest:]
+            ground = ground[:, -smallest:]
+        sig_mel = self.compute_mel(signal, base, True).detach().cpu()
+        gnd_mel = self.compute_mel(ground, base, True).detach().cpu()
         return torch.norm(gnd_mel - sig_mel, p=1) / torch.norm(gnd_mel, p=1)
 
     # def forward(self, wave: Tensor, base: Optional[float] = None):

lt_tensor/transform.py

@@ -415,12 +415,13 @@ class InverseTransform(Model):
         self.length = length
         self.win_length = win_length or n_fft // 4
         self.hop_length = hop_length or n_fft
-        self.center = center // 4
+        self.center = center
         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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a8
+Version: 0.0.1a10
 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.1a8.dist-info → lt_tensor-0.0.1a10.dist-info}/RECORD

@@ -2,17 +2,17 @@ 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=sjWUkUaHFhaCdN4rZ6X-cQDbPieimfKchKq9VtjiwEA,17029
+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=va4bQjpfhH-tnaBDvJZpmYmfg9zwn5_Y6pPOoTswS-U,14471
+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=jZPhoSV1hlrba3ohXGutYAAcSl4pWkqGYFpOlOoN3eo,4740
+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
@@ -20,9 +20,9 @@ lt_tensor/model_zoo/pos.py,sha256=N28v-rF8CELouYxQ9r45Jbd4ri5DNydwDgg7nzmQ4Ig,44
 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=ljnRCqNzNJrab_uGxTOw_ULat_ilv_AMlN9eCDO9dwA,6674
-lt_tensor-0.0.1a8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lt_tensor-0.0.1a8.dist-info/METADATA,sha256=dMWV6z5ErsabfuIIPXzgZsmm92xrDvhYrzS80MdK-SY,965
-lt_tensor-0.0.1a8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a8.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a8.dist-info/RECORD,,
+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,,

{lt_tensor-0.0.1a8.dist-info → lt_tensor-0.0.1a10.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [2025] [gr1336 (Gabriel Ribeiro)]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.