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

cache_dit/cache_factory/patch/flux.py

@@ -0,0 +1,241 @@
+import inspect
+
+import torch
+import numpy as np
+from typing import Tuple, Optional, Dict, Any, Union
+from diffusers import FluxTransformer2DModel
+from diffusers.models.transformers.transformer_flux import (
+    FluxSingleTransformerBlock,
+    Transformer2DModelOutput,
+)
+from diffusers.utils import (
+    USE_PEFT_BACKEND,
+    scale_lora_layers,
+    unscale_lora_layers,
+)
+
+
+from cache_dit.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+# copy from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_flux.py#L380
+def __patch_single_forward__(
+    self: FluxSingleTransformerBlock,
+    hidden_states: torch.Tensor,
+    encoder_hidden_states: torch.Tensor,
+    temb: torch.Tensor,
+    image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    joint_attention_kwargs: Optional[Dict[str, Any]] = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    text_seq_len = encoder_hidden_states.shape[1]
+    hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1)
+
+    residual = hidden_states
+    norm_hidden_states, gate = self.norm(hidden_states, emb=temb)
+    mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states))
+    joint_attention_kwargs = joint_attention_kwargs or {}
+    attn_output = self.attn(
+        hidden_states=norm_hidden_states,
+        image_rotary_emb=image_rotary_emb,
+        **joint_attention_kwargs,
+    )
+
+    hidden_states = torch.cat([attn_output, mlp_hidden_states], dim=2)
+    gate = gate.unsqueeze(1)
+    hidden_states = gate * self.proj_out(hidden_states)
+    hidden_states = residual + hidden_states
+    if hidden_states.dtype == torch.float16:
+        hidden_states = hidden_states.clip(-65504, 65504)
+
+    encoder_hidden_states, hidden_states = (
+        hidden_states[:, :text_seq_len],
+        hidden_states[:, text_seq_len:],
+    )
+    return encoder_hidden_states, hidden_states
+
+
+# copy from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_flux.py#L631
+def __patch_transformer_forward__(
+    self: FluxTransformer2DModel,
+    hidden_states: torch.Tensor,
+    encoder_hidden_states: torch.Tensor = None,
+    pooled_projections: torch.Tensor = None,
+    timestep: torch.LongTensor = None,
+    img_ids: torch.Tensor = None,
+    txt_ids: torch.Tensor = None,
+    guidance: torch.Tensor = None,
+    joint_attention_kwargs: Optional[Dict[str, Any]] = None,
+    controlnet_block_samples=None,
+    controlnet_single_block_samples=None,
+    return_dict: bool = True,
+    controlnet_blocks_repeat: bool = False,
+) -> Union[torch.Tensor, Transformer2DModelOutput]:
+    if joint_attention_kwargs is not None:
+        joint_attention_kwargs = joint_attention_kwargs.copy()
+        lora_scale = joint_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 (
+            joint_attention_kwargs is not None
+            and joint_attention_kwargs.get("scale", None) is not None
+        ):
+            logger.warning(
+                "Passing `scale` via `joint_attention_kwargs` when not using the PEFT backend is ineffective."
+            )
+
+    hidden_states = self.x_embedder(hidden_states)
+
+    timestep = timestep.to(hidden_states.dtype) * 1000
+    if guidance is not None:
+        guidance = guidance.to(hidden_states.dtype) * 1000
+
+    temb = (
+        self.time_text_embed(timestep, pooled_projections)
+        if guidance is None
+        else self.time_text_embed(timestep, guidance, pooled_projections)
+    )
+    encoder_hidden_states = self.context_embedder(encoder_hidden_states)
+
+    if txt_ids.ndim == 3:
+        logger.warning(
+            "Passing `txt_ids` 3d torch.Tensor is deprecated."
+            "Please remove the batch dimension and pass it as a 2d torch Tensor"
+        )
+        txt_ids = txt_ids[0]
+    if img_ids.ndim == 3:
+        logger.warning(
+            "Passing `img_ids` 3d torch.Tensor is deprecated."
+            "Please remove the batch dimension and pass it as a 2d torch Tensor"
+        )
+        img_ids = img_ids[0]
+
+    ids = torch.cat((txt_ids, img_ids), dim=0)
+    image_rotary_emb = self.pos_embed(ids)
+
+    if (
+        joint_attention_kwargs is not None
+        and "ip_adapter_image_embeds" in joint_attention_kwargs
+    ):
+        ip_adapter_image_embeds = joint_attention_kwargs.pop(
+            "ip_adapter_image_embeds"
+        )
+        ip_hidden_states = self.encoder_hid_proj(ip_adapter_image_embeds)
+        joint_attention_kwargs.update({"ip_hidden_states": ip_hidden_states})
+
+    for index_block, block in enumerate(self.transformer_blocks):
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            encoder_hidden_states, hidden_states = (
+                self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    temb,
+                    image_rotary_emb,
+                    joint_attention_kwargs,
+                )
+            )
+
+        else:
+            encoder_hidden_states, hidden_states = block(
+                hidden_states=hidden_states,
+                encoder_hidden_states=encoder_hidden_states,
+                temb=temb,
+                image_rotary_emb=image_rotary_emb,
+                joint_attention_kwargs=joint_attention_kwargs,
+            )
+
+        # controlnet residual
+        if controlnet_block_samples is not None:
+            interval_control = len(self.transformer_blocks) / len(
+                controlnet_block_samples
+            )
+            interval_control = int(np.ceil(interval_control))
+            # For Xlabs ControlNet.
+            if controlnet_blocks_repeat:
+                hidden_states = (
+                    hidden_states
+                    + controlnet_block_samples[
+                        index_block % len(controlnet_block_samples)
+                    ]
+                )
+            else:
+                hidden_states = (
+                    hidden_states
+                    + controlnet_block_samples[index_block // interval_control]
+                )
+
+    for index_block, block in enumerate(self.single_transformer_blocks):
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            encoder_hidden_states, hidden_states = (
+                self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    temb,
+                    image_rotary_emb,
+                    joint_attention_kwargs,
+                )
+            )
+
+        else:
+            encoder_hidden_states, hidden_states = block(
+                hidden_states=hidden_states,
+                encoder_hidden_states=encoder_hidden_states,
+                temb=temb,
+                image_rotary_emb=image_rotary_emb,
+                joint_attention_kwargs=joint_attention_kwargs,
+            )
+
+        # controlnet residual
+        if controlnet_single_block_samples is not None:
+            interval_control = len(self.single_transformer_blocks) / len(
+                controlnet_single_block_samples
+            )
+            interval_control = int(np.ceil(interval_control))
+            hidden_states = (
+                hidden_states
+                + controlnet_single_block_samples[
+                    index_block // interval_control
+                ]
+            )
+
+    hidden_states = self.norm_out(hidden_states, temb)
+    output = self.proj_out(hidden_states)
+
+    if USE_PEFT_BACKEND:
+        # remove `lora_scale` from each PEFT layer
+        unscale_lora_layers(self, lora_scale)
+
+    if not return_dict:
+        return (output,)
+
+    return Transformer2DModelOutput(sample=output)
+
+
+def maybe_patch_flux_transformer(
+    transformer: FluxTransformer2DModel,
+) -> FluxTransformer2DModel:
+    single_forward_parameters = inspect.signature(
+        transformer.single_transformer_blocks[0].forward
+    ).parameters.keys()
+    if "encoder_hidden_states" not in single_forward_parameters:
+        logger.warning("Patch FluxSingleTransformerBlock for cache-dit.")
+        for block in transformer.single_transformer_blocks:
+            block.forward = __patch_single_forward__.__get__(block)
+
+        assert not getattr(transformer, "_is_parallelized", False), (
+            "Please call apply_cache_on_pipe before Parallelize, "
+            "the __patch_transformer_forward__ will overwrite the "
+            "parallized forward and cause a downgrade of performance."
+        )
+        transformer.forward = __patch_transformer_forward__.__get__(transformer)
+        transformer._is_patched = True
+
+    return transformer

{cache_dit-0.2.14.dist-info → cache_dit-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cache_dit
-Version: 0.2.14
+Version: 0.2.16
 Summary: 🤗 CacheDiT: A Training-free and Easy-to-use Cache Acceleration Toolbox for Diffusion Transformers
 Author: DefTruth, vipshop.com, etc.
 Maintainer: DefTruth, vipshop.com, etc
@@ -52,20 +52,22 @@ Dynamic: requires-python
       <img src=https://img.shields.io/badge/Python-3.10|3.11|3.12-9cf.svg >
       <img src=https://img.shields.io/badge/Release-v0.2-brightgreen.svg >
  </div>
-  <p align="center">
-    DeepCache is for UNet not DiT. Most DiT cache speedups are complex and not training-free. <br> CacheDiT offers a set of training-free cache accelerators for Diffusion Transformers: <br> <b>🔥<a href="#dbcache">DBCache</a>, <a href="#dbprune">DBPrune</a>, <a href="#taylorseer">Hybrid TaylorSeer</a>, <a href="#cfg">Hybrid Cache CFG</a>, <a href="#fbcache">FBCache</a></b>, etc🔥
-  </p>
+   🔥<a href="#dbcache">DBCache</a> | <a href="#dbprune">DBPrune</a> | <a href="#taylorseer">Hybrid TaylorSeer</a> | <a href="#cfg">Hybrid Cache CFG</a> | <a href="#fbcache">FBCache</a>🔥
 </div>
 
 <div align="center">
   <p align="center">
-    <b>♥️ Please consider to leave a ⭐️ Star to support us ~ ♥️</b>
+    ♥️ Please consider to leave a ⭐️ Star to support us ~ ♥️
   </p>
 </div> 
 
-## 🔥News🔥
-- [2025-07-18] 🎉First caching mechanism in **[🤗huggingface/flux-fast](https://github.com/huggingface/flux-fast)** with **[cache-dit](https://github.com/vipshop/cache-dit)**, also check the **[PR](https://github.com/huggingface/flux-fast/pull/13)**. 
-- [2025-07-13] **[🤗flux-faster](https://github.com/xlite-dev/flux-faster)** is released! A forked version of **[🤗huggingface/flux-fast](https://github.com/huggingface/flux-fast)** that **makes flux-fast even faster** with **[cache-dit](https://github.com/vipshop/cache-dit)**, **3.3x** speedup on NVIDIA L20.
+## 🔥News  
+
+- [2025-08-12] 🎉First caching mechanism in [QwenLM/Qwen-Image](https://github.com/QwenLM/Qwen-Image) with **[cache-dit](https://github.com/vipshop/cache-dit)**, check the [PR](https://github.com/QwenLM/Qwen-Image/pull/61). 
+- [2025-08-11] 🔥[Qwen-Image](https://github.com/QwenLM/Qwen-Image) is supported now! Please check [run_qwen_image.py](./examples/run_qwen_image.py) as an example.
+- [2025-08-10] 🔥[FLUX.1-Kontext-dev](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev) is supported! Please check [run_flux_kontext.py](./examples/run_flux_kontext.py) as an example.
+- [2025-07-18] 🎉First caching mechanism in [🤗huggingface/flux-fast](https://github.com/huggingface/flux-fast) with **[cache-dit](https://github.com/vipshop/cache-dit)**, check the [PR](https://github.com/huggingface/flux-fast/pull/13). 
+- [2025-07-13] **[🤗flux-faster](https://github.com/xlite-dev/flux-faster)** is released! **3.3x** speedup for FLUX.1 on NVIDIA L20 with `cache-dit`.
 
 ## 📖Contents 
 
@@ -78,7 +80,6 @@ Dynamic: requires-python
 - [⚡️Hybrid Cache CFG](#cfg)
 - [🎉First Block Cache](#fbcache)
 - [⚡️Dynamic Block Prune](#dbprune)
-- [🎉Context Parallelism](#context-parallelism)  
 - [🔥Torch Compile](#compile)
 - [⚙️Metrics CLI](#metrics)
 - [👋Contribute](#contribute)
@@ -104,8 +105,10 @@ pip3 install git+https://github.com/vipshop/cache-dit.git
 
 <div id="supported"></div>
 
+- [🚀Qwen-Image](https://github.com/vipshop/cache-dit/raw/main/examples)  
 - [🚀FLUX.1-dev](https://github.com/vipshop/cache-dit/raw/main/examples)  
 - [🚀FLUX.1-Fill-dev](https://github.com/vipshop/cache-dit/raw/main/examples)  
+- [🚀FLUX.1-Kontext-dev](https://github.com/vipshop/cache-dit/raw/main/examples)  
 - [🚀mochi-1-preview](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀CogVideoX](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀CogVideoX1.5](https://github.com/vipshop/cache-dit/raw/main/examples)
@@ -157,7 +160,7 @@ These case studies demonstrate that even with relatively high thresholds (such a
 - **max_cached_steps**:  (default: -1) DBCache disables the caching strategy when the previous cached steps exceed this value to prevent precision degradation.
 - **residual_diff_threshold**: The value of residual diff threshold, a higher value leads to faster performance at the cost of lower precision.
 
-For a good balance between performance and precision, DBCache is configured by default with **F8B8**, 8 warmup steps, and unlimited cached steps.
+For a good balance between performance and precision, DBCache is configured by default with **F8B0**, 8 warmup steps, and unlimited cached steps.
 
 ```python
 from diffusers import FluxPipeline
@@ -168,16 +171,16 @@ pipe = FluxPipeline.from_pretrained(
     torch_dtype=torch.bfloat16,
 ).to("cuda")
 
-# Default options, F8B8, good balance between performance and precision
+# Default options, F8B0, good balance between performance and precision
 cache_options = CacheType.default_options(CacheType.DBCache)
 
-# Custom options, F8B16, higher precision
+# Custom options, F8B0, higher precision
 cache_options = {
     "cache_type": CacheType.DBCache,
     "warmup_steps": 8,
-    "max_cached_steps": 8,    # -1 means no limit
-    "Fn_compute_blocks": 8,   # Fn, F8, etc.
-    "Bn_compute_blocks": 16,  # Bn, B16, etc.
+    "max_cached_steps": -1, # -1 means no limit
+    "Fn_compute_blocks": 8, # Fn, F8, etc.
+    "Bn_compute_blocks": 0, # Bn, B0, etc.
     "residual_diff_threshold": 0.12,
 }
 
@@ -253,7 +256,7 @@ cache_options = {
     # should set do_separate_classifier_free_guidance as False.
     # For example, set it as True for Wan 2.1 and set it as False 
     # for FLUX.1, HunyuanVideo, CogVideoX, Mochi.
-    "do_separate_classifier_free_guidance": True,  # Wan 2.1
+    "do_separate_classifier_free_guidance": True, # Wan 2.1, Qwen-Image
     # Compute cfg forward first or not, default False, namely, 
     # 0, 2, 4, ..., -> non-CFG step; 1, 3, 5, ... -> CFG step.
     "cfg_compute_first": False,
@@ -270,7 +273,7 @@ cache_options = {
 
 ![](https://github.com/vipshop/cache-dit/raw/main/assets/fbcache-v1.png)
 
-**DBCache** is a more general cache algorithm than **FBCache**. When Fn=1 and Bn=0, DBCache behaves identically to FBCache. Therefore, you can either use the original FBCache implementation directly or configure **DBCache** with **F1B0** settings to achieve the same functionality.
+**DBCache** is a more general cache algorithm than **FBCache**. When Fn=1 and Bn=0, DBCache behaves identically to FBCache. Therefore, you can use configure **DBCache** with **F1B0** settings to achieve the same functionality.
 
 ```python
 from diffusers import FluxPipeline
@@ -281,15 +284,12 @@ pipe = FluxPipeline.from_pretrained(
     torch_dtype=torch.bfloat16,
 ).to("cuda")
 
-# Using FBCache directly
-cache_options = CacheType.default_options(CacheType.FBCache)
-
 # Or using DBCache with F1B0. 
 # Fn=1, Bn=0, means FB Cache, otherwise, Dual Block Cache
 cache_options = {
     "cache_type": CacheType.DBCache,
     "warmup_steps": 8,
-    "max_cached_steps": 8,   # -1 means no limit
+    "max_cached_steps": -1,  # -1 means no limit
     "Fn_compute_blocks": 1,  # Fn, F1, etc.
     "Bn_compute_blocks": 0,  # Bn, B0, etc.
     "residual_diff_threshold": 0.12,
@@ -370,64 +370,6 @@ apply_cache_on_pipe(pipe, **cache_options)
 |24.85s|19.43s|16.82s|15.95s|14.24s|10.66s|
 |<img src=https://github.com/vipshop/cache-dit/raw/main/assets/NONE_R0.08_S0.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/DBPRUNE_F1B0_R0.03_P24.0_T19.43s.png width=105px> | <img src=https://github.com/vipshop/cache-dit/raw/main/assets/DBPRUNE_F1B0_R0.04_P34.6_T16.82s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/DBPRUNE_F1B0_R0.05_P38.3_T15.95s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/DBPRUNE_F1B0_R0.06_P45.2_T14.24s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/DBPRUNE_F1B0_R0.2_P59.5_T10.66s.png width=105px>|
 
-## 🎉Context Parallelism
-
-<div id="context-parallelism"></div>  
-
-**CacheDiT** are **plug-and-play** solutions that works hand-in-hand with [ParaAttention](https://github.com/chengzeyi/ParaAttention). Users can **easily tap into** its **Context Parallelism** features for distributed inference. Firstly, install `para-attn` from PyPI:
-
-```bash
-pip3 install para-attn  # or install `para-attn` from sources.
-```
-
-Then, you can run **DBCache** or **DBPrune** with **Context Parallelism** on 4 GPUs:
-
-```python
-import torch.distributed as dist
-from diffusers import FluxPipeline
-from para_attn.context_parallel import init_context_parallel_mesh
-from para_attn.context_parallel.diffusers_adapters import parallelize_pipe
-from cache_dit.cache_factory import apply_cache_on_pipe, CacheType
-
-# Init distributed process group
-dist.init_process_group()
-torch.cuda.set_device(dist.get_rank())
-
-pipe = FluxPipeline.from_pretrained(
-    "black-forest-labs/FLUX.1-dev",
-    torch_dtype=torch.bfloat16,
-).to("cuda")
-
-# Context Parallel from ParaAttention
-parallelize_pipe(
-    pipe, mesh=init_context_parallel_mesh(
-        pipe.device.type, max_ulysses_dim_size=4
-    )
-)
-
-# DBPrune with default options from this library
-apply_cache_on_pipe(
-    pipe, **CacheType.default_options(CacheType.DBPrune)
-)
-
-dist.destroy_process_group()
-```
-Then, run the python test script with `torchrun`:
-```bash
-torchrun --nproc_per_node=4 parallel_cache.py
-```
-
-<div align="center">
-  <p align="center">
-  DBPrune + <b>torch.compile + context parallelism</b> <br>Steps: 28, "A cat holding a sign that says hello world with complex background"
-  </p>
-</div>
-
-|Baseline|Pruned(24%)|Pruned(35%)|Pruned(38%)|Pruned(45%)|Pruned(60%)|
-|:---:|:---:|:---:|:---:|:---:|:---:|
-|+compile:20.43s|16.25s|14.12s|13.41s|12.00s|8.86s|
-|+L20x4:7.75s|6.62s|6.03s|5.81s|5.24s|3.93s|
-|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_NONE_R0.08_S0_T20.43s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_DBPRUNE_F1B0_R0.03_P24.0_T16.25s.png width=105px> | <img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_DBPRUNE_F1B0_R0.04_P34.6_T14.12s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_DBPRUNE_F1B0_R0.045_P38.2_T13.41s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_DBPRUNE_F1B0_R0.055_P45.1_T12.00s.png width=105px>|<img src=https://github.com/vipshop/cache-dit/raw/main/assets/U0_C1_DBPRUNE_F1B0_R0.2_P59.5_T8.86s.png width=105px>|
 
 ## 🔥Torch Compile
 
@@ -490,7 +432,7 @@ How to contribute? Star ⭐️ this repo to support us or check [CONTRIBUTE.md](
 
 <div id="license"></div>
 
-The **CacheDiT** codebase is adapted from [FBCache](https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache). Special thanks to their excellent work! We have followed the original License from [FBCache](https://github.com/chengzeyi/ParaAttention), please check [LICENSE](https://github.com/vipshop/cache-dit/raw/main/LICENSE) for more details.
+The **CacheDiT** codebase is adapted from [FBCache](https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache). Special thanks to their excellent work! We have followed the original License from FBCache, please check [LICENSE](https://github.com/vipshop/cache-dit/raw/main/LICENSE) for more details.
 
 ## ©️Citations
 

cache_dit-0.2.16.dist-info/RECORD

@@ -0,0 +1,47 @@
+cache_dit/__init__.py,sha256=0-B173-fLi3IA8nJXoS71zK0zD33Xplysd9skmLfEOY,171
+cache_dit/_version.py,sha256=uFGhweCFKwebVyMUvDALfnhYcWJQj8O3h_9xJIOhTtk,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=2UuUJ-CRXrLbv_ZoC2nV3qPHoipfqeWvO7xZO3CxOD4,263
+cache_dit/cache_factory/adapters.py,sha256=3iHIkhkb_2s1f-W-jw0bCToZyLYvbJlPpxASv4EqrqU,6714
+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=gkouVv5IgcsiTOQ5_I-a3S3TnJifNZhrwdkrO1KRCqw,120
+cache_dit/cache_factory/dual_block_cache/cache_blocks.py,sha256=M9R_6t-X6vrsSNvSMQLn24I_fZ9EpFK4RlRzgAtEdac,18407
+cache_dit/cache_factory/dual_block_cache/cache_context.py,sha256=28g3lqgsarCk-u880QF0yl967glXIZrWpUfJYKJZqxg,39872
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/__init__.py,sha256=uSqF5aD2-feHB25vEbx1STBQVjWVAOn_wYTdAEmS4NU,2045
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/cogvideox.py,sha256=RNF24Ysuddo5cjv4hUT4s3C4C3pgud5YJ1OklvtrrlU,2286
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/flux.py,sha256=URWqROg_ANseraFf-on5ZqvJzD7tH3WouboFaJgOAkk,2853
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/hunyuan_video.py,sha256=y0Ab_tTJOixTaK-Remg5IZLCDGIgBOZFszI32PnK9gc,9981
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/mochi.py,sha256=nqpbVjT0vFecIIqVGBvCUIBysOtFFjh-MhrXw4VPBGo,2278
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/qwen_image.py,sha256=qhwpGDxx5RBbumSArc38z4aMv5YVwxH3eiyIpzjXycQ,2322
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/wan.py,sha256=P9-r0HNofBO8rWpB4pAQvGOEbsfiHUAKV16Noq8ZzWg,2610
+cache_dit/cache_factory/dynamic_block_prune/__init__.py,sha256=d_cbjrkBaprzQw4HJI3sRtqMzrhDVL56moLkpSGnqO4,123
+cache_dit/cache_factory/dynamic_block_prune/prune_blocks.py,sha256=6L9WhuWP6GHFRLnGRO_XZ1oE4v9xm-yqQ7cgNP_fOdY,9704
+cache_dit/cache_factory/dynamic_block_prune/prune_context.py,sha256=94e0VKmbU09hb-s8JQ9vOYTJtZ07gva7XT9OQm8EBSc,25530
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/__init__.py,sha256=9WLorIqd7m_dIDs6pPPj-lcd9e56fdvGM2D3DDdWwEU,2045
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/cogvideox.py,sha256=Ny1f3gvtcbVbTvGXNdyv7YC2Ez1rGonttx7xnsvfHM4,2299
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/flux.py,sha256=ibANvG29Sa2CU2pG_IndkEYarshuQDWGTP3klnAStV0,2792
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/hunyuan_video.py,sha256=ylNgdkCgFwWbuCb2sbyIV6XoHTd8MzGbgMO0t1Z6D50,9994
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/mochi.py,sha256=iMZd473vkh2hsJRIlKN2DCsCRJmsV4JSB7SZzZdg4eI,2291
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/qwen_image.py,sha256=0MgHcT4EVUcUnq8-g4GO2p11MzMtRhQp5D3wG9t_KlA,2398
+cache_dit/cache_factory/dynamic_block_prune/diffusers_adapters/wan.py,sha256=VOdnpIZRbcyKHP7e4yRPSlS5hZSyq4dcp9fmHOfI-Fc,2630
+cache_dit/cache_factory/patch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cache_dit/cache_factory/patch/flux.py,sha256=zRUWZlt02vZGJcK2WOfmSbGR4UOUvsFvSBDgeBNZxh8,8813
+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.16.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
+cache_dit-0.2.16.dist-info/METADATA,sha256=y8oidHX3B0iZXfjym_mHtGgB0fGE4fiEA6JIlIeWaRo,22769
+cache_dit-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cache_dit-0.2.16.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
+cache_dit-0.2.16.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
+cache_dit-0.2.16.dist-info/RECORD,,