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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a12
+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
@@ -11,15 +11,17 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: torch>=2.2.0
-Requires-Dist: torchaudio>=2.2.0
+Requires-Dist: torch>=2.7.0
+Requires-Dist: torchaudio>=2.7.0
 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: librosa>=0.11.0
+Requires-Dist: lt-utils==0.0.2a2
+Requires-Dist: librosa==0.11.*
+Requires-Dist: einops
 Requires-Dist: plotly
+Requires-Dist: scipy
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

lt_tensor-0.0.1a14.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=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
+lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
+lt_tensor/transform.py,sha256=dZm8T_ov0blHMQu6nGiehsdG1VSB7bZBUVmTkT-PBdc,13257
+lt_tensor/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lt_tensor/datasets/audio.py,sha256=j73oRyXt-AK4tWWYWjH-3c5RYouQBgDSCTuWHmyG8kQ,7450
+lt_tensor/model_zoo/__init__.py,sha256=RzG7fltZLyiIU_Za4pgfBPli5uPITiJkq4sTCd4uA_0,319
+lt_tensor/model_zoo/basic.py,sha256=_26H_jJk5Ld3DZiNpIhGosGfMxoFDZrI8bpDAYUOYno,10660
+lt_tensor/model_zoo/discriminator.py,sha256=dS5UmJZV5MxIFiaBlIXfgGLDdUT3y0Vuv9lDGHsjJE8,5849
+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=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=wWHUfLFIItN-tB3pWkc1r9aTWpHYBFg7UfvLN4_cD78,3179
+lt_tensor/model_zoo/istft/sg.py,sha256=EaEi3otw_uY5QfqDBNIWBWTJSg3KnwzzR4FBr0u09C0,4838
+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=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,,

lt_tensor/model_zoo/fsn.py

@@ -1,67 +0,0 @@
-__all__ = [
-    "ConcatFusion",
-    "FiLMFusion",
-    "BilinearFusion",
-    "CrossAttentionFusion",
-    "GatedFusion",
-]
-
-from lt_tensor.torch_commons import *
-from lt_tensor.model_base import Model
-
-
-class ConcatFusion(Model):
-    def __init__(self, in_dim_a: int, in_dim_b: int, out_dim: int):
-        super().__init__()
-        self.proj = nn.Linear(in_dim_a + in_dim_b, out_dim)
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        x = torch.cat([a, b], dim=-1)
-        return self.proj(x)
-
-
-class FiLMFusion(Model):
-    def __init__(self, cond_dim: int, feature_dim: int):
-        super().__init__()
-        self.modulator = nn.Linear(cond_dim, 2 * feature_dim)
-
-    def forward(self, x: Tensor, cond: Tensor) -> Tensor:
-        scale, shift = self.modulator(cond).chunk(2, dim=-1)
-        return x * scale + shift
-
-
-class BilinearFusion(Model):
-    def __init__(self, in_dim_a: int, in_dim_b: int, out_dim: int):
-        super().__init__()
-        self.bilinear = nn.Bilinear(in_dim_a, in_dim_b, out_dim)
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        return self.bilinear(a, b)
-
-
-class CrossAttentionFusion(Model):
-    def __init__(self, q_dim: int, kv_dim: int, n_heads: int = 4, d_model: int = 256):
-        super().__init__()
-        self.q_proj = nn.Linear(q_dim, d_model)
-        self.k_proj = nn.Linear(kv_dim, d_model)
-        self.v_proj = nn.Linear(kv_dim, d_model)
-        self.attn = nn.MultiheadAttention(
-            embed_dim=d_model, num_heads=n_heads, batch_first=True
-        )
-
-    def forward(self, query: Tensor, context: Tensor, mask: Tensor = None) -> Tensor:
-        Q = self.q_proj(query)
-        K = self.k_proj(context)
-        V = self.v_proj(context)
-        output, _ = self.attn(Q, K, V, key_padding_mask=mask)
-        return output
-
-
-class GatedFusion(Model):
-    def __init__(self, in_dim: int):
-        super().__init__()
-        self.gate = nn.Sequential(nn.Linear(in_dim * 2, in_dim), nn.Sigmoid())
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        gate = self.gate(torch.cat([a, b], dim=-1))
-        return gate * a + (1 - gate) * b

lt_tensor/model_zoo/gns.py

@@ -1,185 +0,0 @@
-__all__ = [
-    "Downsample1D",
-    "Upsample1D",
-    "DiffusionUNet",
-    "UNetConvBlock1D",
-    "UNetUpBlock1D",
-    "NoisePredictor1D",
-]
-
-from lt_tensor.torch_commons import *
-from lt_tensor.model_base import Model
-from lt_tensor.model_zoo.rsd import ResBlock1D
-from lt_tensor.misc_utils import log_tensor
-
-import torch.nn.functional as F
-
-
-class Downsample1D(Model):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-    ):
-        super().__init__()
-        self.pool = nn.Conv1d(in_channels, out_channels, 4, stride=2, padding=1)
-
-    def forward(self, x):
-        return self.pool(x)
-
-
-class Upsample1D(Model):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        activation=nn.ReLU(inplace=True),
-    ):
-        super().__init__()
-        self.up = nn.Sequential(
-            nn.ConvTranspose1d(
-                in_channels, out_channels, kernel_size=4, stride=2, padding=1
-            ),
-            nn.BatchNorm1d(out_channels),
-            activation,
-        )
-
-    def forward(self, x):
-        return self.up(x)
-
-
-class DiffusionUNet(Model):
-    def __init__(self, in_channels=1, base_channels=64, out_channels=1, depth=4):
-        super().__init__()
-
-        self.depth = depth
-        self.encoder_blocks = nn.ModuleList()
-        self.downsamples = nn.ModuleList()
-        self.upsamples = nn.ModuleList()
-        self.decoder_blocks = nn.ModuleList()
-        # Keep track of channel sizes per layer for skip connections
-        self.channels = [in_channels]  # starting input channel
-        for i in range(depth):
-            enc_in = self.channels[-1]
-            enc_out = base_channels * (2**i)
-            # Encoder block and downsample
-            self.encoder_blocks.append(ResBlock1D(enc_in, enc_out))
-            self.downsamples.append(
-                Downsample1D(enc_out, enc_out)
-            )  # halve time, keep channels
-            self.channels.append(enc_out)
-        # Bottleneck
-        bottleneck_ch = self.channels[-1]
-        self.bottleneck = ResBlock1D(bottleneck_ch, bottleneck_ch)
-        # Decoder blocks (reverse channel flow)
-        for i in reversed(range(depth)):
-            skip_ch = self.channels[i + 1]  # from encoder
-            dec_out = self.channels[i]  # match earlier stage's output
-            self.upsamples.append(Upsample1D(skip_ch, skip_ch))
-            self.decoder_blocks.append(ResBlock1D(skip_ch * 2, dec_out))
-        # Final output projection (out_channels)
-        self.final = nn.Conv1d(in_channels, out_channels, kernel_size=1)
-
-    def forward(self, x: Tensor):
-        skips = []
-
-        # Encoder
-        for enc, down in zip(self.encoder_blocks, self.downsamples):
-            # log_tensor(x, "before enc")
-            x = enc(x)
-            skips.append(x)
-            x = down(x)
-
-        # Bottleneck
-        x = self.bottleneck(x)
-
-        # Decoder
-        for up, dec, skip in zip(self.upsamples, self.decoder_blocks, reversed(skips)):
-            x = up(x)
-
-            # Match lengths via trimming or padding
-            if x.shape[-1] > skip.shape[-1]:
-                x = x[..., : skip.shape[-1]]
-            elif x.shape[-1] < skip.shape[-1]:
-                diff = skip.shape[-1] - x.shape[-1]
-                x = F.pad(x, (0, diff))
-
-            x = torch.cat([x, skip], dim=1)  # concat on channels
-            x = dec(x)
-
-        # Final 1x1 conv
-        return self.final(x)
-
-
-class UNetConvBlock1D(Model):
-    def __init__(self, in_channels: int, out_channels: int, down: bool = True):
-        super().__init__()
-        self.down = down
-        self.conv = nn.Sequential(
-            nn.Conv1d(
-                in_channels,
-                out_channels,
-                kernel_size=3,
-                stride=2 if down else 1,
-                padding=1,
-            ),
-            nn.BatchNorm1d(out_channels),
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(out_channels, out_channels, kernel_size=3, padding=1),
-            nn.BatchNorm1d(out_channels),
-            nn.LeakyReLU(0.2),
-        )
-        self.downsample = (
-            nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=2 if down else 1)
-            if in_channels != out_channels
-            else nn.Identity()
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # x: [B, C, T]
-        residual = self.downsample(x)
-        return self.conv(x) + residual
-
-
-class UNetUpBlock1D(Model):
-    def __init__(self, in_channels: int, out_channels: int):
-        super().__init__()
-        self.conv = nn.Sequential(
-            nn.Conv1d(in_channels, out_channels, kernel_size=3, padding=1),
-            nn.BatchNorm1d(out_channels),
-            nn.LeakyReLU(0.2),
-            nn.Conv1d(out_channels, out_channels, kernel_size=3, padding=1),
-            nn.BatchNorm1d(out_channels),
-            nn.LeakyReLU(0.2),
-        )
-        self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
-
-    def forward(self, x: torch.Tensor, skip: torch.Tensor) -> torch.Tensor:
-        x = self.upsample(x)
-        x = torch.cat([x, skip], dim=1)  # skip connection
-        return self.conv(x)
-
-
-class NoisePredictor1D(Model):
-    def __init__(self, in_channels: int, cond_dim: int = 0, hidden: int = 128):
-        """
-        Args:
-            in_channels: channels of the noisy input [B, C, T]
-            cond_dim: optional condition vector [B, cond_dim]
-        """
-        super().__init__()
-        self.proj = nn.Linear(cond_dim, hidden) if cond_dim > 0 else None
-        self.net = nn.Sequential(
-            nn.Conv1d(in_channels, hidden, kernel_size=3, padding=1),
-            nn.SiLU(),
-            nn.Conv1d(hidden, in_channels, kernel_size=3, padding=1),
-        )
-
-    def forward(self, x: torch.Tensor, cond: Optional[torch.Tensor] = None):
-        # x: [B, C, T], cond: [B, cond_dim]
-        if cond is not None:
-            cond_proj = self.proj(cond).unsqueeze(-1)  # [B, hidden, 1]
-            x = x + cond_proj  # simple conditioning
-        return self.net(x)  # [B, C, T]
-
-