cache-dit 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

cache_dit/cache_factory/first_block_cache/diffusers_adapters/__init__.py

@@ -1,57 +0,0 @@
-# Adapted from: https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache/__init__.py
-
-import importlib
-from typing import Callable
-
-from diffusers import DiffusionPipeline
-
-
-def apply_fb_cache_on_transformer(transformer, *args, **kwargs):
-    transformer_cls_name: str = transformer.__class__.__name__
-    if transformer_cls_name.startswith("Flux"):
-        adapter_name = "flux"
-    elif transformer_cls_name.startswith("Mochi"):
-        adapter_name = "mochi"
-    elif transformer_cls_name.startswith("CogVideoX"):
-        adapter_name = "cogvideox"
-    elif transformer_cls_name.startswith("Wan"):
-        adapter_name = "wan"
-    elif transformer_cls_name.startswith("HunyuanVideo"):
-        adapter_name = "hunyuan_video"
-    else:
-        raise ValueError(
-            f"Unknown transformer class name: {transformer_cls_name}"
-        )
-
-    adapter_module = importlib.import_module(f".{adapter_name}", __package__)
-    apply_cache_on_transformer_fn = getattr(
-        adapter_module, "apply_cache_on_transformer"
-    )
-    return apply_cache_on_transformer_fn(transformer, *args, **kwargs)
-
-
-def apply_fb_cache_on_pipe(pipe: DiffusionPipeline, *args, **kwargs):
-    assert isinstance(pipe, DiffusionPipeline)
-
-    pipe_cls_name: str = pipe.__class__.__name__
-    if pipe_cls_name.startswith("Flux"):
-        adapter_name = "flux"
-    elif pipe_cls_name.startswith("Mochi"):
-        adapter_name = "mochi"
-    elif pipe_cls_name.startswith("CogVideoX"):
-        adapter_name = "cogvideox"
-    elif pipe_cls_name.startswith("Wan"):
-        adapter_name = "wan"
-    elif pipe_cls_name.startswith("HunyuanVideo"):
-        adapter_name = "hunyuan_video"
-    else:
-        raise ValueError(f"Unknown pipeline class name: {pipe_cls_name}")
-
-    adapter_module = importlib.import_module(f".{adapter_name}", __package__)
-    apply_cache_on_pipe_fn = getattr(adapter_module, "apply_cache_on_pipe")
-    return apply_cache_on_pipe_fn(pipe, *args, **kwargs)
-
-
-# re-export functions for compatibility
-apply_cache_on_transformer: Callable = apply_fb_cache_on_transformer
-apply_cache_on_pipe: Callable = apply_fb_cache_on_pipe

cache_dit/cache_factory/first_block_cache/diffusers_adapters/flux.py

@@ -1,100 +0,0 @@
-# Adapted from: https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache/flux.py
-
-import functools
-import unittest
-
-import torch
-from diffusers import DiffusionPipeline, FluxTransformer2DModel
-
-from cache_dit.cache_factory.first_block_cache import cache_context
-
-
-def apply_cache_on_transformer(
-    transformer: FluxTransformer2DModel,
-):
-    if getattr(transformer, "_is_cached", False):
-        return transformer
-
-    cached_transformer_blocks = torch.nn.ModuleList(
-        [
-            cache_context.CachedTransformerBlocks(
-                transformer.transformer_blocks,
-                transformer.single_transformer_blocks,
-                transformer=transformer,
-                return_hidden_states_first=False,
-            )
-        ]
-    )
-    dummy_single_transformer_blocks = torch.nn.ModuleList()
-
-    original_forward = transformer.forward
-
-    @functools.wraps(original_forward)
-    def new_forward(
-        self,
-        *args,
-        **kwargs,
-    ):
-        with (
-            unittest.mock.patch.object(
-                self,
-                "transformer_blocks",
-                cached_transformer_blocks,
-            ),
-            unittest.mock.patch.object(
-                self,
-                "single_transformer_blocks",
-                dummy_single_transformer_blocks,
-            ),
-        ):
-            return original_forward(
-                *args,
-                **kwargs,
-            )
-
-    transformer.forward = new_forward.__get__(transformer)
-
-    transformer._is_cached = True
-
-    return transformer
-
-
-def apply_cache_on_pipe(
-    pipe: DiffusionPipeline,
-    *,
-    shallow_patch: bool = False,
-    residual_diff_threshold=0.05,
-    downsample_factor=1,
-    warmup_steps=0,
-    max_cached_steps=-1,
-    **kwargs,
-):
-    cache_kwargs, kwargs = cache_context.collect_cache_kwargs(
-        default_attrs={
-            "residual_diff_threshold": residual_diff_threshold,
-            "downsample_factor": downsample_factor,
-            "warmup_steps": warmup_steps,
-            "max_cached_steps": max_cached_steps,
-        },
-        **kwargs,
-    )  # noqa
-
-    if not getattr(pipe, "_is_cached", False):
-        original_call = pipe.__class__.__call__
-
-        @functools.wraps(original_call)
-        def new_call(self, *args, **kwargs):
-            with cache_context.cache_context(
-                cache_context.create_cache_context(
-                    **cache_kwargs,
-                )
-            ):
-                return original_call(self, *args, **kwargs)
-
-        pipe.__class__.__call__ = new_call
-        pipe.__class__._is_cached = True
-
-    if not shallow_patch:
-        apply_cache_on_transformer(pipe.transformer, **kwargs)
-
-    return pipe

cache_dit/cache_factory/first_block_cache/diffusers_adapters/hunyuan_video.py

@@ -1,295 +0,0 @@
-# Adapted from: https://github.com/chengzeyi/ParaAttention/blob/main/src/para_attn/first_block_cache/diffusers_adapters/hunyuan_video.py
-import functools
-import unittest
-from typing import Any, Dict, Optional, Union
-
-import torch
-from diffusers import DiffusionPipeline, HunyuanVideoTransformer3DModel
-from diffusers.models.modeling_outputs import Transformer2DModelOutput
-from diffusers.utils import (
-    scale_lora_layers,
-    unscale_lora_layers,
-    USE_PEFT_BACKEND,
-)
-
-from cache_dit.cache_factory.first_block_cache import cache_context
-from cache_dit.logger import init_logger
-
-try:
-    from para_attn.para_attn_interface import SparseKVAttnMode
-
-    def is_sparse_kv_attn_available():
-        return True
-
-except ImportError:
-
-    class SparseKVAttnMode:
-        def __enter__(self):
-            pass
-
-        def __exit__(self, exc_type, exc_value, traceback):
-            pass
-
-    def is_sparse_kv_attn_available():
-        return False
-
-
-logger = init_logger(__name__)  # pylint: disable=invalid-name
-
-
-def apply_cache_on_transformer(
-    transformer: HunyuanVideoTransformer3DModel,
-):
-    if getattr(transformer, "_is_cached", False):
-        return transformer
-
-    cached_transformer_blocks = torch.nn.ModuleList(
-        [
-            cache_context.CachedTransformerBlocks(
-                transformer.transformer_blocks
-                + transformer.single_transformer_blocks,
-                transformer=transformer,
-            )
-        ]
-    )
-    dummy_single_transformer_blocks = torch.nn.ModuleList()
-
-    original_forward = transformer.forward
-
-    @functools.wraps(transformer.__class__.forward)
-    def new_forward(
-        self,
-        hidden_states: torch.Tensor,
-        timestep: torch.LongTensor,
-        encoder_hidden_states: torch.Tensor,
-        encoder_attention_mask: torch.Tensor,
-        pooled_projections: torch.Tensor,
-        guidance: torch.Tensor = None,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        return_dict: bool = True,
-        **kwargs,
-    ) -> Union[torch.Tensor, Dict[str, torch.Tensor]]:
-        with (
-            unittest.mock.patch.object(
-                self,
-                "transformer_blocks",
-                cached_transformer_blocks,
-            ),
-            unittest.mock.patch.object(
-                self,
-                "single_transformer_blocks",
-                dummy_single_transformer_blocks,
-            ),
-        ):
-            if getattr(self, "_is_parallelized", False):
-                return original_forward(
-                    hidden_states,
-                    timestep,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    pooled_projections,
-                    guidance=guidance,
-                    attention_kwargs=attention_kwargs,
-                    return_dict=return_dict,
-                    **kwargs,
-                )
-            else:
-                if attention_kwargs is not None:
-                    attention_kwargs = attention_kwargs.copy()
-                    lora_scale = attention_kwargs.pop("scale", 1.0)
-                else:
-                    lora_scale = 1.0
-
-                if USE_PEFT_BACKEND:
-                    # weight the lora layers by setting `lora_scale` for each PEFT layer
-                    scale_lora_layers(self, lora_scale)
-                else:
-                    if (
-                        attention_kwargs is not None
-                        and attention_kwargs.get("scale", None) is not None
-                    ):
-                        logger.warning(
-                            "Passing `scale` via `attention_kwargs` when not using the PEFT backend is ineffective."
-                        )
-
-                batch_size, num_channels, num_frames, height, width = (
-                    hidden_states.shape
-                )
-                p, p_t = self.config.patch_size, self.config.patch_size_t
-                post_patch_num_frames = num_frames // p_t
-                post_patch_height = height // p
-                post_patch_width = width // p
-
-                # 1. RoPE
-                image_rotary_emb = self.rope(hidden_states)
-
-                # 2. Conditional embeddings
-                temb = self.time_text_embed(
-                    timestep, guidance, pooled_projections
-                )
-                hidden_states = self.x_embedder(hidden_states)
-                encoder_hidden_states = self.context_embedder(
-                    encoder_hidden_states, timestep, encoder_attention_mask
-                )
-
-                # 3. Attention mask preparation
-                latent_sequence_length = hidden_states.shape[1]
-                latent_attention_mask = torch.ones(
-                    batch_size,
-                    1,
-                    latent_sequence_length,
-                    device=hidden_states.device,
-                    dtype=torch.bool,
-                )  # [B, 1, N]
-                attention_mask = torch.cat(
-                    [
-                        latent_attention_mask,
-                        encoder_attention_mask.unsqueeze(1).to(torch.bool),
-                    ],
-                    dim=-1,
-                )  # [B, 1, N + M]
-
-                with SparseKVAttnMode():
-                    # 4. Transformer blocks
-                    hidden_states, encoder_hidden_states = (
-                        self.call_transformer_blocks(
-                            hidden_states,
-                            encoder_hidden_states,
-                            temb,
-                            attention_mask,
-                            image_rotary_emb,
-                        )
-                    )
-
-                # 5. Output projection
-                hidden_states = self.norm_out(hidden_states, temb)
-                hidden_states = self.proj_out(hidden_states)
-
-                hidden_states = hidden_states.reshape(
-                    batch_size,
-                    post_patch_num_frames,
-                    post_patch_height,
-                    post_patch_width,
-                    -1,
-                    p_t,
-                    p,
-                    p,
-                )
-                hidden_states = hidden_states.permute(0, 4, 1, 5, 2, 6, 3, 7)
-                hidden_states = (
-                    hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
-                )
-
-                hidden_states = hidden_states.to(timestep.dtype)
-
-                if USE_PEFT_BACKEND:
-                    # remove `lora_scale` from each PEFT layer
-                    unscale_lora_layers(self, lora_scale)
-
-                if not return_dict:
-                    return (hidden_states,)
-
-                return Transformer2DModelOutput(sample=hidden_states)
-
-    transformer.forward = new_forward.__get__(transformer)
-
-    def call_transformer_blocks(
-        self, hidden_states, encoder_hidden_states, *args, **kwargs
-    ):
-        if torch.is_grad_enabled() and self.gradient_checkpointing:
-
-            def create_custom_forward(module, return_dict=None):
-                def custom_forward(*inputs):
-                    if return_dict is not None:
-                        return module(*inputs, return_dict=return_dict)
-                    else:
-                        return module(*inputs)
-
-                return custom_forward
-
-            ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False}
-
-            for block in self.transformer_blocks:
-                hidden_states, encoder_hidden_states = (
-                    torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(block),
-                        hidden_states,
-                        encoder_hidden_states,
-                        *args,
-                        **kwargs,
-                        **ckpt_kwargs,
-                    )
-                )
-
-            for block in self.single_transformer_blocks:
-                hidden_states, encoder_hidden_states = (
-                    torch.utils.checkpoint.checkpoint(
-                        create_custom_forward(block),
-                        hidden_states,
-                        encoder_hidden_states,
-                        *args,
-                        **kwargs,
-                        **ckpt_kwargs,
-                    )
-                )
-
-        else:
-            for block in self.transformer_blocks:
-                hidden_states, encoder_hidden_states = block(
-                    hidden_states, encoder_hidden_states, *args, **kwargs
-                )
-
-            for block in self.single_transformer_blocks:
-                hidden_states, encoder_hidden_states = block(
-                    hidden_states, encoder_hidden_states, *args, **kwargs
-                )
-
-        return hidden_states, encoder_hidden_states
-
-    transformer.call_transformer_blocks = call_transformer_blocks.__get__(
-        transformer
-    )
-
-    transformer._is_cached = True
-
-    return transformer
-
-
-def apply_cache_on_pipe(
-    pipe: DiffusionPipeline,
-    *,
-    shallow_patch: bool = False,
-    residual_diff_threshold=0.06,
-    downsample_factor=1,
-    warmup_steps=0,
-    max_cached_steps=-1,
-    **kwargs,
-):
-    cache_kwargs, kwargs = cache_context.collect_cache_kwargs(
-        default_attrs={
-            "residual_diff_threshold": residual_diff_threshold,
-            "downsample_factor": downsample_factor,
-            "warmup_steps": warmup_steps,
-            "max_cached_steps": max_cached_steps,
-        },
-        **kwargs,
-    )
-    if not getattr(pipe, "_is_cached", False):
-        original_call = pipe.__class__.__call__
-
-        @functools.wraps(original_call)
-        def new_call(self, *args, **kwargs):
-            with cache_context.cache_context(
-                cache_context.create_cache_context(
-                    **cache_kwargs,
-                )
-            ):
-                return original_call(self, *args, **kwargs)
-
-        pipe.__class__.__call__ = new_call
-        pipe.__class__._is_cached = True
-
-    if not shallow_patch:
-        apply_cache_on_transformer(pipe.transformer, **kwargs)
-
-    return pipe

cache_dit/cache_factory/first_block_cache/diffusers_adapters/wan.py

@@ -1,98 +0,0 @@
-# Adapted from: https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache/wan.py
-
-import functools
-import unittest
-
-import torch
-from diffusers import DiffusionPipeline, WanTransformer3DModel
-
-from cache_dit.cache_factory.first_block_cache import cache_context
-
-
-def apply_cache_on_transformer(
-    transformer: WanTransformer3DModel,
-):
-    if getattr(transformer, "_is_cached", False):
-        return transformer
-
-    blocks = torch.nn.ModuleList(
-        [
-            cache_context.CachedTransformerBlocks(
-                transformer.blocks,
-                transformer=transformer,
-                return_hidden_states_only=True,
-            )
-        ]
-    )
-
-    original_forward = transformer.forward
-
-    @functools.wraps(transformer.__class__.forward)
-    def new_forward(
-        self,
-        *args,
-        **kwargs,
-    ):
-        with unittest.mock.patch.object(
-            self,
-            "blocks",
-            blocks,
-        ):
-            return original_forward(
-                *args,
-                **kwargs,
-            )
-
-    transformer.forward = new_forward.__get__(transformer)
-
-    transformer._is_cached = True
-
-    return transformer
-
-
-def apply_cache_on_pipe(
-    pipe: DiffusionPipeline,
-    *,
-    shallow_patch: bool = False,
-    residual_diff_threshold=0.03,
-    downsample_factor=1,
-    slg_layers=None,
-    slg_start: float = 0.0,
-    slg_end: float = 0.1,
-    warmup_steps=0,
-    max_cached_steps=-1,
-    **kwargs,
-):
-    cache_kwargs, kwargs = cache_context.collect_cache_kwargs(
-        default_attrs={
-            "residual_diff_threshold": residual_diff_threshold,
-            "downsample_factor": downsample_factor,
-            "enable_alter_cache": True,
-            "slg_layers": slg_layers,
-            "slg_start": slg_start,
-            "slg_end": slg_end,
-            "num_inference_steps": kwargs.get("num_inference_steps", 50),
-            "warmup_steps": warmup_steps,
-            "max_cached_steps": max_cached_steps,
-        },
-        **kwargs,
-    )
-    if not getattr(pipe, "_is_cached", False):
-        original_call = pipe.__class__.__call__
-
-        @functools.wraps(original_call)
-        def new_call(self, *args, **kwargs):
-            with cache_context.cache_context(
-                cache_context.create_cache_context(
-                    **cache_kwargs,
-                )
-            ):
-                return original_call(self, *args, **kwargs)
-
-        pipe.__class__.__call__ = new_call
-        pipe.__class__._is_cached = True
-
-    if not shallow_patch:
-        apply_cache_on_transformer(pipe.transformer, **kwargs)
-
-    return pipe

cache_dit-0.2.14.dist-info/RECORD

@@ -1,49 +0,0 @@
-cache_dit/__init__.py,sha256=0-B173-fLi3IA8nJXoS71zK0zD33Xplysd9skmLfEOY,171
-cache_dit/_version.py,sha256=ut2sCt69XoYh0A1_KAmfCg1IKkN6zwqhu2eMFWAhMbQ,513
-cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
-cache_dit/primitives.py,sha256=A2iG9YLot3gOsZSPp-_gyjqjLgJvWQRx8aitD4JQ23Y,3877
-cache_dit/utils.py,sha256=4cFNh0asch6Zgsixq0bS1ElfwBu_6BG5ZSmaa1khjyg,144
-cache_dit/cache_factory/__init__.py,sha256=iYQwLwB_XLoYl0OB9unZGDbBtrYvZaLkOAmhGRwdW2E,191
-cache_dit/cache_factory/adapters.py,sha256=QMCaXnmqM7NT7sx4bCF1mMLn-QcXX9h1RmgLAypDedg,5256
-cache_dit/cache_factory/taylorseer.py,sha256=LKSNo2ode69EVo9xrxjxAMEjz0yDGiGADeDYnEqddA8,3987
-cache_dit/cache_factory/utils.py,sha256=V-Mb5Jn07geEUUWo4QAfh6pmSzkL-2OGDn0VAXbG6hQ,1799
-cache_dit/cache_factory/dual_block_cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/cache_factory/dual_block_cache/cache_context.py,sha256=sJ9yxQlcrX4qkPln94FrL0WDe2WIn3_UD2-Mk8YtjSw,73301
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/__init__.py,sha256=krNAICf-aS3JLmSG8vOB9tpLa04uYRcABsC8PMbVUKY,1870
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/cogvideox.py,sha256=3xUjvDzor9AkBkDUc0N7kZqM86MIdajuigesnicNzXE,2260
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/flux.py,sha256=cIsov6Pf0dRyddqkzTA2CU-jSDotof8LQr-HIoY9T9M,2615
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/hunyuan_video.py,sha256=SO4q39PQuQ5QVHy5Z-ubiKdstzvQPedONN2J5oiGUh0,9955
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/mochi.py,sha256=8W9m-WeEVE2ytYi9udKEA8Wtb0EnvP3eT2A1Tu-d29k,2252
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/wan.py,sha256=EREHM5E1wxnL-uRXRAEege4HXraRp1oD_r1Zx4CsiKk,2596
-cache_dit/cache_factory/dynamic_block_prune/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/cache_factory/dynamic_block_prune/prune_context.py,sha256=1qarKAsEFiaaN2_ghko2dqGz_R7BTQSOyGtb_eQq38Y,35716
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/__init__.py,sha256=hVBTXj9MMGFGVezT3j8MntFRBiphSaUL4YhSOd8JtuY,1870
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/cogvideox.py,sha256=KP8NxtHAKzzBOoX0lhvlMgY_5dmP4Z3T5TOfwl4SSyg,2273
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/flux.py,sha256=kCB7lL4OIq8TZn-baMIF8D_PVPTFW60omCMVQCb8ebs,2628
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/hunyuan_video.py,sha256=xAkd40BGsfuCKdW3Abrx35VwgZQg4CZFz13P4VY71eY,9968
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/mochi.py,sha256=zXgoRDDjus3a2WSjtNh4ERtQp20ceb6nzohHMDlo2zY,2265
-cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/wan.py,sha256=PA7nuLgfAelnaI8usQx0Kxi8XATzMapyR1WndEdFoZA,2604
-cache_dit/cache_factory/first_block_cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/cache_factory/first_block_cache/cache_context.py,sha256=qn4zWJ_eEMIPYzrxXoslunxbzK0WueuNtC54Pp5Q57k,23241
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/__init__.py,sha256=-FFgA2MoudEo7uDacg4aWgm1KwfLZFsEDTVxatgbq9M,2146
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/cogvideox.py,sha256=qO5CWyurtwW30mvOe6cxeQPTSXLDlPJcezm72zEjDq8,2375
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/flux.py,sha256=Dcd4OzABCtyQCZNX2KNnUTdVoO1E1ApM7P8gcVYzcK0,2733
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/hunyuan_video.py,sha256=OL7W4ukYlZz0IDmBR1zVV6XT3Mgciglj9Hqzv1wUAkQ,10092
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/mochi.py,sha256=lQTClo52OwPbNEE4jiBZQhfC7hbtYqnYIABp_vbm_dk,2363
-cache_dit/cache_factory/first_block_cache/diffusers_adapters/wan.py,sha256=dBNzHBECAuTTA1a7kLdvZL20YzaKTAS3iciVLzKKEWA,2638
-cache_dit/compile/__init__.py,sha256=DfMdPleFFGADXLsr7zXui8BTz_y9futY6rNmNdh9y7k,63
-cache_dit/compile/utils.py,sha256=N4A55_8uIbEd-S4xyJPcrdKceI2MGM9BTIhJE63jyL4,3786
-cache_dit/custom_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/custom_ops/triton_taylorseer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/metrics/__init__.py,sha256=RaUhl5dieF40RqnizGzR30qoJJ9dyMUEADwgwMaMQrE,575
-cache_dit/metrics/config.py,sha256=ieOgD9ayz722RjVzk24bSIqS2D6o7TZjGk8KeXV-OLQ,551
-cache_dit/metrics/fid.py,sha256=9Ivtazl6mW0Bon2VXa-Ia5Xj2ewxRD3V1Qkd69zYM3Y,17066
-cache_dit/metrics/inception.py,sha256=pBVe2X6ylLPIXTG4-GWDM9DWnCviMJbJ45R3ulhktR0,12759
-cache_dit/metrics/lpips.py,sha256=I2qCNi6qJh5TRsaIsdxO0WoRX1DN7U_H3zS0oCSahYM,1032
-cache_dit/metrics/metrics.py,sha256=8jvM1sF-nDxUuwCRy44QEoo4dYVLCQVh1QyAMs4eaQY,27840
-cache_dit-0.2.14.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-0.2.14.dist-info/METADATA,sha256=EyZN75JcVcvTc5bopHXfl6w-nA-ro9Uit2Sjy5DU66A,25198
-cache_dit-0.2.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-0.2.14.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
-cache_dit-0.2.14.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-0.2.14.dist-info/RECORD,,