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

lt_tensor/model_zoo/discriminator.py

@@ -1,196 +0,0 @@
-from lt_tensor.torch_commons import *
-import torch.nn.functional as F
-from lt_tensor.model_base import Model
-from lt_utils.common import *
-
-
-class PeriodDiscriminator(Model):
-    def __init__(
-        self,
-        period: int,
-        use_spectral_norm=False,
-        kernel_size: int = 5,
-        stride: int = 3,
-    ):
-        super().__init__()
-        self.period = period
-        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(
-                nn.Conv2d(
-                    1, self.channels[0], (kernel_size, 1), (stride, 1), padding=(2, 0)
-                )
-            ),
-            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.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):
-        stride = (self.stride, 1) if not is_last else 1
-
-        return nn.Sequential(
-            self.norm_f(
-                nn.Conv2d(
-                    last_in,
-                    out_dim,
-                    (self.kernel_size, 1),
-                    stride,
-                    padding=(2, 0),
-                )
-            ),
-            nn.LeakyReLU(0.1),
-        )
-
-    def forward(self, x: torch.Tensor):
-        """
-        x: (B, T)
-        """
-        b, t = x.shape
-        if t % self.period != 0:
-            pad_len = self.period - (t % self.period)
-            x = F.pad(x, (0, pad_len), mode="reflect")
-            t = t + pad_len
-
-        x = x.view(b, 1, t // self.period, self.period)  # (B, 1, T//P, P)
-
-        f_map = []
-        x = self.first_pass(x)
-        f_map.append(x)
-        for conv in self.convs:
-            x = conv(x)
-            f_map.append(x)
-        x = self.post_conv(x)
-        f_map.append(x)
-        return x.flatten(1, -1), f_map
-
-
-class ScaleDiscriminator(nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super().__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.activation = nn.LeakyReLU(0.1)
-        self.convs = nn.ModuleList(
-            [
-                norm_f(nn.Conv1d(1, 128, 15, 1, padding=7)),
-                norm_f(nn.Conv1d(128, 128, 41, 2, groups=4, padding=20)),
-                norm_f(nn.Conv1d(128, 256, 41, 2, groups=16, padding=20)),
-                norm_f(nn.Conv1d(256, 512, 41, 4, groups=16, padding=20)),
-                norm_f(nn.Conv1d(512, 1024, 41, 4, groups=16, padding=20)),
-                norm_f(nn.Conv1d(1024, 1024, 41, 1, groups=16, padding=20)),
-                norm_f(nn.Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.post_conv = norm_f(nn.Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x: torch.Tensor):
-        """
-        x: (B, T)
-        """
-        f_map = []
-        x = x.unsqueeze(1)  # (B, 1, T)
-        for conv in self.convs:
-            x = self.activation(conv(x))
-            f_map.append(x)
-        x = self.post_conv(x)
-        f_map.append(x)
-        return x.flatten(1, -1), f_map
-
-
-class MultiScaleDiscriminator(Model):
-    def __init__(self, layers: int = 3):
-        super().__init__()
-        self.pooling = nn.AvgPool1d(4, 2, padding=2)
-        self.discriminators = nn.ModuleList(
-            [ScaleDiscriminator(i == 0) for i in range(layers)]
-        )
-
-    def forward(self, x: torch.Tensor):
-        """
-        x: (B, T)
-        Returns: list of outputs from each scale discriminator
-        """
-        outputs = []
-        features = []
-        for i, d in enumerate(self.discriminators):
-            if i != 0:
-                x = self.pooling(x)
-            out, f_map = d(x)
-            outputs.append(out)
-            features.append(f_map)
-        return outputs, features
-
-
-class MultiPeriodDiscriminator(Model):
-    def __init__(self, periods: List[int] = [2, 3, 5, 7, 11]):
-        super().__init__()
-        self.discriminators = nn.ModuleList([PeriodDiscriminator(p) for p in periods])
-
-    def forward(self, x: torch.Tensor):
-        """
-        x: (B, T)
-        Returns: list of tuples of outputs from each period discriminator and the f_map.
-        """
-        # torch.log(torch.clip(x, min=clip_val))
-        out_map = []
-        feat_map = []
-        for d in self.discriminators:
-            out, feat = d(x)
-            out_map.append(out)
-            feat_map.append(feat)
-        return out_map, feat_map
-
-
-def discriminator_loss(real_out_map, fake_out_map):
-    loss = 0.0
-    rl, fl = [], []
-    for real_out, fake_out in zip(real_out_map, fake_out_map):
-        real_loss = torch.mean((1.0 - real_out) ** 2)
-        fake_loss = torch.mean(fake_out**2)
-        loss += real_loss + fake_loss
-        rl.append(real_loss.item())
-        fl.append(fake_loss.item())
-    return loss, sum(rl), sum(fl)
-
-
-def generator_adv_loss(fake_disc_outputs: List[Tensor]):
-    loss = 0.0
-    for fake_out in fake_disc_outputs:
-        fake_score = fake_out[0]
-        loss += -torch.mean(fake_score)
-    return loss
-
-
-def feature_loss(
-    fmap_r,
-    fmap_g,
-    weight=2.0,
-    loss_fn: Callable[[Tensor, Tensor], Tensor] = F.l1_loss,
-):
-    loss = 0.0
-    for dr, dg in zip(fmap_r, fmap_g):
-        for rl, gl in zip(dr, dg):
-            loss += loss_fn(rl - gl)
-    return loss * weight
-
-
-def generator_loss(disc_generated_outputs):
-    loss = 0.0
-    gen_losses = []
-    for dg in disc_generated_outputs:
-        l = torch.mean((1.0 - dg) ** 2)
-        gen_losses.append(l.item())
-        loss += l
-
-    return loss, gen_losses

lt_tensor/model_zoo/istft/__init__.py

@@ -1,5 +0,0 @@
-from .generator import iSTFTGenerator
-from . import trainer
-
-
-__all__ = ["iSTFTGenerator", "trainer"]

lt_tensor/model_zoo/istft/generator.py

@@ -1,90 +0,0 @@
-__all__ = ["iSTFTGenerator"]
-from lt_utils.common import *
-from lt_tensor.torch_commons import *
-from lt_tensor.model_zoo.residual import ConvNets, ResBlocks
-
-
-class iSTFTGenerator(ConvNets):
-    def __init__(
-        self,
-        in_channels: int = 80,
-        upsample_rates: List[Union[int, List[int]]] = [8, 8],
-        upsample_kernel_sizes: List[Union[int, List[int]]] = [16, 16],
-        upsample_initial_channel: int = 512,
-        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],
-        ],
-        n_fft: int = 16,
-        activation: nn.Module = nn.LeakyReLU(0.1),
-        hop_length: int = 256,
-    ):
-        super().__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.hop_length = hop_length
-        self.conv_pre = weight_norm(
-            nn.Conv1d(in_channels, upsample_initial_channel, 7, 1, padding=3)
-        )
-        self.blocks = nn.ModuleList()
-        self.activation = activation
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.blocks.append(
-                self._make_blocks(
-                    (i, k, u),
-                    upsample_initial_channel,
-                    resblock_kernel_sizes,
-                    resblock_dilation_sizes,
-                )
-            )
-
-        ch = upsample_initial_channel // (2 ** (i + 1))
-        self.post_n_fft = n_fft // 2 + 1
-        self.conv_post = weight_norm(nn.Conv1d(ch, n_fft + 2, 7, 1, padding=3))
-        self.conv_post.apply(self.init_weights)
-        self.reflection_pad = nn.ReflectionPad1d((1, 0))
-
-    def _make_blocks(
-        self,
-        state: Tuple[int, int, int],
-        upsample_initial_channel: int,
-        resblock_kernel_sizes: List[Union[int, List[int]]],
-        resblock_dilation_sizes: List[int | List[int]],
-    ):
-        i, k, u = state
-        channels = upsample_initial_channel // (2 ** (i + 1))
-        return nn.ModuleDict(
-            dict(
-                up=nn.Sequential(
-                    self.activation,
-                    weight_norm(
-                        nn.ConvTranspose1d(
-                            upsample_initial_channel // (2**i),
-                            channels,
-                            k,
-                            u,
-                            padding=(k - u) // 2,
-                        )
-                    ).apply(self.init_weights),
-                ),
-                residual=ResBlocks(
-                    channels,
-                    resblock_kernel_sizes,
-                    resblock_dilation_sizes,
-                    self.activation,
-                ),
-            )
-        )
-
-    def forward(self, x):
-        x = self.conv_pre(x)
-        for block in self.blocks:
-            x = block["up"](x)
-            x = block["residual"](x)
-
-        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/sg.py

@@ -1,142 +0,0 @@
-import torch
-import torch.nn as nn
-import math
-from einops import repeat
-
-
-class SineGen(nn.Module):
-    def __init__(
-        self,
-        samp_rate,
-        upsample_scale,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super().__init__()
-        self.sampling_rate = samp_rate
-        self.upsample_scale = upsample_scale
-        self.harmonic_num = harmonic_num
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.voiced_threshold = voiced_threshold
-        self.flag_for_pulse = flag_for_pulse
-        self.dim = self.harmonic_num + 1  # fundamental + harmonics
-
-    def _f02uv_b(self, f0):
-        return (f0 > self.voiced_threshold).float()  # [B, T]
-
-    def _f02uv(self, f0):
-        return (f0 > self.voiced_threshold).float().unsqueeze(-1)  # -> (B, T, 1)
-
-    @torch.no_grad()
-    def _f02sine(self, f0_values):
-        """
-        f0_values: (B, T, 1)
-        Output: sine waves (B, T * upsample, dim)
-        """
-        B, T, _ = f0_values.size()
-        f0_upsampled = repeat(
-            f0_values, "b t d -> b (t r) d", r=self.upsample_scale
-        )  # (B, T_up, 1)
-
-        # Create harmonics
-        harmonics = (
-            torch.arange(1, self.dim + 1, device=f0_values.device)
-            .float()
-            .view(1, 1, -1)
-        )
-        f0_harm = f0_upsampled * harmonics  # (B, T_up, dim)
-
-        # Convert Hz to radians (2πf/sr), then integrate to get phase
-        rad_values = f0_harm / self.sampling_rate  # normalized freq
-        rad_values = rad_values % 1.0  # remove multiples of 2π
-
-        # Random initial phase for each harmonic (except 0th if pulse mode)
-        if self.flag_for_pulse:
-            rand_ini = torch.zeros((B, 1, self.dim), device=f0_values.device)
-        else:
-            rand_ini = torch.rand((B, 1, self.dim), device=f0_values.device)
-
-        rand_ini = rand_ini * 2 * math.pi
-
-        # Compute cumulative phase
-        rad_values = rad_values * 2 * math.pi
-        phase = torch.cumsum(rad_values, dim=1) + rand_ini  # (B, T_up, dim)
-
-        sine_waves = torch.sin(phase)  # (B, T_up, dim)
-        return sine_waves
-
-    def _forward(self, f0):
-        """
-        f0: (B, T, 1)
-        returns: sine signal with harmonics and noise added
-        """
-        sine_waves = self._f02sine(f0)  # (B, T_up, dim)
-        uv = self._f02uv_b(f0) # (B, T, 1)
-        uv = repeat(uv, "b t d -> b (t r) d", r=self.upsample_scale)  # (B, T_up, 1)
-
-        # voiced sine + unvoiced noise
-        sine_signal = self.sine_amp * sine_waves * uv  # (B, T_up, dim)
-        noise = torch.randn_like(sine_signal) * self.noise_std
-        output = sine_signal + noise * (1.0 - uv)  # noise added only on unvoiced
-
-        return output  # (B, T_up, dim)
-
-    def forward(self, f0):
-        """
-        Args:
-            f0: (B, T) in Hz (before upsampling)
-        Returns:
-            sine_waves: (B, T_up, dim)
-            uv: (B, T_up, 1)
-            noise: (B, T_up, 1)
-        """
-        B, T = f0.shape
-        device = f0.device
-
-        # Get uv mask (before upsampling)
-        uv = self._f02uv(f0)  # (B, T, 1)
-
-        # Expand f0 to include harmonics: (B, T, dim)
-        f0 = f0.unsqueeze(-1)  # (B, T, 1)
-        harmonics = (
-            torch.arange(1, self.dim + 1, device=device).float().view(1, 1, -1)
-        )  # (1, 1, dim)
-        f0_harm = f0 * harmonics  # (B, T, dim)
-
-        # Upsample
-        f0_harm_up = repeat(
-            f0_harm, "b t d -> b (t r) d", r=self.upsample_scale
-        )  # (B, T_up, dim)
-        uv_up = repeat(uv, "b t d -> b (t r) d", r=self.upsample_scale)  # (B, T_up, 1)
-
-        # Convert to radians
-        rad_per_sample = f0_harm_up / self.sampling_rate  # Hz → cycles/sample
-        rad_per_sample = rad_per_sample * 2 * math.pi  # cycles → radians/sample
-
-        # Random phase init for each sample
-        B, T_up, D = rad_per_sample.shape
-        rand_phase = torch.rand(B, D, device=device) * 2 * math.pi  # (B, D)
-
-        # Compute cumulative phase
-        phase = torch.cumsum(rad_per_sample, dim=1) + rand_phase.unsqueeze(
-            1
-        )  # (B, T_up, D)
-
-        # Apply sine
-        sine_waves = torch.sin(phase) * self.sine_amp  # (B, T_up, D)
-
-        # Handle unvoiced: create noise only for fundamental
-        noise = torch.randn(B, T_up, 1, device=device) * self.noise_std
-        if self.flag_for_pulse:
-            # If pulse mode is on, align phase at start of voiced segments
-            # Optional and tricky to implement — may require segmenting uv
-            pass
-
-        # Replace sine by noise for unvoiced (only on fundamental)
-        sine_waves[:, :, 0:1] = sine_waves[:, :, 0:1] * uv_up + noise * (1 - uv_up)
-
-        return sine_waves, uv_up, noise