cache-dit 0.1.1.dev2__tar.gz

cache_dit-0.1.1.dev2/.github/workflows/issue.yml

@@ -0,0 +1,22 @@
+name: issues
+on:
+  schedule:
+    - cron: "0 0 * * 0"
+
+jobs:
+  close-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+    - uses: actions/stale@v9.0.0
+      with:
+        days-before-issue-stale: 30
+        days-before-issue-close: 7
+        stale-issue-label: "stale"
+        stale-issue-message: "This issue is stale because it has been open for 30 days with no activity."
+        close-issue-message: "This issue was closed because it has been inactive for 7 days since being marked as stale."
+        days-before-pr-stale: -1
+        days-before-pr-close: -1
+        repo-token: ${{ secrets.GITHUB_TOKEN }}

cache_dit-0.1.1.dev2/.gitignore

@@ -0,0 +1,167 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+_version.py
+
+report*.html
+
+.DS_Store
+tmp

cache_dit-0.1.1.dev2/.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+      - id: check-docstring-first
+      - id: check-toml
+      - id: check-yaml
+        exclude: packaging/.*
+        args:
+          - --allow-multiple-documents
+      - id: mixed-line-ending
+        args: [--fix=lf]
+      - id: end-of-file-fixer
+      
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+        args: [--config=setup.cfg]
+
+  - repo: https://github.com/PyCQA/pydocstyle
+    rev: 6.1.1
+    hooks:
+      - id: pydocstyle
+
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black-jupyter
+        args:
+          - --line-length=80

cache_dit-0.1.1.dev2/CONTRIBUTE.md

@@ -0,0 +1,28 @@
+# Developer Guide
+
+## 👨‍💻Pre-commit
+
+Before submitting code, configure pre-commit, for example:
+
+```bash
+# fork vipshop/DBCache to your own github page, then:
+git clone git@github.com:your-github-page/your-fork-DBCache.git
+cd your-fork-DBCache && git checkout -b dev
+# update submodule
+git submodule update --init --recursive --force
+# install pre-commit
+pip3 install pre-commit
+pre-commit install
+pre-commit run --all-files
+```
+
+## 👨‍💻Add a new feature
+
+```bash
+# feat: support xxx-cache method
+# add your commits
+git add .
+git commit -m "support xxx-cache method"
+git push
+# then, open a PR from your personal branch to DBCache:main
+```

cache_dit-0.1.1.dev2/LICENSE

@@ -0,0 +1,53 @@
+# 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.

cache_dit-0.1.1.dev2/MANIFEST.in

@@ -0,0 +1,6 @@
+include MANIFEST.in
+include LICENSE
+include requirements.txt
+recursive-include tests *
+prune */__pycache__
+global-exclude *.o *.so *.dylib *.a .git *.pyc *.swp

cache_dit-0.1.1.dev2/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: cache_dit
+Version: 0.1.1.dev2
+Summary: ⚡️DBCache: A Training-free UNet-style Cache Acceleration for Diffusion Transformers
+Author: DefTruth, vipshop.com, etc.
+Maintainer: DefTruth, vipshop.com, etc
+Project-URL: Repository, https://github.com/vipshop/DBCache.git
+Project-URL: Homepage, https://github.com/vipshop/DBCache.git
+Requires-Python: >=3.10
+Requires-Dist: packaging
+Requires-Dist: torch
+Requires-Dist: transformers
+Requires-Dist: diffusers
+Provides-Extra: all
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest<8.0.0,>=7.0.0; extra == "dev"
+Requires-Dist: pytest-html; extra == "dev"
+Requires-Dist: expecttest; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: transformers; extra == "dev"
+Requires-Dist: diffusers; extra == "dev"
+Requires-Dist: accelerate; extra == "dev"
+Requires-Dist: peft; extra == "dev"
+Requires-Dist: protobuf; extra == "dev"
+Requires-Dist: sentencepiece; extra == "dev"
+Requires-Dist: opencv-python-headless; extra == "dev"
+Requires-Dist: ftfy; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python

cache_dit-0.1.1.dev2/README.md

@@ -0,0 +1,320 @@
+<div align="center">
+  <p align="center">
+    <h3>⚡️DBCache: A Training-free UNet-style Cache Acceleration for <br>Diffusion Transformers</h2>
+  </p>
+   <img src=./assets/DBCache.png >
+  <div align='center'>
+        <img src=https://img.shields.io/badge/Language-Python-brightgreen.svg >
+        <img src=https://img.shields.io/badge/PRs-welcome-9cf.svg >
+        <img src=https://img.shields.io/badge/Build-pass-brightgreen.svg >
+        <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.1.0-brightgreen.svg >
+ </div>
+  <p align="center">
+    DeepCache requires UNet’s U-shape, but DiT lacks it. Most DiT cache accelerators are complex and not training-free. DBCache builds on FBCache to create a training-free, UNet-style cache accelerator for DiT.
+  </p>
+</div>
+
+## 🤗 Introduction 
+
+<div align="center">
+  <p align="center">
+    <h3>DBCache: Dual Block Caching for Diffusion Transformers</h3>
+  </p>
+</div> 
+
+**DBCache**: **Dual Block Caching** for Diffusion Transformers. We have enhanced `FBCache` into a more general and customizable cache algorithm, namely `DBCache`, enabling it to achieve fully `UNet-style` cache acceleration for DiT models. Different configurations of compute blocks (**F8B12**, etc.) can be customized in DBCache. Moreover, it can be entirely **training**-**free**. DBCache can strike a perfect **balance** between performance and precision!
+
+<div align="center">
+  <p align="center">
+    DBCache, <b> L20x1 </b>, Steps: 28, "A cat holding a sign that says hello world with complex background"
+  </p>
+</div>
+
+|Baseline(L20x1)|F1B0 (0.08)|F1B0 (0.20)|F8B8 (0.15)|F12B12 (0.20)|F16B16 (0.20)|
+|:---:|:---:|:---:|:---:|:---:|:---:|
+|24.85s|15.59s|8.58s|15.41s|15.11s|17.74s|
+|<img src=./assets/NONE_R0.08_S0.png width=105px>|<img src=./assets/DBCACHE_F1B0S1_R0.08_S11.png width=105px> | <img src=./assets/DBCACHE_F1B0S1_R0.2_S19.png width=105px>|<img src=./assets/DBCACHE_F8B8S1_R0.15_S15.png width=105px>|<img src=./assets/DBCACHE_F12B12S4_R0.2_S16.png width=105px>|<img src=./assets/DBCACHE_F16B16S4_R0.2_S13.png width=105px>|
+|**Baseline(L20x1)**|**F1B0 (0.08)**|**F8B8 (0.12)**|**F8B12 (0.20)**|**F8B16 (0.20)**|**F8B20 (0.20)**|
+|27.85s|6.04s|5.88s|5.77s|6.01s|6.20s|
+|<img src=https://github.com/user-attachments/assets/70ea57f4-d8f2-415b-8a96-d8315974a5e6 width=105px>|<img src=https://github.com/user-attachments/assets/fc0e1a67-19cc-44aa-bf50-04696e7978a0 width=105px> |<img src=https://github.com/user-attachments/assets/d1434896-628c-436b-95ad-43c085a8629e width=105px>|<img src=https://github.com/user-attachments/assets/aaa42cd2-57de-4c4e-8bfb-913018a8251d width=105px>|<img src=https://github.com/user-attachments/assets/dc0ba2a4-ef7c-436d-8a39-67055deab92f width=105px>|<img src=https://github.com/user-attachments/assets/aede466f-61ed-4256-8df0-fecf8020c5ca width=105px>|
+
+<div align="center">
+  <p align="center">
+     DBCache, <b> L20x4 </b>, Steps: 20, case to show the texture recovery ability of DBCache
+  </p>
+</div>
+
+These case studies demonstrate that even with relatively high thresholds (such as 0.12, 0.15, 0.2, etc.) under the DBCache **F12B12** or **F8B16** configuration, the detailed texture of the kitten's fur, colored cloth, and the clarity of text can still be preserved. This suggests that users can leverage DBCache to effectively balance performance and precision in their workflows! 
+
+<div align="center">
+  <p align="center">
+    <h3>DBPrune: Dynamic Block Prune with Residual Caching</h3>
+  </p>
+</div> 
+
+**DBPrune**: Dynamic Block Prune algorithm with Residual Caching. We have further implemented a new Dynamic Block Prune algorithm based on residual caching for Diffusion Transformers, referred to as DBPrune. DBPrune is currently in the experimental phase, and we kindly invite you to stay tuned for upcoming updates.
+
+|Baseline(L20x1)|Pruned(24%)|Pruned(35%)|Pruned(38%)|Pruned(45%)|Pruned(60%)|
+|:---:|:---:|:---:|:---:|:---:|:---:|
+|24.85s|19.43s|16.82s|15.95s|14.24s|10.66s|
+|<img src=./assets/NONE_R0.08_S0.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.03_P24.0_T19.43s.png width=105px> | <img src=./assets/DBPRUNE_F1B0_R0.04_P34.6_T16.82s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.05_P38.3_T15.95s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.06_P45.2_T14.24s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.2_P59.5_T10.66s.png width=105px>|
+
+<div align="center">
+  <p align="center">
+    DBPrune, <b> L20x1 </b>, Steps: 28, "A cat holding a sign that says hello world with complex background"
+  </p>
+</div>
+
+Moreover, both DBCache and DBPrune 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.
+
+## ©️Citations
+
+```BibTeX
+@misc{DBCache@2025,
+  title={DBCache: A Training-free UNet-style Cache Acceleration for Diffusion Transformers},
+  url={https://github.com/vipshop/DBCache.git},
+  note={Open-source software available at https://github.com/vipshop/DBCache.git},
+  author={vipshop.com},
+  year={2025}
+}
+```
+
+## 👋Reference
+
+<div id="reference"></div>
+
+**DBCache** is built upon **FBCache**. The **DBCache** codebase was adapted from FBCache's implementation at the [ParaAttention](https://github.com/chengzeyi/ParaAttention/tree/main/src/para_attn/first_block_cache). We would like to express our sincere gratitude for this excellent work!
+
+## 📖Contents 
+
+<div id="contents"></div>  
+
+- [⚙️Installation](#️installation)
+- [⚡️Dual Block Cache](#dbcache)
+- [🎉First Block Cache](#fbcache)
+- [⚡️Dynamic Block Prune](#dbprune)
+- [🎉Context Parallelism](#context-parallelism)  
+- [⚡️Torch Compile](#compile)
+- [🎉Supported Models](#supported)
+- [👋Contribute](#contribute)
+- [©️License](#license)
+
+
+## ⚙️Installation  
+
+<div id="installation"></div>
+
+You can install `DBCache` from GitHub:
+
+```bash
+pip3 install git+https://github.com/vipshop/DBCache.git
+```
+
+or just install it from sources:
+
+```bash
+git clone https://github.com/vipshop/DBCache.git && cd DBCache
+pip3 install 'torch==2.7.0' 'setuptools>=64' 'setuptools_scm>=8'
+
+pip3 install -e '.[dev]' --no-build-isolation # build editable package
+python3 -m build && pip3 install ./dist/cache_dit-*.whl # or build whl first and then install it.
+```
+
+## ⚡️DBCache: Dual Block Cache  
+
+<div id="dbcache"></div>
+
+![](https://github.com/user-attachments/assets/c2a382b9-0ccd-46f4-aacc-87857b4a4de8)
+
+**DBCache** provides configurable parameters for custom optimization, enabling a balanced trade-off between performance and precision:
+
+- **Fn**: 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.
+- **Bn**: 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.
+- **warmup_steps**: (default: 0) 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**:  (default: -1) DBCache disables the caching strategy when the running 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.
+
+```python
+from diffusers import FluxPipeline
+from cache_dit.cache_factory import apply_cache_on_pipe, CacheType
+
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev",
+    torch_dtype=torch.bfloat16,
+).to("cuda")
+
+# Default options, F8B8, good balance between performance and precision
+cache_options = CacheType.default_options(CacheType.DBCache)
+
+# Custom options, F8B16, 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.
+    "residual_diff_threshold": 0.12,
+}
+
+apply_cache_on_pipe(pipe, **cache_options)
+```
+Moreover, users configuring higher **Bn** values (e.g., **F8B16**) while aiming to maintain good performance can specify **Bn_compute_blocks_ids** to work with Bn. DBCache will only compute the specified blocks, with the remaining estimated using the previous step's residual cache.
+
+```python
+# Custom options, F8B16, higher precision with good performance.
+cache_options = {
+    # 0, 2, 4, ..., 14, 15, etc. [0,16)
+    "Bn_compute_blocks_ids": CacheType.range(0, 16, 2),
+    # Skip Bn blocks (1, 3, 5 ,..., etc.) only if the L1 diff 
+    # lower than this value, otherwise, compute it.
+    "non_compute_blocks_diff_threshold": 0.08,
+}
+```
+
+## 🎉FBCache: First Block Cache  
+
+<div id="fbcache"></div>
+
+![](https://github.com/user-attachments/assets/0fb66656-b711-457a-92a7-a830f134272d)
+
+**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.
+
+```python
+from diffusers import FluxPipeline
+from cache_dit.cache_factory import apply_cache_on_pipe, CacheType
+
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev",
+    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
+    "Fn_compute_blocks": 1,  # Fn, F1, etc.
+    "Bn_compute_blocks": 0,  # Bn, B0, etc.
+    "residual_diff_threshold": 0.12,
+}
+
+apply_cache_on_pipe(pipe, **cache_options)
+```
+
+## ⚡️DBPrune: Dynamic Block Prune
+
+<div id="dbprune"></div>  
+
+![](https://github.com/user-attachments/assets/932b6360-9533-4352-b176-4c4d84bd4695)
+
+We have further implemented a new **Dynamic Block Prune** algorithm based on **Residual Caching** for Diffusion Transformers, which is referred to as **DBPrune**. DBPrune is currently in the experimental phase, and we kindly invite you to stay tuned for upcoming updates.
+
+```python
+from diffusers import FluxPipeline
+from cache_dit.cache_factory import apply_cache_on_pipe, CacheType
+
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev",
+    torch_dtype=torch.bfloat16,
+).to("cuda")
+
+# Using DBPrune
+cache_options = CacheType.default_options(CacheType.DBPrune)
+
+apply_cache_on_pipe(pipe, **cache_options)
+```
+
+<div align="center">
+  <p align="center">
+    DBPrune, <b> L20x1 </b>, Steps: 28, "A cat holding a sign that says hello world with complex background"
+  </p>
+</div>
+
+|Baseline(L20x1)|Pruned(24%)|Pruned(35%)|Pruned(38%)|Pruned(45%)|Pruned(60%)|
+|:---:|:---:|:---:|:---:|:---:|:---:|
+|24.85s|19.43s|16.82s|15.95s|14.24s|10.66s|
+|<img src=./assets/NONE_R0.08_S0.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.03_P24.0_T19.43s.png width=105px> | <img src=./assets/DBPRUNE_F1B0_R0.04_P34.6_T16.82s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.05_P38.3_T15.95s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.06_P45.2_T14.24s.png width=105px>|<img src=./assets/DBPRUNE_F1B0_R0.2_P59.5_T10.66s.png width=105px>|
+
+## 🎉Context Parallelism
+
+<div id="context-parallelism"></div>  
+
+DBCache and DBPrune 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** with **Context Parallelism** on 4 GPUs:
+
+```python
+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
+
+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
+    )
+)
+
+# DBCache with F8B8 from this library
+apply_cache_on_pipe(
+    pipe, **CacheType.default_options(CacheType.DBCache)
+)
+```
+
+## ⚡️Torch Compile
+
+<div id="compile"></div>  
+
+**DBCache** and **DBPrune** are designed to work compatibly with `torch.compile`. For example:
+
+```python
+apply_cache_on_pipe(
+    pipe, **CacheType.default_options(CacheType.DBCache)
+)
+# Compile the Transformer module
+pipe.transformer = torch.compile(pipe.transformer)
+```
+However, users intending to use DBCache and DBPrune for DiT with **dynamic input shapes** should consider increasing the **recompile** **limit** of `torch._dynamo` to achieve better performance. 
+
+```python
+torch._dynamo.config.recompile_limit = 96  # default is 8
+torch._dynamo.config.accumulated_recompile_limit = 2048  # default is 256
+```
+Otherwise, the recompile_limit error may be triggered, causing the module to fall back to eager mode.
+
+## 🎉Supported Models  
+
+<div id="supported"></div>
+
+- [🚀FLUX.1](./src/cache_dit/cache_factory/dual_block_cache/diffusers_adapters)
+- [🚀CogVideoX](./src/cache_dit/cache_factory/dual_block_cache/diffusers_adapters)
+- [🚀Mochi](./src/cache_dit/cache_factory/dual_block_cache/diffusers_adapters)
+
+## 👋Contribute 
+<div id="contribute"></div>
+
+How to contribute? Star this repo or check [CONTRIBUTE.md](./CONTRIBUTE.md).
+
+## ©️License   
+
+<div id="license"></div>
+
+
+We have followed the original License from [ParaAttention](https://github.com/chengzeyi/ParaAttention), please check [LICENSE](./LICENSE) for more details.