cache-dit 1.0.3__py3-none-any.whl → 1.0.14__py3-none-any.whl

cache_dit/cache_factory/cache_blocks/pattern_base.py

@@ -1,458 +0,0 @@
-import inspect
-import torch
-import torch.distributed as dist
-
-from cache_dit.cache_factory.cache_contexts.cache_context import CachedContext
-from cache_dit.cache_factory.cache_contexts.cache_manager import (
-    CachedContextManager,
-    CacheNotExistError,
-)
-from cache_dit.cache_factory import ForwardPattern
-from cache_dit.logger import init_logger
-
-logger = init_logger(__name__)
-
-
-class CachedBlocks_Pattern_Base(torch.nn.Module):
-    _supported_patterns = [
-        ForwardPattern.Pattern_0,
-        ForwardPattern.Pattern_1,
-        ForwardPattern.Pattern_2,
-    ]
-
-    def __init__(
-        self,
-        # 0. Transformer blocks configuration
-        transformer_blocks: torch.nn.ModuleList,
-        transformer: torch.nn.Module = None,
-        forward_pattern: ForwardPattern = ForwardPattern.Pattern_0,
-        check_forward_pattern: bool = True,
-        check_num_outputs: bool = True,
-        # 1. Cache context configuration
-        cache_prefix: str = None,  # maybe un-need.
-        cache_context: CachedContext | str = None,
-        cache_manager: CachedContextManager = None,
-        **kwargs,
-    ):
-        super().__init__()
-
-        # 0. Transformer blocks configuration
-        self.transformer = transformer
-        self.transformer_blocks = transformer_blocks
-        self.forward_pattern = forward_pattern
-        self.check_forward_pattern = check_forward_pattern
-        self.check_num_outputs = check_num_outputs
-        # 1. Cache context configuration
-        self.cache_prefix = cache_prefix
-        self.cache_context = cache_context
-        self.cache_manager = cache_manager
-
-        self._check_forward_pattern()
-        logger.info(
-            f"Match Cached Blocks: {self.__class__.__name__}, for "
-            f"{self.cache_prefix}, cache_context: {self.cache_context}, "
-            f"cache_manager: {self.cache_manager.name}."
-        )
-
-    def _check_forward_pattern(self):
-        if not self.check_forward_pattern:
-            logger.warning(
-                f"Skipped Forward Pattern Check: {self.forward_pattern}"
-            )
-            return
-
-        assert (
-            self.forward_pattern.Supported
-            and self.forward_pattern in self._supported_patterns
-        ), f"Pattern {self.forward_pattern} is not supported now!"
-
-        if self.transformer_blocks is not None:
-            for block in self.transformer_blocks:
-                # Special case for HiDreamBlock
-                if hasattr(block, "block"):
-                    if isinstance(block.block, torch.nn.Module):
-                        block = block.block
-
-                forward_parameters = set(
-                    inspect.signature(block.forward).parameters.keys()
-                )
-
-                if self.check_num_outputs:
-                    num_outputs = str(
-                        inspect.signature(block.forward).return_annotation
-                    ).count("torch.Tensor")
-
-                    if num_outputs > 0:
-                        assert len(self.forward_pattern.Out) == num_outputs, (
-                            f"The number of block's outputs is {num_outputs} don't not "
-                            f"match the number of the pattern: {self.forward_pattern}, "
-                            f"Out: {len(self.forward_pattern.Out)}."
-                        )
-
-                for required_param in self.forward_pattern.In:
-                    assert (
-                        required_param in forward_parameters
-                    ), f"The input parameters must contains: {required_param}."
-
-    @torch.compiler.disable
-    def _check_cache_params(self):
-        assert self.cache_manager.Fn_compute_blocks() <= len(
-            self.transformer_blocks
-        ), (
-            f"Fn_compute_blocks {self.cache_manager.Fn_compute_blocks()} must be less than "
-            f"the number of transformer blocks {len(self.transformer_blocks)}"
-        )
-        assert self.cache_manager.Bn_compute_blocks() <= len(
-            self.transformer_blocks
-        ), (
-            f"Bn_compute_blocks {self.cache_manager.Bn_compute_blocks()} must be less than "
-            f"the number of transformer blocks {len(self.transformer_blocks)}"
-        )
-
-    def call_blocks(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        # Call all blocks to process the hidden states without cache.
-        for block in self.transformer_blocks:
-            hidden_states = block(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            if not isinstance(hidden_states, torch.Tensor):
-                hidden_states, encoder_hidden_states = hidden_states
-                if not self.forward_pattern.Return_H_First:
-                    hidden_states, encoder_hidden_states = (
-                        encoder_hidden_states,
-                        hidden_states,
-                    )
-
-        return hidden_states, encoder_hidden_states
-
-    @torch.compiler.disable
-    def _process_block_outputs(
-        self,
-        hidden_states: torch.Tensor | tuple,
-        encoder_hidden_states: torch.Tensor | None,
-    ) -> tuple[torch.Tensor, torch.Tensor | None]:
-        if not isinstance(hidden_states, torch.Tensor):
-            hidden_states, encoder_hidden_states = hidden_states
-            if not self.forward_pattern.Return_H_First:
-                hidden_states, encoder_hidden_states = (
-                    encoder_hidden_states,
-                    hidden_states,
-                )
-        return hidden_states, encoder_hidden_states
-
-    @torch.compiler.disable
-    def _process_forward_outputs(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor | None,
-    ) -> tuple[torch.Tensor, torch.Tensor | None] | torch.Tensor:
-        return (
-            hidden_states
-            if self.forward_pattern.Return_H_Only
-            else (
-                (hidden_states, encoder_hidden_states)
-                if self.forward_pattern.Return_H_First
-                else (encoder_hidden_states, hidden_states)
-            )
-        )
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        # Use it's own cache context.
-        try:
-            self.cache_manager.set_context(self.cache_context)
-            self._check_cache_params()
-        except CacheNotExistError as e:
-            logger.warning(f"Cache context not exist: {e}, skip cache.")
-            # Call all blocks to process the hidden states.
-            hidden_states, encoder_hidden_states = self.call_blocks(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            return self._process_forward_outputs(
-                hidden_states,
-                encoder_hidden_states,
-            )
-
-        original_hidden_states = hidden_states
-        # Call first `n` blocks to process the hidden states for
-        # more stable diff calculation.
-        hidden_states, encoder_hidden_states = self.call_Fn_blocks(
-            hidden_states,
-            encoder_hidden_states,
-            *args,
-            **kwargs,
-        )
-
-        Fn_hidden_states_residual = hidden_states - original_hidden_states
-        del original_hidden_states
-
-        self.cache_manager.mark_step_begin()
-        # Residual L1 diff or Hidden States L1 diff
-        can_use_cache = self.cache_manager.can_cache(
-            (
-                Fn_hidden_states_residual
-                if not self.cache_manager.is_l1_diff_enabled()
-                else hidden_states
-            ),
-            parallelized=self._is_parallelized(),
-            prefix=(
-                f"{self.cache_prefix}_Fn_residual"
-                if not self.cache_manager.is_l1_diff_enabled()
-                else f"{self.cache_prefix}_Fn_hidden_states"
-            ),
-        )
-
-        torch._dynamo.graph_break()
-        if can_use_cache:
-            self.cache_manager.add_cached_step()
-            del Fn_hidden_states_residual
-            hidden_states, encoder_hidden_states = (
-                self.cache_manager.apply_cache(
-                    hidden_states,
-                    encoder_hidden_states,
-                    prefix=(
-                        f"{self.cache_prefix}_Bn_residual"
-                        if self.cache_manager.is_cache_residual()
-                        else f"{self.cache_prefix}_Bn_hidden_states"
-                    ),
-                    encoder_prefix=(
-                        f"{self.cache_prefix}_Bn_residual"
-                        if self.cache_manager.is_encoder_cache_residual()
-                        else f"{self.cache_prefix}_Bn_hidden_states"
-                    ),
-                )
-            )
-            torch._dynamo.graph_break()
-            # Call last `n` blocks to further process the hidden states
-            # for higher precision.
-            hidden_states, encoder_hidden_states = self.call_Bn_blocks(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-        else:
-            self.cache_manager.set_Fn_buffer(
-                Fn_hidden_states_residual,
-                prefix=f"{self.cache_prefix}_Fn_residual",
-            )
-            if self.cache_manager.is_l1_diff_enabled():
-                # for hidden states L1 diff
-                self.cache_manager.set_Fn_buffer(
-                    hidden_states,
-                    f"{self.cache_prefix}_Fn_hidden_states",
-                )
-            del Fn_hidden_states_residual
-            torch._dynamo.graph_break()
-            (
-                hidden_states,
-                encoder_hidden_states,
-                hidden_states_residual,
-                encoder_hidden_states_residual,
-            ) = self.call_Mn_blocks(  # middle
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            torch._dynamo.graph_break()
-            if self.cache_manager.is_cache_residual():
-                self.cache_manager.set_Bn_buffer(
-                    hidden_states_residual,
-                    prefix=f"{self.cache_prefix}_Bn_residual",
-                )
-            else:
-                self.cache_manager.set_Bn_buffer(
-                    hidden_states,
-                    prefix=f"{self.cache_prefix}_Bn_hidden_states",
-                )
-
-            if self.cache_manager.is_encoder_cache_residual():
-                self.cache_manager.set_Bn_encoder_buffer(
-                    encoder_hidden_states_residual,
-                    prefix=f"{self.cache_prefix}_Bn_residual",
-                )
-            else:
-                self.cache_manager.set_Bn_encoder_buffer(
-                    encoder_hidden_states,
-                    prefix=f"{self.cache_prefix}_Bn_hidden_states",
-                )
-            torch._dynamo.graph_break()
-            # Call last `n` blocks to further process the hidden states
-            # for higher precision.
-            hidden_states, encoder_hidden_states = self.call_Bn_blocks(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-
-        # patch cached stats for blocks or remove it.
-        torch._dynamo.graph_break()
-
-        return self._process_forward_outputs(
-            hidden_states,
-            encoder_hidden_states,
-        )
-
-    @torch.compiler.disable
-    def _is_parallelized(self):
-        # Compatible with distributed inference.
-        return any(
-            (
-                all(
-                    (
-                        self.transformer is not None,
-                        getattr(self.transformer, "_is_parallelized", False),
-                    )
-                ),
-                (dist.is_initialized() and dist.get_world_size() > 1),
-            )
-        )
-
-    @torch.compiler.disable
-    def _is_in_cache_step(self):
-        # Check if the current step is in cache steps.
-        # If so, we can skip some Bn blocks and directly
-        # use the cached values.
-        return (
-            self.cache_manager.get_current_step()
-            in self.cache_manager.get_cached_steps()
-        ) or (
-            self.cache_manager.get_current_step()
-            in self.cache_manager.get_cfg_cached_steps()
-        )
-
-    @torch.compiler.disable
-    def _Fn_blocks(self):
-        # Select first `n` blocks to process the hidden states for
-        # more stable diff calculation.
-        # Fn: [0,...,n-1]
-        selected_Fn_blocks = self.transformer_blocks[
-            : self.cache_manager.Fn_compute_blocks()
-        ]
-        return selected_Fn_blocks
-
-    @torch.compiler.disable
-    def _Mn_blocks(self):  # middle blocks
-        # M(N-2n): only transformer_blocks [n,...,N-n], middle
-        if self.cache_manager.Bn_compute_blocks() == 0:  # WARN: x[:-0] = []
-            selected_Mn_blocks = self.transformer_blocks[
-                self.cache_manager.Fn_compute_blocks() :
-            ]
-        else:
-            selected_Mn_blocks = self.transformer_blocks[
-                self.cache_manager.Fn_compute_blocks() : -self.cache_manager.Bn_compute_blocks()
-            ]
-        return selected_Mn_blocks
-
-    @torch.compiler.disable
-    def _Bn_blocks(self):
-        # Bn: transformer_blocks [N-n+1,...,N-1]
-        selected_Bn_blocks = self.transformer_blocks[
-            -self.cache_manager.Bn_compute_blocks() :
-        ]
-        return selected_Bn_blocks
-
-    def call_Fn_blocks(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        for block in self._Fn_blocks():
-            hidden_states = block(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            hidden_states, encoder_hidden_states = self._process_block_outputs(
-                hidden_states, encoder_hidden_states
-            )
-
-        return hidden_states, encoder_hidden_states
-
-    def call_Mn_blocks(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        original_hidden_states = hidden_states
-        original_encoder_hidden_states = encoder_hidden_states
-        for block in self._Mn_blocks():
-            hidden_states = block(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            hidden_states, encoder_hidden_states = self._process_block_outputs(
-                hidden_states, encoder_hidden_states
-            )
-
-        # compute hidden_states residual
-        hidden_states = hidden_states.contiguous()
-
-        hidden_states_residual = hidden_states - original_hidden_states
-
-        if (
-            encoder_hidden_states is not None
-            and original_encoder_hidden_states is not None
-        ):
-            encoder_hidden_states = encoder_hidden_states.contiguous()
-            encoder_hidden_states_residual = (
-                encoder_hidden_states - original_encoder_hidden_states
-            )
-        else:
-            encoder_hidden_states_residual = None
-
-        return (
-            hidden_states,
-            encoder_hidden_states,
-            hidden_states_residual,
-            encoder_hidden_states_residual,
-        )
-
-    def call_Bn_blocks(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        if self.cache_manager.Bn_compute_blocks() == 0:
-            return hidden_states, encoder_hidden_states
-
-        for block in self._Bn_blocks():
-            hidden_states = block(
-                hidden_states,
-                encoder_hidden_states,
-                *args,
-                **kwargs,
-            )
-            hidden_states, encoder_hidden_states = self._process_block_outputs(
-                hidden_states, encoder_hidden_states
-            )
-
-        return hidden_states, encoder_hidden_states

cache_dit/cache_factory/cache_blocks/pattern_utils.py

@@ -1,41 +0,0 @@
-import torch
-
-from typing import Any
-from cache_dit.cache_factory import CachedContext
-from cache_dit.cache_factory import CachedContextManager
-
-
-def patch_cached_stats(
-    module: torch.nn.Module | Any,
-    cache_context: CachedContext | str = None,
-    cache_manager: CachedContextManager = None,
-):
-    # Patch the cached stats to the module, the cached stats
-    # will be reset for each calling of pipe.__call__(**kwargs).
-    if module is None or cache_manager is None:
-        return
-
-    if cache_context is not None:
-        cache_manager.set_context(cache_context)
-
-    # TODO: Patch more cached stats to the module
-    module._cached_steps = cache_manager.get_cached_steps()
-    module._residual_diffs = cache_manager.get_residual_diffs()
-    module._cfg_cached_steps = cache_manager.get_cfg_cached_steps()
-    module._cfg_residual_diffs = cache_manager.get_cfg_residual_diffs()
-
-
-def remove_cached_stats(
-    module: torch.nn.Module | Any,
-):
-    if module is None:
-        return
-
-    if hasattr(module, "_cached_steps"):
-        del module._cached_steps
-    if hasattr(module, "_residual_diffs"):
-        del module._residual_diffs
-    if hasattr(module, "_cfg_cached_steps"):
-        del module._cfg_cached_steps
-    if hasattr(module, "_cfg_residual_diffs"):
-        del module._cfg_residual_diffs

cache_dit/cache_factory/cache_contexts/__init__.py

@@ -1,15 +0,0 @@
-from cache_dit.cache_factory.cache_contexts.calibrators import (
-    Calibrator,
-    CalibratorBase,
-    CalibratorConfig,
-    TaylorSeerCalibratorConfig,
-    FoCaCalibratorConfig,
-)
-from cache_dit.cache_factory.cache_contexts.cache_context import (
-    CachedContext,
-    BasicCacheConfig,
-)
-from cache_dit.cache_factory.cache_contexts.cache_manager import (
-    CachedContextManager,
-    CacheNotExistError,
-)

cache_dit/cache_factory/patch_functors/__init__.py

@@ -1,15 +0,0 @@
-from cache_dit.cache_factory.patch_functors.functor_base import PatchFunctor
-from cache_dit.cache_factory.patch_functors.functor_dit import DiTPatchFunctor
-from cache_dit.cache_factory.patch_functors.functor_flux import FluxPatchFunctor
-from cache_dit.cache_factory.patch_functors.functor_chroma import (
-    ChromaPatchFunctor,
-)
-from cache_dit.cache_factory.patch_functors.functor_hidream import (
-    HiDreamPatchFunctor,
-)
-from cache_dit.cache_factory.patch_functors.functor_hunyuan_dit import (
-    HunyuanDiTPatchFunctor,
-)
-from cache_dit.cache_factory.patch_functors.functor_qwen_image_controlnet import (
-    QwenImageControlNetPatchFunctor,
-)

cache_dit-1.0.3.dist-info/RECORD

@@ -1,58 +0,0 @@
-cache_dit/__init__.py,sha256=sHRg0swXZZiw6lvSQ53fcVtN9JRayx0az2lXAz5OOGI,1510
-cache_dit/_version.py,sha256=l8k828IdTfzXAlmx4oT8GsiIf2eeMAlFDALjoYk-jrU,704
-cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
-cache_dit/utils.py,sha256=AyYRwi5XBxYBH4GaXxOxv9-X24Te_IYOYwh54t_1d3A,10674
-cache_dit/cache_factory/.gitignore,sha256=5Cb-qT9wsTUoMJ7vACDF7ZcLpAXhi5v-xdcWSRit988,23
-cache_dit/cache_factory/__init__.py,sha256=vy9I6Ofkj9jWeUoOvh-cY5a9QlDDKfj2FVPlVTf7BeA,1390
-cache_dit/cache_factory/cache_interface.py,sha256=fJgsOSR_lP0cvNDrR0zMLLoZBZC6tLAQaPQs_oo2R1o,12577
-cache_dit/cache_factory/cache_types.py,sha256=ooukxQRG55uTLmaZ0SKw6gIeY6SQHhMxkbv55uj2Sqk,991
-cache_dit/cache_factory/forward_pattern.py,sha256=FumlCuZ-TSmSYH0hGBHctSJ-oGLCftdZjLygqhsmdR4,2258
-cache_dit/cache_factory/params_modifier.py,sha256=zYJJsInTYCaYHBZ7mZJOP-PZnkSg3iN1WPewNOayXos,3628
-cache_dit/cache_factory/utils.py,sha256=mm8JNu6XG_w6nMYvv53TmugSb-l3W7l3Y4rJ2xBgktY,1891
-cache_dit/cache_factory/block_adapters/__init__.py,sha256=vM3aDMzPY79Tw4L0hlV2PdA3MFYomnf0eo0BGBo9P78,18087
-cache_dit/cache_factory/block_adapters/block_adapters.py,sha256=2TVK_KqiYXC7AKZ2s07fzdOzUoeUBc9P1SzQtLVzhf4,22249
-cache_dit/cache_factory/block_adapters/block_registers.py,sha256=2L7QeM4ygnaKQpC9PoJod0QRYyxidUKU2AYpysDCUwE,2572
-cache_dit/cache_factory/cache_adapters/__init__.py,sha256=py71WGD3JztQ1uk6qdLVbzYcQ1rvqFidNNaQYo7tqTo,79
-cache_dit/cache_factory/cache_adapters/cache_adapter.py,sha256=HTyZdspd34G6QiJ2qPNoLmGwcxmAnCwpAf91NTIQtl4,21442
-cache_dit/cache_factory/cache_blocks/__init__.py,sha256=mivvm8YOfqT7YHs8y_MzGOGztPw8LxAqKGXuSRXxCv0,3032
-cache_dit/cache_factory/cache_blocks/offload_utils.py,sha256=wusgcqaCrwEjvv7Guy-6VXhNOgPPUrBV2sSVuRmGuvo,3513
-cache_dit/cache_factory/cache_blocks/pattern_0_1_2.py,sha256=ElMps6_7uI74tSF9GDR_dEI0bZEhdzcepM29xFWnYo8,428
-cache_dit/cache_factory/cache_blocks/pattern_3_4_5.py,sha256=mzs1S2YFwNAPMMTisTKbU6GA5m60J_20CAVy9OIWoMQ,10652
-cache_dit/cache_factory/cache_blocks/pattern_base.py,sha256=UeBYEz3hamO3CyVMj1KI7GnxRVQGBjQ5EJi90obVZyI,16306
-cache_dit/cache_factory/cache_blocks/pattern_utils.py,sha256=dGOC1tMMOvcbvEgx44eTESKn_jsv-0RZ3tRHPa3wmQ4,1315
-cache_dit/cache_factory/cache_contexts/__init__.py,sha256=N3SxFnluXk5q09nhSqKIJCVzEGWzySJWm-vic6dH79E,412
-cache_dit/cache_factory/cache_contexts/cache_context.py,sha256=FXvrR3XZr4iIsKSTBngzaRM6_WxiHkRNQ3wAJz40kbk,15798
-cache_dit/cache_factory/cache_contexts/cache_manager.py,sha256=X99XnmiY-Us8D2pqJGPKxWcXAhQQpk3xdEWOOOYXIZ4,30465
-cache_dit/cache_factory/cache_contexts/calibrators/__init__.py,sha256=mzYXO8tbytGpJJ9rpPu20kMoj1Iu_7Ym9tjfzV8rA98,5574
-cache_dit/cache_factory/cache_contexts/calibrators/base.py,sha256=mn6ZBkChGpGwN5csrHTUGMoX6BBPvqHXSLbIExiW-EU,748
-cache_dit/cache_factory/cache_contexts/calibrators/foca.py,sha256=nhHGs_hxwW1M942BQDMJb9-9IuHdnOxp774Jrna1bJI,891
-cache_dit/cache_factory/cache_contexts/calibrators/taylorseer.py,sha256=aGxr9SpytYznTepDWGPAxWDnuVMSuNyn6uNXnLh2acQ,4001
-cache_dit/cache_factory/patch_functors/__init__.py,sha256=IJZrvSkeHbR_xW-6IzY7sqEhApBsOfPyorQGJutvWH0,652
-cache_dit/cache_factory/patch_functors/functor_base.py,sha256=Ahk0fTfrHgNdEl-9JSkACvfyyv9G-Ei5OSz7XBIlX5o,357
-cache_dit/cache_factory/patch_functors/functor_chroma.py,sha256=xD0Q96VArp1vYBLQ0pcjRIyFB1i_Y7muZ2q07Hz8Oqs,13430
-cache_dit/cache_factory/patch_functors/functor_dit.py,sha256=SDjhzCWa6PoFNN4_upoQEf6DHvW1yJ7zuXMS2VvyJco,3904
-cache_dit/cache_factory/patch_functors/functor_flux.py,sha256=UMkyuEYjO7UO_zmXi9Djd-nD-XMgCUgE-qkYA3plWSM,9559
-cache_dit/cache_factory/patch_functors/functor_hidream.py,sha256=inf4T5UcIa06zVsoLWCNJbb1bEDmGeBGSyC7OL1zpuc,15309
-cache_dit/cache_factory/patch_functors/functor_hunyuan_dit.py,sha256=iSo5dD5uKnjQQeysDUIkKt0wdnK5bzXTc_F_lfHG70w,6401
-cache_dit/cache_factory/patch_functors/functor_qwen_image_controlnet.py,sha256=D5i1Rrq1FQ49liupLcV2DW04moBqLnW9TICzfnMMzIU,10519
-cache_dit/compile/__init__.py,sha256=FcTVzCeyypl-mxlc59_ehHL3lBNiDAFsXuRoJ-5Cfi0,56
-cache_dit/compile/utils.py,sha256=nN2OIrSdwRR5zGxJinKDqb07pXpvTNTF3g_OgLkeeBU,3858
-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=UjPJ69DyyjZDfERTpKAjZKOxOTx58aWnkze7VfH3en8,673
-cache_dit/metrics/clip_score.py,sha256=ERNCFQFJKzJdbIX9OAg-1LiSPuXUVHLOFxbf2gcENpc,3938
-cache_dit/metrics/config.py,sha256=ieOgD9ayz722RjVzk24bSIqS2D6o7TZjGk8KeXV-OLQ,551
-cache_dit/metrics/fid.py,sha256=ZM_FM0XERtpnkMUfphmw2aOdljrh1uba-pnYItu0q6M,18219
-cache_dit/metrics/image_reward.py,sha256=N8HalJo1T1js0dsNb2V1KRv4kIdcm3nhx7iOXJuqcns,5421
-cache_dit/metrics/inception.py,sha256=pBVe2X6ylLPIXTG4-GWDM9DWnCviMJbJ45R3ulhktR0,12759
-cache_dit/metrics/lpips.py,sha256=hrHrmdM-f2B4TKDs0xLqJO5JFaYcCjq2qNIR8oCrVkc,811
-cache_dit/metrics/metrics.py,sha256=AZbQyoavE-djvyRUZ_EfCIrWSQbiWQFo7n2dhn7XptE,40466
-cache_dit/quantize/__init__.py,sha256=kWYoMAyZgBXu9BJlZjTQ0dRffW9GqeeY9_iTkXrb70A,59
-cache_dit/quantize/quantize_ao.py,sha256=Pr3u3Qr6qLvFkd8k-_rfcz4Mkjlg36U9BHG2t6Bl-6M,6301
-cache_dit/quantize/quantize_interface.py,sha256=2s_R7xPSKuJeFpEGeLwRxnq_CqJcBG3a3lzyW5wh-UM,1241
-cache_dit-1.0.3.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-1.0.3.dist-info/METADATA,sha256=gPY4pnvl4dvTTu7Twv6unzEesu1fXCDlGNMlSdFP3Lc,28103
-cache_dit-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-1.0.3.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
-cache_dit-1.0.3.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-1.0.3.dist-info/RECORD,,

cache_dit-1.0.3.dist-info/licenses/LICENSE

@@ -1,53 +0,0 @@
-# License
-
-## Acceptance
-
-By using the software, you agree to all of the terms and conditions below.
-
-## Copyright License
-
-The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below.
-
-## Limitations
-
-You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
-
-You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
-
-You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
-
-## Patents
-
-The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
-
-If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
-No Other Rights
-
-These terms do not imply any licenses other than those expressly granted in these terms.
-
-## Termination
-
-If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
-
-## No Liability
-
-As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
-Definitions
-
-The licensor is the entity offering these terms, and the software is the software the licensor makes available under these terms, including any portion of it.
-
-## Definitions
-
-you refers to the individual or entity agreeing to these terms.
-
-your company is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. control means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
-
-your licenses are all the licenses granted to you for the software under these terms.
-
-use means anything you do with the software requiring one of your licenses.
-
-trademark means trademarks, service marks, and similar rights.