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

cache_dit/cache_factory/cache_blocks/pattern_base.py

@@ -1,404 +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,
-)
-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 forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        *args,
-        **kwargs,
-    ):
-        # Use it's own cache context.
-        self.cache_manager.set_context(self.cache_context)
-        self._check_cache_params()
-
-        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 (
-            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)
-            )
-        )
-
-    @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,
-            )
-            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
-
-    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,
-            )
-            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,
-                    )
-
-        # 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,
-            )
-            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

cache_dit/cache_factory/cache_blocks/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,14 +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,
-)

cache_dit/cache_factory/cache_interface.py

@@ -1,217 +0,0 @@
-from typing import Any, Tuple, List, Union, Optional
-from diffusers import DiffusionPipeline
-from cache_dit.cache_factory.cache_types import CacheType
-from cache_dit.cache_factory.block_adapters import BlockAdapter
-from cache_dit.cache_factory.block_adapters import BlockAdapterRegistry
-from cache_dit.cache_factory.cache_adapters import CachedAdapter
-from cache_dit.cache_factory.cache_contexts import BasicCacheConfig
-from cache_dit.cache_factory.cache_contexts import CalibratorConfig
-from cache_dit.cache_factory.params_modifier import ParamsModifier
-
-from cache_dit.logger import init_logger
-
-logger = init_logger(__name__)
-
-
-def enable_cache(
-    # DiffusionPipeline or BlockAdapter
-    pipe_or_adapter: Union[
-        DiffusionPipeline,
-        BlockAdapter,
-    ],
-    # Basic DBCache config: BasicCacheConfig
-    cache_config: BasicCacheConfig = BasicCacheConfig(),
-    # Calibrator config: TaylorSeerCalibratorConfig, etc.
-    calibrator_config: Optional[CalibratorConfig] = None,
-    # Modify cache context params for specific blocks.
-    params_modifiers: Optional[
-        Union[
-            ParamsModifier,
-            List[ParamsModifier],
-            List[List[ParamsModifier]],
-        ]
-    ] = None,
-    # Other cache context kwargs: Deprecated cache kwargs
-    **kwargs,
-) -> Union[
-    DiffusionPipeline,
-    BlockAdapter,
-]:
-    r"""
-    Unified Cache API for  almost Any Diffusion Transformers (with Transformer Blocks
-    that match the specific Input and Output patterns).
-
-    For a good balance between performance and precision, DBCache is configured by default
-    with F8B0, 8 warmup steps, and unlimited cached steps.
-
-    Args:
-        pipe_or_adapter (`DiffusionPipeline` or `BlockAdapter`, *required*):
-            The standard Diffusion Pipeline or custom BlockAdapter (from cache-dit or user-defined).
-            For example: cache_dit.enable_cache(FluxPipeline(...)). Please check https://github.com/vipshop/cache-dit/blob/main/docs/BlockAdapter.md
-            for the usgae of BlockAdapter.
-        cache_config (`BasicCacheConfig`, *required*, defaults to BasicCacheConfig()):
-            Basic DBCache config for cache context, defaults to BasicCacheConfig(). The configurable params listed belows:
-                Fn_compute_blocks: (`int`, *required*, defaults to 8):
-                    Specifies that `DBCache` uses the **first n** Transformer blocks to fit the information
-                    at time step t, enabling the calculation of a more stable L1 diff and delivering more
-                    accurate information to subsequent blocks. Please check https://github.com/vipshop/cache-dit/blob/main/docs/DBCache.md
-                    for more details of DBCache.
-                Bn_compute_blocks: (`int`, *required*, defaults to 0):
-                    Further fuses approximate information in the **last n** Transformer blocks to enhance
-                    prediction accuracy. These blocks act as an auto-scaler for approximate hidden states
-                    that use residual cache.
-                residual_diff_threshold (`float`, *required*, defaults to 0.08):
-                    the value of residual diff threshold, a higher value leads to faster performance at the
-                    cost of lower precision.
-                max_warmup_steps (`int`, *required*, defaults to 8):
-                    DBCache does not apply the caching strategy when the number of running steps is less than
-                    or equal to this value, ensuring the model sufficiently learns basic features during warmup.
-                max_cached_steps (`int`, *required*, defaults to -1):
-                    DBCache disables the caching strategy when the previous cached steps exceed this value to
-                    prevent precision degradation.
-                max_continuous_cached_steps (`int`, *required*, defaults to -1):
-                    DBCache disables the caching strategy when the previous continous cached steps exceed this value to
-                    prevent precision degradation.
-                enable_separate_cfg (`bool`, *required*,  defaults to None):
-                    Whether to do separate cfg or not, such as Wan 2.1, Qwen-Image. For model that fused CFG
-                    and non-CFG into single forward step, should set enable_separate_cfg as False, for example:
-                    CogVideoX, HunyuanVideo, Mochi, etc.
-                cfg_compute_first (`bool`, *required*,  defaults to False):
-                    Compute cfg forward first or not, default False, namely, 0, 2, 4, ..., -> non-CFG step;
-                    1, 3, 5, ... -> CFG step.
-                cfg_diff_compute_separate (`bool`, *required*,  defaults to True):
-                    Compute separate diff values for CFG and non-CFG step, default True. If False, we will
-                    use the computed diff from current non-CFG transformer step for current CFG step.
-        calibrator_config (`CalibratorConfig`, *optional*, defaults to None):
-            Config for calibrator, if calibrator_config is not None, means that user want to use DBCache
-            with specific calibrator, such as taylorseer, foca, and so on.
-        params_modifiers ('ParamsModifier', *optional*, defaults to None):
-            Modify cache context params for specific blocks. The configurable params listed belows:
-                cache_config (`BasicCacheConfig`, *required*, defaults to BasicCacheConfig()):
-                    The same as 'cache_config' param in cache_dit.enable_cache() interface.
-                calibrator_config (`CalibratorConfig`, *optional*, defaults to None):
-                    The same as 'calibrator_config' param in cache_dit.enable_cache() interface.
-                **kwargs: (`dict`, *optional*, defaults to {}):
-                    The same as 'kwargs' param in cache_dit.enable_cache() interface.
-        kwargs (`dict`, *optional*, defaults to {})
-            Other cache context kwargs, please check https://github.com/vipshop/cache-dit/blob/main/src/cache_dit/cache_factory/cache_contexts/cache_context.py
-            for more details.
-
-    Examples:
-    ```py
-    >>> import cache_dit
-    >>> from diffusers import DiffusionPipeline
-    >>> pipe = DiffusionPipeline.from_pretrained("Qwen/Qwen-Image") # Can be any diffusion pipeline
-    >>> cache_dit.enable_cache(pipe) # One-line code with default cache options.
-    >>> output = pipe(...) # Just call the pipe as normal.
-    >>> stats = cache_dit.summary(pipe) # Then, get the summary of cache acceleration stats.
-    >>> cache_dit.disable_cache(pipe) # Disable cache and run original pipe.
-    """
-    # Collect cache context kwargs
-    cache_context_kwargs = {}
-    if (cache_type := cache_context_kwargs.pop("cache_type", None)) is not None:
-        if cache_type == CacheType.NONE:
-            return pipe_or_adapter
-
-    # WARNING: Deprecated cache config params. These parameters are now retained
-    # for backward compatibility but will be removed in the future.
-    deprecated_cache_kwargs = {
-        "Fn_compute_blocks": kwargs.get("Fn_compute_blocks", None),
-        "Bn_compute_blocks": kwargs.get("Bn_compute_blocks", None),
-        "max_warmup_steps": kwargs.get("max_warmup_steps", None),
-        "max_cached_steps": kwargs.get("max_cached_steps", None),
-        "max_continuous_cached_steps": kwargs.get(
-            "max_continuous_cached_steps", None
-        ),
-        "residual_diff_threshold": kwargs.get("residual_diff_threshold", None),
-        "enable_separate_cfg": kwargs.get("enable_separate_cfg", None),
-        "cfg_compute_first": kwargs.get("cfg_compute_first", None),
-        "cfg_diff_compute_separate": kwargs.get(
-            "cfg_diff_compute_separate", None
-        ),
-    }
-
-    deprecated_cache_kwargs = {
-        k: v for k, v in deprecated_cache_kwargs.items() if v is not None
-    }
-
-    if deprecated_cache_kwargs:
-        logger.warning(
-            "Manually settup DBCache context without BasicCacheConfig is "
-            "deprecated and will be removed in the future, please use "
-            "`cache_config` parameter instead!"
-        )
-        if cache_config is not None:
-            cache_config.update(**deprecated_cache_kwargs)
-        else:
-            cache_config = BasicCacheConfig(**deprecated_cache_kwargs)
-
-    if cache_config is not None:
-        cache_context_kwargs["cache_config"] = cache_config
-
-    # WARNING: Deprecated taylorseer params. These parameters are now retained
-    # for backward compatibility but will be removed in the future.
-    if (
-        kwargs.get("enable_taylorseer", None) is not None
-        or kwargs.get("enable_encoder_taylorseer", None) is not None
-    ):
-        logger.warning(
-            "Manually settup TaylorSeer calibrator without TaylorSeerCalibratorConfig is "
-            "deprecated and will be removed in the future, please use "
-            "`calibrator_config` parameter instead!"
-        )
-        from cache_dit.cache_factory.cache_contexts.calibrators import (
-            TaylorSeerCalibratorConfig,
-        )
-
-        calibrator_config = TaylorSeerCalibratorConfig(
-            enable_calibrator=kwargs.get("enable_taylorseer"),
-            enable_encoder_calibrator=kwargs.get("enable_encoder_taylorseer"),
-            calibrator_cache_type=kwargs.get(
-                "taylorseer_cache_type", "residual"
-            ),
-            taylorseer_order=kwargs.get("taylorseer_order", 1),
-        )
-
-    if calibrator_config is not None:
-        cache_context_kwargs["calibrator_config"] = calibrator_config
-
-    if params_modifiers is not None:
-        cache_context_kwargs["params_modifiers"] = params_modifiers
-
-    if isinstance(pipe_or_adapter, (DiffusionPipeline, BlockAdapter)):
-        return CachedAdapter.apply(
-            pipe_or_adapter,
-            **cache_context_kwargs,
-        )
-    else:
-        raise ValueError(
-            f"type: {type(pipe_or_adapter)} is not valid, "
-            "Please pass DiffusionPipeline or BlockAdapter"
-            "for the 1's position param: pipe_or_adapter"
-        )
-
-
-def disable_cache(
-    pipe_or_adapter: Union[
-        DiffusionPipeline,
-        BlockAdapter,
-    ],
-):
-    CachedAdapter.maybe_release_hooks(pipe_or_adapter)
-    logger.warning(
-        f"Cache Acceleration is disabled for: "
-        f"{pipe_or_adapter.__class__.__name__}."
-    )
-
-
-def supported_pipelines(
-    **kwargs,
-) -> Tuple[int, List[str]]:
-    return BlockAdapterRegistry.supported_pipelines(**kwargs)
-
-
-def get_adapter(
-    pipe: DiffusionPipeline | str | Any,
-) -> BlockAdapter:
-    return BlockAdapterRegistry.get_adapter(pipe)

cache_dit/cache_factory/patch_functors/__init__.py

@@ -1,12 +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,
-)