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

lt_tensor-0.0.1a13.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=UNba6UEsAv1oZ60IAaKBNGbhXK2WPxRI9E4QcjP-_w0,28755
+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=knVLxzrLUjNQ6vdBESTZOk3r86ldi5PHetoBuJmymcw,6388
+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/sg.py,sha256=EaEi3otw_uY5QfqDBNIWBWTJSg3KnwzzR4FBr0u09C0,4838
+lt_tensor/model_zoo/istft/trainer.py,sha256=EPuGtvfgR8vCrVc72p5OwVy73nNVlx510VxnH3NeErY,16080
+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/model_zoo/fsn.py

@@ -1,67 +0,0 @@
-__all__ = [
-    "ConcatFusion",
-    "FiLMFusion",
-    "BilinearFusion",
-    "CrossAttentionFusion",
-    "GatedFusion",
-]
-
-from ..torch_commons import *
-from ..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 ..torch_commons import *
-from ..model_base import Model
-from .rsd import ResBlock1D, ResBlocks
-from ..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]
-
-

lt_tensor/model_zoo/rsd.py

@@ -1,237 +0,0 @@
-__all__ = [
-    "spectral_norm_select",
-    "ResBlock1D_BT",
-    "ResBlock1D",
-    "ResBlock2D",
-    "ResBlocks",
-]
-from lt_utils.common import *
-from ..torch_commons import *
-from ..model_base import Model
-import math
-from ..misc_utils import log_tensor
-
-
-def spectral_norm_select(module: nn.Module, enabled: bool):
-    if enabled:
-        return spectral_norm(module)
-    return module
-
-
-class ResBlock1D_BT(Model):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        kernel_size: int = 3,
-        dilation: Union[Sequence[int], int] = (1, 3, 5),
-        activation: nn.Module = nn.LeakyReLU(0.1),
-        num_groups: int = 1,
-        batched: bool = True,
-    ):
-        super().__init__()
-        self.conv = nn.ModuleList()
-        if isinstance(dilation, int):
-            dilation = [dilation]
-
-        if batched:
-            layernorm_fn = lambda x: nn.GroupNorm(num_groups=num_groups, num_channels=x)
-        else:
-            layernorm_fn = lambda x: nn.LayerNorm(normalized_shape=x)
-        for i, dil in enumerate(dilation):
-
-            self.conv.append(
-                nn.ModuleDict(
-                    dict(
-                        net=nn.Sequential(
-                            self._get_conv_layer(
-                                in_channels, in_channels, kernel_size, dil
-                            ),
-                            activation,
-                            self._get_conv_layer(
-                                in_channels, in_channels, kernel_size, 1, True
-                            ),
-                            activation,
-                        ),
-                        l_norm=layernorm_fn(in_channels),
-                    )
-                )
-            )
-        self.final = nn.Sequential(
-            self._get_conv_layer(in_channels, out_channels, kernel_size, 1, True),
-            activation,
-        )
-        self.conv.apply(self.init_weights)
-
-    def _get_conv_layer(
-        self,
-        channels_in: int,
-        channels_out: int,
-        kernel_size: int,
-        dilation: int,
-        pad_gate: bool = False,
-    ):
-        return weight_norm(
-            nn.Conv1d(
-                in_channels=channels_in,
-                out_channels=channels_out,
-                kernel_size=kernel_size,
-                stride=1,
-                dilation=dilation,
-                padding=(
-                    int((kernel_size * dilation - dilation) / 2)
-                    if not pad_gate
-                    else int((kernel_size * 1 - 1) / 2)
-                ),
-            )
-        )
-
-    def forward(self, x: Tensor):
-        for i, layer in enumerate(self.conv):
-            xt = layer["net"](x)
-            x = xt + x
-            x = layer["l_norm"](x)
-        return self.final(x)
-
-    def remove_weight_norm(self):
-        for module in self.modules():
-            try:
-                remove_weight_norm(module)
-            except ValueError:
-                pass  # Not normed, skip
-
-    @staticmethod
-    def init_weights(m, mean=0.0, std=0.01):
-        classname = m.__class__.__name__
-        if "Conv" in classname:
-            m.weight.data.normal_(mean, std)
-
-
-class ResBlock1D(Model):
-    def __init__(
-        self,
-        channels,
-        kernel_size=3,
-        dilation=(1, 3, 5),
-        activation: nn.Module = nn.LeakyReLU(0.1),
-    ):
-        super(ResBlock1D, self).__init__()
-        self.convs = nn.ModuleList(
-            [
-                self._get_conv_layer(i, channels, kernel_size, 1, dilation, activation)
-                for i in range(3)
-            ]
-        )
-        self.convs.apply(self.init_weights)
-
-    def _get_conv_layer(self, id, ch, k, stride, d, actv):
-        get_padding = lambda ks, d: int((ks * d - d) / 2)
-        return nn.Sequential(
-            actv,  # 1
-            weight_norm(
-                nn.Conv1d(
-                    ch, ch, k, stride, dilation=d[id], padding=get_padding(k, d[id])
-                )
-            ),  # 2
-            actv,  # 3
-            weight_norm(
-                nn.Conv1d(ch, ch, k, stride, dilation=1, padding=get_padding(k, 1))
-            ),  # 4
-        )
-
-    def forward(self, x: torch.Tensor):
-        for cnn in self.convs:
-            x = cnn(x) + x
-        return x
-
-    def remove_weight_norm(self):
-        for module in self.modules():
-            try:
-                remove_weight_norm(module)
-            except ValueError:
-                pass  # Not normed, skip
-
-    @staticmethod
-    def init_weights(m, mean=0.0, std=0.01):
-        classname = m.__class__.__name__
-        if "Conv" in classname:
-            m.weight.data.normal_(mean, std)
-
-
-class ResBlocks(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),
-    ):
-        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)
-
-    def remove_weight_norm(self):
-        for module in self.modules():
-            try:
-                remove_weight_norm(module)
-            except ValueError:
-                pass  # Not normed, skip
-
-    @staticmethod
-    def init_weights(m, mean=0.0, std=0.01):
-        classname = m.__class__.__name__
-        if "Conv" in classname:
-            m.weight.data.normal_(mean, std)
-
-
-class ResBlock2D(Model):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        downsample=False,
-        spec_norm: bool = False,
-    ):
-        super().__init__()
-        stride = 2 if downsample else 1
-
-        self.block = nn.Sequential(
-            spectral_norm_select(
-                nn.Conv2d(in_channels, out_channels, 3, stride, 1), spec_norm
-            ),
-            nn.LeakyReLU(0.2),
-            spectral_norm_select(
-                nn.Conv2d(out_channels, out_channels, 3, 1, 1), spec_norm
-            ),
-        )
-
-        self.skip = nn.Identity()
-        if downsample or in_channels != out_channels:
-            self.skip = spectral_norm_select(
-                nn.Conv2d(in_channels, out_channels, 1, stride), spec_norm
-            )
-        # on less to be handled every cicle
-        self.sqrt_2 = math.sqrt(2)
-
-    def forward(self, x):
-        return (self.block(x) + self.skip(x)) / self.sqrt_2

lt_tensor-0.0.1a11.dist-info/RECORD

@@ -1,28 +0,0 @@
-lt_tensor/__init__.py,sha256=uwJ7uiO18VYj8Z1V4KSOQ3ZrnowSgJWKCIiFBrzLMOI,429
-lt_tensor/losses.py,sha256=1wrke1e68hUBNAoPdJgKni0pJvXKcieza_R8nwBzMW4,4937
-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=8LqtpmLKqCo79NdH160ByQojG8YTDcw8aHKFgOFGVLI,25425
-lt_tensor/model_base.py,sha256=a2ogixC2fUyOLqz15TzCRcGXvBam--TdmpG83jw9Of8,21543
-lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
-lt_tensor/noise_tools.py,sha256=rfFbPsrsycWVuH9G4zZCQC9Vgi9r8hDaECcB0TZYSYQ,11345
-lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
-lt_tensor/transform.py,sha256=LZZ9G7ud1cojERC7N7hMAbH9GC3ImY1hBIY00kVMs-I,13492
-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=OQqsQDRBf6gWqoeGeEuIaTh96AqcDyTIbO8MAMNTtI4,7045
-lt_tensor/model_zoo/disc.py,sha256=9RxyHYH2nGhxLs_yoEFVgerBfH4-qdaL2Mu9akyG0_M,5841
-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=RV7KVY7q4CYzzsWXH4NGJQwSqrYWwHh-16Q62lKoA2k,3594
-lt_tensor/model_zoo/pos.py,sha256=N28v-rF8CELouYxQ9r45Jbd4ri5DNydwDgg7nzmQ4Ig,4471
-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=2Sta_KytTqGZh-ZeHpcCbqP6O8VT6QQVkx-7szA3Itc,8830
-lt_tensor-0.0.1a11.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
-lt_tensor-0.0.1a11.dist-info/METADATA,sha256=DNs5JZfr_mjve_GHy13Auics3BI_f1pNYBth-dQW04M,966
-lt_tensor-0.0.1a11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a11.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a11.dist-info/RECORD,,