lt-tensor 0.0.1a33__tar.gz → 0.0.1a34__tar.gz

{lt_tensor-0.0.1a33 → lt_tensor-0.0.1a34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a33
+Version: 0.0.1a34
 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.1a33 → lt_tensor-0.0.1a34}/lt_tensor/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.1a33"
+__version__ = "0.0.1a34"
 
 from . import (
     lr_schedulers,

lt_tensor-0.0.1a34/lt_tensor/losses.py

@@ -0,0 +1,277 @@
+__all__ = [
+    "masked_cross_entropy",
+    "adaptive_l1_loss",
+    "contrastive_loss",
+    "smooth_l1_loss",
+    "hybrid_loss",
+    "diff_loss",
+    "cosine_loss",
+    "ft_n_loss",
+    "MultiMelScaleLoss",
+]
+import math
+import random
+from lt_tensor.torch_commons import *
+from lt_utils.common import *
+import torch.nn.functional as F
+from lt_tensor.model_base import Model
+from lt_tensor.processors import AudioProcessor, AudioProcessorConfig
+from lt_tensor.math_ops import normalize_minmax, normalize_unit_norm, normalize_zscore
+
+
+def ft_n_loss(output: Tensor, target: Tensor, weight: Optional[Tensor] = None):
+    if weight is not None:
+        return torch.mean((torch.abs(output - target) + weight) ** 0.5)
+    return torch.mean(torch.abs(output - target) ** 0.5)
+
+
+def adaptive_l1_loss(
+    inp: Tensor,
+    tgt: Tensor,
+    weight: Optional[Tensor] = None,
+    scale: float = 1.0,
+    inverted: bool = False,
+):
+
+    if weight is not None:
+        loss = torch.mean(torch.abs((inp - tgt) + weight.mean()))
+    else:
+        loss = torch.mean(torch.abs(inp - tgt))
+    loss *= scale
+    if inverted:
+        return -loss
+    return loss
+
+
+def smooth_l1_loss(inp: Tensor, tgt: Tensor, beta=1.0, weight=None):
+    diff = torch.abs(inp - tgt)
+    loss = torch.where(diff < beta, 0.5 * diff**2 / beta, diff - 0.5 * beta)
+    if weight is not None:
+        loss *= weight
+    return loss.mean()
+
+
+def contrastive_loss(x1: Tensor, x2: Tensor, label: Tensor, margin: float = 1.0):
+    # label == 1: similar, label == 0: dissimilar
+    dist = torch.nn.functional.pairwise_distance(x1, x2)
+    loss = label * dist**2 + (1 - label) * torch.clamp(margin - dist, min=0.0) ** 2
+    return loss.mean()
+
+
+def cosine_loss(inp, tgt):
+    cos = torch.nn.functional.cosine_similarity(inp, tgt, dim=-1)
+    return 1 - cos.mean()  # Lower is better
+
+
+def masked_cross_entropy(
+    logits: torch.Tensor,  # [B, T, V]
+    targets: torch.Tensor,  # [B, T]
+    lengths: torch.Tensor,  # [B]
+    reduction: str = "mean",
+) -> torch.Tensor:
+    """
+    CrossEntropyLoss with masking for variable-length sequences.
+    - logits: unnormalized scores [B, T, V]
+    - targets: ground truth indices [B, T]
+    - lengths: actual sequence lengths [B]
+    """
+    B, T, V = logits.size()
+    logits = logits.view(-1, V)
+    targets = targets.view(-1)
+
+    # Create mask
+    mask = torch.arange(T, device=lengths.device).expand(B, T) < lengths.unsqueeze(1)
+    mask = mask.reshape(-1)
+
+    # Apply CE only where mask == True
+    loss = F.cross_entropy(
+        logits[mask], targets[mask], reduction="mean" if reduction == "mean" else "none"
+    )
+    if reduction == "none":
+        return loss
+    return loss
+
+
+def diff_loss(pred_noise, true_noise, mask=None):
+    """Standard diffusion noise-prediction loss (e.g., DDPM)"""
+    if mask is not None:
+        return F.mse_loss(pred_noise * mask, true_noise * mask)
+    return F.mse_loss(pred_noise, true_noise)
+
+
+def hybrid_diff_loss(pred_noise, true_noise, alpha=0.5):
+    """Combines L1 and L2"""
+    l1 = F.l1_loss(pred_noise, true_noise)
+    l2 = F.mse_loss(pred_noise, true_noise)
+    return alpha * l1 + (1 - alpha) * l2
+
+
+def gan_d_loss(real_preds, fake_preds, use_lsgan=True):
+    loss = 0
+    for real, fake in zip(real_preds, fake_preds):
+        if use_lsgan:
+            loss += F.mse_loss(real, torch.ones_like(real)) + F.mse_loss(
+                fake, torch.zeros_like(fake)
+            )
+        else:
+            loss += -torch.mean(torch.log(real + 1e-7)) - torch.mean(
+                torch.log(1 - fake + 1e-7)
+            )
+    return loss
+
+
+class MultiMelScaleLoss(Model):
+    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],
+        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,
+        use_istft_norm: bool = True,
+        use_pitch_loss: bool = True,
+        use_rms_loss: bool = True,
+        norm_pitch_fn: Callable[[Tensor], Tensor] = normalize_unit_norm,
+        norm_rms_fn: Callable[[Tensor], Tensor] = normalize_unit_norm,
+        lambda_mel: float = 1.0,
+        lambda_rms: float = 1.0,
+        lambda_pitch: float = 1.0,
+        weight: float = 1.0,
+    ):
+        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.use_pitch_loss = use_pitch_loss
+        self.use_rms_loss = use_rms_loss
+        self.lambda_pitch = lambda_pitch
+        self.lambda_rms = lambda_rms
+
+        self.norm_pitch_fn = norm_pitch_fn
+        self.norm_rms = norm_rms_fn
+
+        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,
+        onesided: Optional[bool],
+        std: int,
+        mean: int,
+    ):
+        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 forward(
+        self, input_wave: torch.Tensor, target_wave: torch.Tensor
+    ) -> torch.Tensor:
+        assert self.use_istft_norm or input_wave.shape[-1] == target_wave.shape[-1]
+        target_wave = target_wave.to(input_wave.device)
+        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 = self.norm_pitch_fn(M.compute_pitch(input_proc))
+                y_pitch = self.norm_pitch_fn(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 = self.norm_rms(M.compute_rms(input_proc, x_mels))
+                y_rms = self.norm_rms(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 → lt_tensor-0.0.1a34}/lt_tensor/model_zoo/losses/discriminators.py

@@ -82,23 +82,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)
 
@@ -637,179 +620,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 → lt_tensor-0.0.1a34}/lt_tensor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a33
+Version: 0.0.1a34
 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.1a33 → lt_tensor-0.0.1a34}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as f:
     long_description = f.read()
 
 setup(
-    version="0.0.1a33",
+    version="0.0.1a34",
     name="lt-tensor",
     description="General utilities for PyTorch and others. Built for general use.",
     long_description=long_description,

lt_tensor-0.0.1a33/lt_tensor/losses.py

@@ -1,159 +0,0 @@
-__all__ = [
-    "masked_cross_entropy",
-    "adaptive_l1_loss",
-    "contrastive_loss",
-    "smooth_l1_loss",
-    "hybrid_loss",
-    "diff_loss",
-    "cosine_loss",
-    "gan_loss",
-    "ft_n_loss",
-]
-import math
-import random
-from lt_tensor.torch_commons import *
-from lt_utils.common import *
-import torch.nn.functional as F
-
-def ft_n_loss(output: Tensor, target: Tensor, weight: Optional[Tensor] = None):
-    if weight is not None:
-        return torch.mean((torch.abs(output - target) + weight) **0.5)
-    return torch.mean(torch.abs(output - target)**0.5)
-
-def adaptive_l1_loss(
-    inp: Tensor,
-    tgt: Tensor,
-    weight: Optional[Tensor] = None,
-    scale: float = 1.0,
-    inverted: bool = False,
-):
-
-    if weight is not None:
-        loss = torch.mean(torch.abs((inp - tgt) + weight.mean()))
-    else:
-        loss = torch.mean(torch.abs(inp - tgt))
-    loss *= scale
-    if inverted:
-        return -loss
-    return loss
-
-
-def smooth_l1_loss(inp: Tensor, tgt: Tensor, beta=1.0, weight=None):
-    diff = torch.abs(inp - tgt)
-    loss = torch.where(diff < beta, 0.5 * diff**2 / beta, diff - 0.5 * beta)
-    if weight is not None:
-        loss *= weight
-    return loss.mean()
-
-
-def contrastive_loss(x1: Tensor, x2: Tensor, label: Tensor, margin: float = 1.0):
-    # label == 1: similar, label == 0: dissimilar
-    dist = torch.nn.functional.pairwise_distance(x1, x2)
-    loss = label * dist**2 + (1 - label) * torch.clamp(margin - dist, min=0.0) ** 2
-    return loss.mean()
-
-
-def cosine_loss(inp, tgt):
-    cos = torch.nn.functional.cosine_similarity(inp, tgt, dim=-1)
-    return 1 - cos.mean()  # Lower is better
-
-
-class GanLosses:
-    @staticmethod
-    def get_loss(
-        pred: Tensor,
-        target_is_real: bool,
-        loss_type: Literal["bce", "mse", "hinge", "wasserstein"] = "bce",
-    ) -> Tensor:
-        if loss_type == "bce":  # Standard GAN
-            target = torch.ones_like(pred) if target_is_real else torch.zeros_like(pred)
-            return F.binary_cross_entropy_with_logits(pred, target)
-
-        elif loss_type == "mse":  # LSGAN
-            target = torch.ones_like(pred) if target_is_real else torch.zeros_like(pred)
-            return F.mse_loss(torch.sigmoid(pred), target)
-
-        elif loss_type == "hinge":
-            if target_is_real:
-                return torch.mean(F.relu(1.0 - pred))
-            else:
-                return torch.mean(F.relu(1.0 + pred))
-
-        elif loss_type == "wasserstein":
-            return -pred.mean() if target_is_real else pred.mean()
-
-        else:
-            raise ValueError(f"Unknown loss_type: {loss_type}")
-
-    @staticmethod
-    def generator_loss(fake_pred: Tensor, loss_type: str = "bce") -> Tensor:
-        return GanLosses.get_loss(fake_pred, target_is_real=True, loss_type=loss_type)
-
-    @staticmethod
-    def discriminator_loss(
-        real_pred: Tensor, fake_pred: Tensor, loss_type: str = "bce"
-    ) -> Tensor:
-        real_loss = GanLosses.get_loss(
-            real_pred, target_is_real=True, loss_type=loss_type
-        )
-        fake_loss = GanLosses.get_loss(
-            fake_pred.detach(), target_is_real=False, loss_type=loss_type
-        )
-        return (real_loss + fake_loss) * 0.5
-
-
-def masked_cross_entropy(
-    logits: torch.Tensor,  # [B, T, V]
-    targets: torch.Tensor,  # [B, T]
-    lengths: torch.Tensor,  # [B]
-    reduction: str = "mean",
-) -> torch.Tensor:
-    """
-    CrossEntropyLoss with masking for variable-length sequences.
-    - logits: unnormalized scores [B, T, V]
-    - targets: ground truth indices [B, T]
-    - lengths: actual sequence lengths [B]
-    """
-    B, T, V = logits.size()
-    logits = logits.view(-1, V)
-    targets = targets.view(-1)
-
-    # Create mask
-    mask = torch.arange(T, device=lengths.device).expand(B, T) < lengths.unsqueeze(1)
-    mask = mask.reshape(-1)
-
-    # Apply CE only where mask == True
-    loss = F.cross_entropy(
-        logits[mask], targets[mask], reduction="mean" if reduction == "mean" else "none"
-    )
-    if reduction == "none":
-        return loss
-    return loss
-
-
-def diff_loss(pred_noise, true_noise, mask=None):
-    """Standard diffusion noise-prediction loss (e.g., DDPM)"""
-    if mask is not None:
-        return F.mse_loss(pred_noise * mask, true_noise * mask)
-    return F.mse_loss(pred_noise, true_noise)
-
-
-def hybrid_diff_loss(pred_noise, true_noise, alpha=0.5):
-    """Combines L1 and L2"""
-    l1 = F.l1_loss(pred_noise, true_noise)
-    l2 = F.mse_loss(pred_noise, true_noise)
-    return alpha * l1 + (1 - alpha) * l2
-
-
-def gan_d_loss(real_preds, fake_preds, use_lsgan=True):
-    loss = 0
-    for real, fake in zip(real_preds, fake_preds):
-        if use_lsgan:
-            loss += F.mse_loss(real, torch.ones_like(real)) + F.mse_loss(
-                fake, torch.zeros_like(fake)
-            )
-        else:
-            loss += -torch.mean(torch.log(real + 1e-7)) - torch.mean(
-                torch.log(1 - fake + 1e-7)
-            )
-    return loss