lt-tensor 0.0.1a4__py3-none-any.whl → 0.0.1a7__py3-none-any.whl

lt_tensor/processors/audio.py

@@ -0,0 +1,193 @@
+__all__ = ["AudioProcessor"]
+from ..torch_commons import *
+from lt_utils.common import *
+from lt_utils.type_utils import is_file, is_array
+from ..misc_utils import log_tensor
+import librosa
+import torchaudio
+
+from ..transform import InverseTransformConfig, InverseTransform
+from lt_utils.file_ops import FileScan, get_file_name, path_to_str
+
+from lt_tensor.model_base import Model
+
+
+class AudioProcessor(Model):
+    def __init__(
+        self,
+        sample_rate: int = 24000,
+        n_mels: int = 80,
+        n_fft: int = 1024,
+        win_length: Optional[int] = None,
+        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,
+        mean: int = -4,
+        inverse_transform_config: Union[
+            Dict[str, Union[Number, Tensor, bool]], InverseTransformConfig
+        ] = dict(n_fft=16, hop_length=4, win_length=16, center=True),
+        *__,
+        **_,
+    ):
+        super().__init__()
+        assert isinstance(inverse_transform_config, (InverseTransformConfig, dict))
+        self.mean = mean
+        self.std = std
+        self.n_mels = n_mels
+        self.n_fft = n_fft
+        self.n_stft = n_fft // 2 + 1
+        self.f_min = f_min
+        self.f_max = f_max
+        self.n_iter = n_iter
+        self.hop_length = hop_length or n_fft // 4
+        self.win_length = win_length or n_fft
+        self.sample_rate = sample_rate
+        self.mel_spec = torchaudio.transforms.MelSpectrogram(
+            sample_rate=sample_rate,
+            n_mels=n_mels,
+            n_fft=n_fft,
+            win_length=win_length,
+            hop_length=hop_length,
+            center=center,
+            f_min=f_min,
+            f_max=f_max,
+            mel_scale=mel_scale,
+        )
+        self.mel_rscale = torchaudio.transforms.InverseMelScale(
+            n_stft=self.n_stft,
+            n_mels=n_mels,
+            sample_rate=sample_rate,
+            f_min=f_min,
+            f_max=f_max,
+            mel_scale=mel_scale,
+        )
+        self.giffin_lim = torchaudio.transforms.GriffinLim(
+            n_fft=n_fft,
+            n_iter=n_iter,
+            win_length=win_length,
+            hop_length=hop_length,
+        )
+        if isinstance(inverse_transform_config, dict):
+            inverse_transform_config = InverseTransformConfig(
+                **inverse_transform_config
+            )
+        self._inv_transform = InverseTransform(**inverse_transform_config.to_dict())
+
+    def inverse_transform(self, spec: Tensor, phase: Tensor, *_, **kwargs):
+        return self._inv_transform(spec, phase, **kwargs)
+
+    def compute_mel(
+        self, wave: Tensor, base: float = 1e-6, add_base: bool = False
+    ) -> 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
+        )
+
+    def reverse_mel(self, mel: Tensor, n_iter: Optional[int] = None):
+        if isinstance(n_iter, int) and n_iter != self.n_iter:
+            self.giffin_lim = torchaudio.transforms.GriffinLim(
+                n_fft=self.n_fft,
+                n_iter=n_iter,
+                win_length=self.win_length,
+                hop_length=self.hop_length,
+            )
+            self.n_iter = n_iter
+        return self.giffin_lim.forward(
+            self.mel_rscale(mel),
+        )
+
+    def load_audio(
+        self,
+        path: PathLike,
+        top_db: float = 30,
+    ) -> Tensor:
+        is_file(path, True)
+        wave, sr = librosa.load(str(path), sr=self.sample_rate)
+        wave, _ = librosa.effects.trim(wave, top_db=top_db)
+        return (
+            torch.from_numpy(
+                librosa.resample(wave, orig_sr=sr, target_sr=self.sample_rate)
+                if sr != self.sample_rate
+                else wave
+            )
+            .float()
+            .unsqueeze(0)
+        )
+
+    def find_audios(self, path: PathLike, additional_extensions: List[str] = []):
+        extensions = [
+            "*.wav",
+            "*.aac",
+            "*.m4a",
+            "*.mp3",
+            "*.ogg",
+            "*.opus",
+            "*.flac",
+        ]
+        extensions.extend(
+            [x for x in additional_extensions if isinstance(x, str) and "*" in x]
+        )
+        return FileScan.files(
+            path,
+            extensions,
+        )
+
+    def find_audio_text_pairs(
+        self,
+        path,
+        additional_extensions: List[str] = [],
+        text_file_patterns: List[str] = [".normalized.txt", ".original.txt"],
+    ):
+        is_array(text_file_patterns, True, validate=True)  # Rases if empty or not valid
+        additional_extensions = [
+            x
+            for x in additional_extensions
+            if isinstance(x, str)
+            and "*" in x
+            and not any(list(map(lambda y: y in x), text_file_patterns))
+        ]
+        audio_files = self.find_audios(path, additional_extensions)
+        results = []
+        for audio in audio_files:
+            base_audio_dir = Path(audio).parent
+            audio_name = get_file_name(audio, False)
+            for pattern in text_file_patterns:
+                possible_txt_file = Path(base_audio_dir, audio_name + pattern)
+                if is_file(possible_txt_file):
+                    results.append((audio, path_to_str(possible_txt_file)))
+                    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)
+        return torch.norm(gnd_mel - sig_mel, p=1) / torch.norm(gnd_mel, p=1)
+
+    # def forward(self, wave: Tensor, base: Optional[float] = None):
+    def forward(
+        self,
+        *inputs: Union[Tensor, float],
+        ap_task: Literal[
+            "get_mel", "get_loss", "inv_transform", "revert_mel"
+        ] = "get_mel",
+        **inputs_kwargs,
+    ):
+        if ap_task == "get_mel":
+            return self.compute_mel(*inputs, **inputs_kwargs)
+        elif ap_task == "get_loss":
+            return self.stft_loss(*inputs, **inputs_kwargs)
+        elif ap_task == "inv_transform":
+            return self.inverse_transform(*inputs, **inputs_kwargs)
+        elif ap_task == "revert_mel":
+            return self.reverse_mel(*inputs, **inputs_kwargs)
+        else:
+            raise ValueError(f"Invalid task '{ap_task}'")

lt_tensor/transform.py

@@ -8,8 +8,6 @@ __all__ = [
     "normalize",
     "min_max_scale",
     "mel_to_linear",
-    "add_noise",
-    "shift_time",
     "stretch_tensor",
     "pad_tensor",
     "get_sinusoidal_embedding",
@@ -17,6 +15,8 @@ __all__ = [
     "normalize",
     "window_sumsquare",
     "inverse_transform",
+    "InverseTransformConfig",
+    "InverseTransform",
     "stft_istft_rebuild",
 ]
 
@@ -25,12 +25,15 @@ import torchaudio
 import math
 from .misc_utils import log_tensor
 from lt_utils.common import *
+from lt_utils.misc_utils import cache_wrapper, default
 import torch.nn.functional as F
+from .model_base import Model
+import warnings
 
 
 def to_mel_spectrogram(
     waveform: torch.Tensor,
-    sample_rate: int = 22050,
+    sample_rate: int = 24000,
     n_fft: int = 1024,
     hop_length: Optional[int] = None,
     win_length: Optional[int] = None,
@@ -39,16 +42,19 @@ def to_mel_spectrogram(
     f_max: Optional[float] = None,
 ) -> torch.Tensor:
     """Converts waveform to mel spectrogram."""
-    mel_spectrogram = torchaudio.transforms.MelSpectrogram(
-        sample_rate=sample_rate,
-        n_fft=n_fft,
-        hop_length=hop_length,
-        win_length=win_length,
-        n_mels=n_mels,
-        f_min=f_min,
-        f_max=f_max,
+    return (
+        torchaudio.transforms.MelSpectrogram(
+            sample_rate=sample_rate,
+            n_fft=n_fft,
+            hop_length=hop_length,
+            win_length=win_length,
+            n_mels=n_mels,
+            f_min=f_min,
+            f_max=f_max,
+        )
+        .to(device=waveform.device)
+        .forward(waveform)
     )
-    return mel_spectrogram(waveform)
 
 
 def stft(
@@ -151,16 +157,6 @@ def mel_to_linear(
     return torch.matmul(mel_fb_inv, mel_spec + eps)
 
 
-def add_noise(x: torch.Tensor, noise_level: float = 0.01) -> torch.Tensor:
-    """Adds Gaussian noise to tensor."""
-    return x + noise_level * torch.randn_like(x)
-
-
-def shift_time(x: torch.Tensor, shift: int) -> torch.Tensor:
-    """Shifts tensor along time axis (last dim)."""
-    return torch.roll(x, shifts=shift, dims=-1)
-
-
 def stretch_tensor(x: torch.Tensor, rate: float, mode: str = "linear") -> torch.Tensor:
     """Time-stretch tensor using interpolation."""
     B, C, T = x.shape if x.ndim == 3 else (1, 1, x.shape[0])
@@ -207,8 +203,7 @@ def generate_window(
         return torch.ones(1, device=device)
 
     n = torch.arange(M, dtype=torch.float32, device=device)
-    window = alpha - (1.0 - alpha) * torch.cos(2.0 * math.pi * n / (M - 1))
-    return window
+    return alpha - (1.0 - alpha) * torch.cos(2.0 * math.pi * n / (M - 1))
 
 
 def pad_center(tensor: torch.Tensor, size: int, axis: int = -1) -> torch.Tensor:
@@ -269,12 +264,12 @@ def normalize(
 def window_sumsquare(
     window_spec: Union[str, int, float, Callable, List[Any], Tuple[Any, ...]],
     n_frames: int,
-    hop_length: int = 300,
-    win_length: int = 1200,
+    hop_length: int = 256,
+    win_length: int = 1024,
     n_fft: int = 2048,
     dtype: torch.dtype = torch.float32,
     norm: Optional[Union[int, float]] = None,
-    device: Optional[torch.device] = "cpu",
+    device: Optional[torch.device] = None,
 ):
     if win_length is None:
         win_length = n_fft
@@ -303,9 +298,9 @@ def window_sumsquare(
 def inverse_transform(
     spec: Tensor,
     phase: Tensor,
-    n_fft: int = 2048,
-    hop_length: int = 300,
-    win_length: int = 1200,
+    n_fft: int = 1024,
+    hop_length: Optional[int] = None,
+    win_length: Optional[int] = None,
     length: Optional[Any] = None,
     window: Optional[Tensor] = None,
 ):
@@ -319,3 +314,168 @@ def inverse_transform(
         window=window,
         length=length,
     )
+
+
+def is_nand(a: bool, b: bool):
+    """[a -> b = result]
+    ```
+    False -> False = True
+    False -> True = True
+    True -> False = True
+    True -> True = False
+    ```
+    """
+    return not (a and b)
+
+
+class InverseTransformConfig:
+    def __init__(
+        self,
+        n_fft: int = 1024,
+        hop_length: Optional[int] = None,
+        win_length: Optional[int] = None,
+        length: Optional[int] = None,
+        window: Optional[Tensor] = None,
+        onesided: Optional[bool] = None,
+        return_complex: bool = False,
+        normalized: bool = False,
+        center: bool = True,
+    ):
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.win_length = win_length
+        self.length = length
+        self.onesided = onesided
+        self.return_complex = return_complex
+        self.normalized = normalized
+        self.center = center
+        self.window = window
+
+    def to_dict(self):
+        return self.__dict__.copy()
+
+
+class InverseTransform(Model):
+    def __init__(
+        self,
+        n_fft: int = 1024,
+        hop_length: Optional[int] = None,
+        win_length: Optional[int] = None,
+        length: Optional[int] = None,
+        window: Optional[Tensor] = None,
+        onesided: Optional[bool] = None,
+        return_complex: bool = False,
+        normalized: bool = False,
+        center: bool = True,
+    ):
+        """
+        Module for inverting a magnitude + phase spectrogram to a waveform using ISTFT.
+
+        This class encapsulates common ISTFT parameters at initialization and applies
+        the inverse transformation in the `forward()` method with minimal per-call overhead.
+
+        Parameters
+        ----------
+        n_fft : int, optional
+            Size of FFT to use during inversion. Default is 1024.
+        hop_length : int, optional
+            Number of audio samples between STFT columns. Defaults to `n_fft`.
+        win_length : int, optional
+            Size of the window function. Defaults to `n_fft // 4`.
+        length : int, optional
+            Output waveform length. If not provided, length will be inferred.
+        window : Tensor, optional
+            Custom window tensor. If None, a Hann window is used.
+        onesided : bool, optional
+            Whether the input STFT was onesided. Required only for consistency checks.
+        return_complex : bool, default=False
+            Must be False if `onesided` is True. Not used internally.
+        normalized : bool, default=False
+            Whether the STFT was normalized.
+        center : bool, default=True
+            Whether the signal was padded during STFT.
+
+        Methods
+        -------
+        forward(spec, phase)
+            Applies ISTFT using stored settings on the given magnitude and phase tensors.
+        update_settings(...)
+            Updates ISTFT parameters dynamically (used internally during forward).
+        """
+        super().__init__()
+        assert window is None or isinstance(window, Tensor)
+        assert any(
+            (
+                (not return_complex and not onesided),
+                (not onesided and return_complex),
+                (not return_complex and onesided),
+            )
+        )
+        self.n_fft = n_fft
+        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.return_complex = return_complex
+        self.onesided = onesided
+        self.normalized = normalized
+        self.window = torch.hann_window(win_length) if window is None else window
+
+    def _apply_device_to(self):
+        """Applies to device while used with module `Model`"""
+        self.window = self.window.to(device=self.device)
+
+    def update_settings(
+        self,
+        *,
+        n_fft: Optional[int] = None,
+        hop_length: Optional[int] = None,
+        win_length: Optional[int] = None,
+        length: Optional[int] = None,
+        window: Optional[Tensor] = None,
+        onesided: Optional[bool] = None,
+        return_complex: Optional[bool] = None,
+        center: Optional[bool] = None,
+        normalized: Optional[bool] = None,
+        **_,
+    ):
+
+        self.kwargs = dict(
+            n_fft=default(n_fft, self.n_fft),
+            hop_length=default(hop_length, self.hop_length),
+            win_length=default(win_length, self.win_length),
+            length=default(length, self.length),
+            window=default(window, self.window),
+            onesided=default(onesided, self.onesided),
+            return_complex=default(return_complex, self.return_complex),
+            center=default(center, self.center),
+            normalized=default(normalized, self.normalized),
+        )
+        if self.kwargs["onesided"] and self.kwargs["return_complex"]:
+            warnings.warn(
+                "You cannot use return_complex with `onesided` enabled. `return_complex` is set to False."
+            )
+            self.kwargs["return_complex"] = False
+
+    def forward(self, spec: Tensor, phase: Tensor, **kwargs):
+        """
+        Perform the inverse short-time Fourier transform.
+
+        Parameters
+        ----------
+        spec : Tensor
+            Magnitude spectrogram of shape (batch, freq, time).
+        phase : Tensor
+            Phase angles tensor, same shape as `spec`, in radians.
+        **kwargs : dict, optional
+            Optional ISTFT override parameters (same as in `update_settings`).
+
+        Returns
+        -------
+        Tensor
+            Time-domain waveform reconstructed from `spec` and `phase`.
+        """
+        if kwargs:
+            self.update_settings(**kwargs)
+
+        return torch.istft(spec * torch.exp(phase * 1j), **self.kwargs)

{lt_tensor-0.0.1a4.dist-info → lt_tensor-0.0.1a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a4
+Version: 0.0.1a7
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336
@@ -17,7 +17,7 @@ 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.1.a3
+Requires-Dist: lt-utils==0.0.1
 Requires-Dist: librosa>=0.11.0
 Dynamic: author
 Dynamic: classifier

lt_tensor-0.0.1a7.dist-info/RECORD

@@ -0,0 +1,28 @@
+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/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/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lt_tensor/datasets/audio.py,sha256=kVluXRbLX7C5W5aFN7CUMb-O1KTHjTiTvE4f7iBcnZk,3754
+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/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
+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=mU0usiagVyNPd0uEadL_lC4BFzSMNpjTIwth82gFJRI,6650
+lt_tensor-0.0.1a7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lt_tensor-0.0.1a7.dist-info/METADATA,sha256=5A9UrpFdhQikU44UlJbLQmQAVTceVhcbPV25jmLM9Os,965
+lt_tensor-0.0.1a7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a7.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a7.dist-info/RECORD,,

lt_tensor-0.0.1a4.dist-info/RECORD

@@ -1,24 +0,0 @@
-lt_tensor/__init__.py,sha256=bvCjaIsYjbGFbR5MNezgLyRgN4_CsyrjmVEvuClsgOU,303
-lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
-lt_tensor/math_ops.py,sha256=ZtnJ9WB-pbFQLsXuNfQl2dAaeob5BWfxmhkwpxITUZ4,2066
-lt_tensor/misc_utils.py,sha256=e44FCQbjNHP-4WOHIbtqqH0x590DzUE6CrD_4Vl_d38,19880
-lt_tensor/model_base.py,sha256=tmRu5pTcELKMFcybOiZ1thJPuJWRSPkbUUtp9Y1NJWw,9555
-lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
-lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
-lt_tensor/transform.py,sha256=IVAaQlq12OvMVhX3lX4lgsTCJYJce5n5MtMy7IK_AU4,8892
-lt_tensor/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lt_tensor/datasets/audio.py,sha256=BZTceP9MlmyrVioHpWLkd_ZcyawYYZUAlVWKfKwyWAg,3318
-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=ND6JR_x6b2Y1VqxZejalv8Cz5_TO3H_Z-0x6UnACbBM,4740
-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-0.0.1a4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lt_tensor-0.0.1a4.dist-info/METADATA,sha256=sbT9xduzE-huVvSjnak9iCo1Eyp45bsMUarc16oTD3o,968
-lt_tensor-0.0.1a4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a4.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a4.dist-info/RECORD,,